今天小编要跟大家分享的文章是关于Web前端工程师应该知道的JavaScript的10个难点。相信很多正在学习Web前端知识的小伙伴对于JavaScript存在很多疑问，为了帮助大家更好的学习Web前端知识，成为一名优秀的web前端工程师，今天小编为大家分享了这篇Web前端应该知道的JavaScript难点的问题，下面我们一起看一看吧！

1、立即执行函数

立即执行函数，即ImmediatelyInvokedFunctionExpression

(IIFE)，正如它的名字，就是创建函数的同时立即执行。它没有绑定任何事件，也无需等待任何异步操作：

1.(function(){

2.

3.//代码

4.

5.//...

6.

7.})()

function(){}是一个匿名函数，包围它的一对括号将其转换为一个表达式，紧跟其后的一对括号调用了这个函数。立即执行函数也可以理解为立即调用一个匿名函数。立即执行函数最常见的应用场景就是：将var变量的作用域限制于你们函数内，这样可以避免命名冲突。

2、闭包

对于闭包(closure)，当外部函数返回之后，内部函数依然可以访问外部函数的变量。

1.(function(){

2.

3.//代码

4.

5.//...

6.

7.})()

代码中，外部函数f1只执行了一次，变量N设为0，并将内部函数f2赋值给了变量result。由于外部函数f1已经执行完毕，其内部变量N应该在内存中被清除，然而事实并不是这样：我们每次调用result的时候，发现变量N一直在内存中，并且在累加。为什么呢?这就是闭包的神奇之处了!

3、使用闭包定义私有变量

通常，JavaScript开发者使用下划线作为私有变量的前缀。但是实际上，这些变量依然可以被访问和修改，并非真正的私有变量。这时，使用闭包可以定义真正的私有变量：

1.functionProduct(){

2.

3.varname

4.

5.this.setName=function(value){

6.name=value

7.}

8.

9.this.getName=function(){

10.returnname

11.}

12.}

13.

14.varp=newProduct()

15.p.setName("Fundebug")

16.

17.console.log(p.name)//输出undefined

18.console.log(p.getName())//输出Fundebug

代码中，对象p的的name属性为私有属性，使用p.name不能直接访问。

4、prototype

每个JavaScript构造函数都有一个prototype属性，用于设置所有实例对象需要共享的属性和方法。prototype属性不能列举。JavaScript仅支持通过prototype属性进行继承属性和方法。

1.functionRectangle(x,y)

2.{

3.this._length=x

4.this._breadth=y

5.}

6.

7.Rectangle.prototype.getDimensions=function()

8.{

9.return{

10.length:this._length,

11.breadth:this._breadth

12.}

13.}

14.

15.varx=newRectangle(3,4)

16.vary=newRectangle(4,3)

17.

18.console.log(x.getDimensions())//{length:3,breadth:4}

19.console.log(y.getDimensions())//{length:4,breadth:3}

代码中，x和y都是构造函数Rectangle创建的对象实例，它们通过prototype继承了getDimensions方法。

5、模块化

JavaScript并非模块化编程语言，至少ES6落地之前都不是。然而对于一个复杂的Web应用，模块化编程是一个最基本的要求。这时，可以使用立即执行函数来实现模块化，正如很多JS库比如jQuery以及我们Fundebug都是这样实现的。

1.varmodule=(function(){

2.varN=5

3.

4.functionprint(x){

5.console.log("Theresultis:"+x)

6.}

7.

8.functionadd(a){

9.varx=a+N

10.print(x)

11.}

12.

13.return{

14.description:"Thisisdescription",

15.add:add

16.}

17.})()

18.

19.

20.console.log(module.description)//输出"thisisdescription"

21.

22.module.add(5)//输出“Theresultis:10”

所谓模块化，就是根据需要控制模块内属性与方法的可访问性，即私有或者公开。在代码中，module为一个独立的模块，N为其私有属性，print为其私有方法，decription为其公有属性，add为其共有方法。

6、变量提升

JavaScript会将所有变量和函数声明移动到它的作用域的最前面，这就是所谓的变量提升(Hoisting)。也就是说，无论你在什么地方声明变量和函数，解释器都会将它们移动到作用域的最前面。因此我们可以先使用变量和函数，而后声明它们。但是，仅仅是变量声明被提升了，而变量赋值不会被提升。如果你不明白这一点，有时则会出错：

1.console.log(y)//输出undefined

2.

3.y=2//初始化y

上面的代码等价于下面的代码：

