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.构建知识导图这个可以让你越学越清晰，你可以按你喜欢的任何形式去做，只要自己印象深刻就行。注意：知识导图也应该是经常修改、修正，让它更合理、更清晰。学习编程知识，就来北京尚学堂，优秀的师资和多年的编程教育经验，会让你在学习的道路上快人一步。
