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
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一个运行时的依赖，注入器依靠它来创建服务对象的实例。