1.vary//声明y

2.

3.console.log(y)//输出undefined

4.

5.y=2//初始化y

为了避免BUG，开发者应该在每个作用域开始时声明变量和函数。

7、柯里化

柯里化，即Currying，可以是函数变得更加灵活。我们可以一次性传入多个参数调用它也可以只传入一部分参数来调用它，让它返回一个函数去处理剩下的参数。

1.varadd=function(x){

2.returnfunction(y){

3.returnx+y

4.}

5.}

6.

7.console.log(add(1)(1))//输出2

8.

9.varadd1=add(1)

10.console.log(add1(1))//输出2

11.

12.varadd10=add(10)

13.console.log(add10(1))//输出11

代码中，我们可以一次性传入2个1作为参数add(1)(1)，也可以传入1个参数之后获取add1与add10函数，这样使用起来非常灵活。

8、apply，call与bind方法

JavaScript开发者有必要理解apply、call与bind方法的不同点。它们的共同点是第一个参数都是this，即函数运行时依赖的上下文。

三者之中，call方法是最简单的，它等价于指定this值调用函数：

1.varuser={

2.name:"RahulMhatre",

3.whatIsYourName:function(){

4.console.log(this.name)

5.}

6.}

7.

8.user.whatIsYourName()//输出"RahulMhatre",

9.

10.varuser2={

11.name:"NehaSampat"

12.}

13.

14.user.whatIsYourName.call(user2)//输出"NehaSampat"

·apply方法与call方法类似。两者唯一的不同点在于，apply方法使用数组指定参数，而call方法每个参数单独需要指定：

·apply(thisArg,[argsArray])

1.varuser={

2.greet:"Hello!",

3.greetUser:function(userName){

4.console.log(this.greet+""+userName)

5.}

6.}

7.

8.vargreet1={

9.greet:"Hola"

10.}

11.

12.user.greetUser.call(greet1,"Rahul")//输出"HolaRahul"

13.user.greetUser.apply(greet1,["Rahul"])//输出"HolaRahul"

使用bind方法，可以为函数绑定this值，然后作为一个新的函数返回：

1.varuser={

2.greet:"Hello!",

3.greetUser:function(userName){

4.console.log(this.greet+""+userName)

5.}

6.}

7.

8.vargreetHola=user.greetUser.bind({greet:"Hola"})

9.vargreetBonjour=user.greetUser.bind({greet:"Bonjour"})

10.

11.greetHola("Rahul")//输出"HolaRahul"

12.greetBonjour("Rahul")//输出"BonjourRahul"

9、memoization

Memoization用于优化比较耗时的计算，通过将计算结果缓存到内存中，这样对于同样的输入值，下次只需要中内存中读取结果。

1.functionmemoizeFunction(func)

2.{

3.varcache={}

4.returnfunction()

5.{

6.varkey=arguments[0]

7.if(cache[key])

8.{

9.returncache[key]

10.}

11.else

12.{

13.varval=func.apply(this,arguments)

14.cache[key]=val

15.returnval

16.}

17.}

18.}

19.

20.

21.varfibonacci=memoizeFunction(function(n)

22.{

23.return(n===0||n===1)?n:fibonacci(n-1)+fibonacci(n-2)

24.})

25.

26.console.log(fibonacci(100))//输出354224848179262000000

27.console.log(fibonacci(100))//输出354224848179262000000

代码中，第2次计算fibonacci(100)则只需要在内存中直接读取结果。

10、函数重载

所谓函数重载(method

overloading)，就是函数名称一样，但是输入输出不一样。或者说，允许某个函数有各种不同输入，根据不同的输入，返回不同的结果。凭直觉，函数重载可以通过if...else或者switch实现，这就不去管它了。jQuery之父John

Resig提出了一个非常巧(bian)妙(tai)的方法，利用了闭包。

从效果上来说，people对象的find方法允许3种不同的输入:

0个参数时，返回所有人名1个参数时，根据firstName查找人名并返回2个参数时，根据完整的名称查找人名并返回。

难点在于，people.find只能绑定一个函数，那它为何可以处理3种不同的输入呢?它不可能同时绑定3个函数find0,find1与find2啊!这里的关键在于old属性。

由addMethod函数的调用顺序可知，people.find最终绑定的是find2函数。然而，在绑定find2时，old为find1同理，绑定find1时，old为find0。3个函数find0,find1与find2就这样通过闭包链接起来了。

根据addMethod的逻辑，当f.length与arguments.length不匹配时，就会去调用old，直到匹配为止。

1.functionaddMethod(object,name,f)

2.{

3.varold=object[name]

4.object[name]=function()

5.{

6.//f.length为函数定义时的参数个数

7.//arguments.length为函数调用时的参数个数

8.if(f.length===arguments.length)

9.{

10.returnf.apply(this,arguments)

11.}

12.elseif(typeofold==="function")

13.{

14.returnold.apply(this,arguments)

15.}

16.}

17.}

18.

19.

20.//不传参数时，返回所有name

21.functionfind0()

22.{

23.returnthis.names

24.}

25.

26.

27.//传一个参数时，返回firstName匹配的name

28.functionfind1(firstName)

29.{

30.varresult=[]

31.for(vari=0i

32.{

33.if(this.names[i].indexOf(firstName)===0)

34.{

35.result.push(this.names[i])

36.}

37.}

38.returnresult

39.}

40.

41.

42.//传两个参数时，返回firstName和lastName都匹配的name

43.functionfind2(firstName,lastName)

44.{

45.varresult=[]

46.for(vari=0i

47.{

48.if(this.names[i]===(firstName+""+lastName))

49.{

50.result.push(this.names[i])

51.}

52.}

53.returnresult

54.}

55.

56.

57.varpeople={

58.names:["DeanEdwards","AlexRussell","DeanTom"]

59.}

60.

61.

62.addMethod(people,"find",find0)

63.addMethod(people,"find",find1)

64.addMethod(people,"find",find2)

65.

66.

67.console.log(people.find())//输出["DeanEdwards","AlexRussell","DeanTom"]

68.console.log(people.find("Dean"))//输出["DeanEdwards","DeanTom"]

69.console.log(people.find("Dean","Edwards"))//输出["DeanEdwards"]

以上就是小编今天为大家分享的关于Web前端工程师应该知道的JavaScript的10个难点。希望本篇文章能够对正在从事Web前端学习的小伙伴们有所帮助。想要了解更多web前端相关知识记得关注北大青鸟Web培训官网最后祝愿小伙伴们工作顺利！

原文链接：#/a/1190000010371988

js并不难学。Js给人那种感觉的原因多半是因为它如下的特点：A：本身知识很抽象、晦涩难懂，如：闭包、内置对象、DOM。B：本身内容很多，如函数库、对象库就一大堆。C：混合多种编程思想。它里面不但牵涉面向过程编程思想，又有面向对象编程思想，同时，它的面向对象还和别的编程语言（如：C++，JAVA，PHP）不大一样。就好像又是新的一样，让你对曾经学的面向对象产生了怀疑......D：辛苦学习后又看似和实际应用脱节。通常学了很久的js基础之后，变量、函数、对象你也都略知一二，但一到公司开发项目的时候，却又难以下手。因为公司在开发实际项目的时候通常都是直接用它的衍生库，如：jquery，angular，boostrap，amaze，layui，ueditor等，而这些库又多如牛毛，同时还有自己的难点。让你都不知道该学哪个好，甚至都怀疑自己学的是不是js了，好像有多个版本的js一样，总是学不完......那么，怎么才能在js领域内学的轻松甚至游刃有余呢？我总结了一些实战意义的js学习经验：1.首先要紧紧抓住它的地位时刻都不能忘记，否则很容易犯“一叶障目不见泰山”的错误。不要学了很久就知道js是编程语言，就是写代码，而且特点就是乱七八糟就完了，那样是学不好js的。要时时抓住它的地位，确切的说是它在整个Web中的地位：它属于前端的核心，主要用来操控和重新调整DOM，通过修改DOM结构，从而来达到修改页面效果的目的。要用这个中心思想去指导后续的一切js的学习，并且形成条件反射。 2.要有一条清晰的学习路线这个只能是过来人给你提供参考了。我的学习路线如下：A：js基础部分，如：定义变量、函数、数组、字符串等的处理，内置函数、内置对象等；B：js面向过程编程思想，封装出各个函数，试着用这些去做一些常见的小功能，如：选项卡、自定义多选按钮、自定义播放器、3D幻灯片；C：js面向对象编程思想，试着去封装一些你自己的对象，提供出有意义的接口出来；D：学了上述的内容，然后学常用的库，这里必须学jquery；E：学基于jquery之上的常见插件，如：bootstrap，Layer，富文本编辑器等；F：综合应用上面的多种库写实际项目的模板，多写几套。 3.从多角度去学习和领悟充分调动你所学的东西，从多角度去做某一功能，如：以前你是从面向过程角度做的，现在改为从面向对象的角度再来做，或者继续做成可以直接使用的插件，提供属性、方法等出来。争取让你做的这个功能逐渐能使用到实际项目中来。这样的好处：既综合应用了你的所学，又能有实际意义。 4.注意培养信心此时的你，不适合一来就看很复杂很炫的网页效果的源代码，也不适合一来就学jquery，angular，vue，bootstrap这些东西。这些内容包含了很多深奥的知识在里面，在没有任何基础的情况下直接学这些，会严重打击你的自信心。而此时你是弱小的，你需要的是培养信心，而不是反过来，否则结局很可能是“夭折”，离学有所成也就遥遥无期了。 5. 多写总结这种总结不但包括源代码、显示效果截图，还应该很容易犯的错误和对应的解决方法以及最后一两句精简的结论性语句。对自己写的总结不是写完了就了事了，要多回顾、多改进、多精简。到做项目的时候，应该是看里面的一两句话就知道是讲什么了，而不要再去看长篇大论了。 6.构建知识导图这个可以让你越学越清晰，你可以按你喜欢的任何形式去做，只要自己印象深刻就行。注意：知识导图也应该是经常修改、修正，让它更合理、更清晰。学习编程知识，就来北京尚学堂，优秀的师资和多年的编程教育经验，会让你在学习的道路上快人一步。

1. $render用处就是：

  在$viewValue改变的时候可以重新绑定model数据，主要使用在自定义指令的时候，但是我们要注意一点在$viewValue改变的时候可以重新绑定model数据，

  但是我们要注意一点($viewValue和DOM节点的value是不同的)，我觉得他们的区别有点类似setTimeout和$timeout的区别，但是又不太一样。

  ps:其实modelValue和绑定的数据也可以不同

2.ngModelController则是ng-model指令中所定义的controller，

  在ngModelController中有两个很重要的属性，一个叫做$viewValue，一个叫做$modeValue。

  $viewValue：指令渲染模板所用的值，$viewValue属性保存着更新视图所需的实际字符串

  $modeValue:指控制器中流通的值，modelValue由数据模型持有。$modelValue和$viewValue可能是不同的，取决于$parser流水线是否对其进行了操作。

  于此相关的另外两个指令：$parses和$formatters

  $parses的作用是：将$viewValue->$modelValue

  $formatters的作用是：将$modelValue->$viewValue

3.$apply的作用: $apply()函数可以从Angular框架的外部让表达式在Angular上下文内部执行,Scope提供$apply方法传播Model的变化。

              在apply()方法里面，它会去调用scope.digest()方法，apply()方法带一个函数或者一个表达式，然后执行它，

  最后调用scope.digest()方法去更新bindings或者watchers。

  $apply()方法可以在angular框架之外执行angular JS的表达式。

  在$apply方法中提到过脏检查，首先apply方法会触发evel方法，当evel方法解析成功后，会去触发digest方法，digest方法会触发watch方法

  scope.digest(): 用于检查绑定的数据到底有没有发生变化。

4.watch方法用法：

语法：

$watch(watchFn,watchAction,deepWatch)

三个参数：

watchFn:angular表达式或函数的字符串

watchAction(newValue,oldValue,scope):watchFn发生变化会被调用，是一个函数

deepWatch：可选的布尔值命令检查被监控的对象的每个属性是否发生变化

$watch会返回一个函数，想要注销这个watch可以使用函数，true/false

5.angularJS——自定义服务provider之$get

  可以认为provider有三个部分：

  第一部分是私有变量和私有函数，这些变量和函数会在以后被修改。

  第二部分是在app.config函数里可以访问的变量和函数，所以，他们可以在其他地方使用之前被修改。注意，这些变量和函数一定要添加到this上面才行。

  第三部分是在控制器里可以访问的变量和函数，通过$get函数返回。

  当使用 provider创建服务的时候，唯一可以让控制器访问的属性和方法是在$get()函数里返回的属性和方法。

  使用Provider的优点就是，你可以在Provider对象传递到应用程序的其他部分之前在app.config函数中对其进行修改。

  当你使用Provider创建一个service时，唯一的可以在你的控制器中访问的属性和方法是通过$get()函数返回内容。

  大型数据进行访问的时候许多大型互联网站都是为全球用户提供服务的，

  用户分布范围广，各地网络情况千差万别。在国内，还有各个运营商网络互通难的问题。

  使用在具体的环境中，

6.angularjs中的run（）方法使用

  run方法用于初始化全局的数据，仅对全局作用域起作用。

例子：

<script type="text/javascript">

  var m1 = angular.module('myApp',[])

  m1.run(['$rootScope',function($rootScope){

  $rootScope.name = 'hello'

  }])

  console.log( m1 )

</script>

7.config方法

在模块加载阶段，对模块进行自定义配置

config可以注入$stateProvider, $urlRouterProvider, $controllerProvider, $provide, $httpProvider等等provider,

config的工作流程：

新建一个模块，这个模块中有一个服务，一个自定义指令

8.$routeProvider

$routeProvider是一个用于配置路由的内置服务。

它主要有以下两个成员函数：

otherwise(params)：设定映射信息到$route.current，一般用于指定没有标明的路由如何处理。

when(path, route)：向$route服务添加新的路由。path是指定的URL路径，route标明路由的处理。

9.ng-view是由ngRoute模块提供的一个特殊指令，它的独特作用是在HTML中给$route对应的

  视图内容占位

  $routeProvider是组网址的配置，将它们映射相应的HTML页面或 ng-template，并附加一个控制器使用相同键的服务

  $routeProvider.when('/',{template:'这是首页页面'})

10.template 和 templateUrl

  template: '<div><h2>Route</h2></div>'

  AngularJS会将配置对象中的HTML模板渲染到对应的具有ng-view指令的DOM元素中。

  templateUrl: 'views/template_name.html'

  应用会根据templateUrl属性所指定的路径通过XHR读取视图（或者从$templateCache中读取）。

  如果能够找到并读取这个模板，AngularJS会将模板的内容渲染到具有ng-view指令的DOM元素中。

11.在组件中注入服务

  Angular在底层做了大量的初始化工作，这极大地降低了我们使用依赖注入的成本，

  现在要完成依赖注入，我们只需要三步：

  第一步：通过import导入被依赖的对象服务

  第二步：在组件中配置注入器。在启动组件时，Angular会读取@Component装饰器里的providers元数据，

        它是一个数组，配置了该组件需要使用的所有依赖，Angular的依赖注入框架会根据这个列表去创建对应的示例。

  第三步：在组件构造函数中声明需要注入的依赖。注入器会根据构造函数上的声明，

        在组件初始化时通过第二步中的providers元数据配置依赖，为构造函数提供对应的依赖服务，最终完成依赖注入。

  例如：

      // app.component.ts

    // 1. 导入被依赖对象的服务

import { MyService } from './my-service/my-service.service'

// 2. 在组件中配置注入器

@Component({

  providers: [MyService]

})

export class AppComponent {

  // 3. 在构造函数中声明需要注入的依赖

  constructor(private myService: MyService) {}

}

12.在服务中注入服务

  例如：

    // power.service.ts

import { Injectable } from '@angular/core'

@Injectable()

export class PowerService {

  // power come from here..

}

// count.service.ts

import { Injectable } from '@angular/core'

import { PowerService } from './power/power.service'

@Injectable()

export class CountService {

  constructor(private power: PoowerService) {}

}

// app.component.ts  这里是当前组件，其实模块中的注入也一样，后面讲到

providers: [

  CountService,

  PowerService

]

  这里需要注意的是@Injectable装饰器是非必须的，因为只有一个服务依赖其他服务的时候才必须需要使用@Injectable显式装饰，

  来表示这个服务需要依赖，所以我们的PowerService并不是必须加上@Injectable装饰器的，

  可是，Angular官方推荐是否依赖其他服务，都应该使用@Injectable来装饰服务。

13.在模块中注入服务

  在模块中注册服务和在组件中注册服务的方法是一样的，只是在模块中注入的服务在整个组件中都是可用的。

  例如：

    // app.module.ts

import { BrowserModule } from '@angular/platform-browser'

import { NgModule } from '@angular/core'

import { AppComponent } from './app.component'

@NgModule({

 declarations: [

  AppComponent,

 ],

 imports: [

  BrowserModule

 ],

 providers: [CountService, PowerService],

 bootstrap: [AppComponent]

})

export class AppModule { }

  与在组件中注入不同的是，在Angular应用启动的时候，它好首先加载这个模块需要的所有依赖，

  此时会生成一个全局的根注入器，由该依赖创建的依赖注入对象会再整个应用中可见，并共享一个实例。

14.Provider

  Provider一个运行时的依赖，注入器依靠它来创建服务对象的实例。

---