你真的懂函数吗?

定义
1. 匿名函数
2. 具名函数
3. 箭头函数

词法作用域（也叫静态作用域）

var global1 = 1
 function fn1(param1){
     var local1 = 'local1'
     var local2 = 'local2')
     function fn2(param2){
         var local2 = 'inner local2'
         console.log(local1)
         console.log(local2)
     }

     function fn3(){
         var local2 = 'fn3 local2'
         fn2(local2)
     }
 }

深入阅读：

call stack

this & arguments

重要：this 就是 call 的第一个参数！call 的其他参数统称为 arguments 如果你记住了这个规则，那么网上其他关于 this 的解释在此时都变得很啰嗦了。

this 是隐藏的第一个参数，且一般是对象（如果不是对象，就显得很没有意义了）

function f(){
      console.log(this)
      console.log(arguments)
  }
  f.call() // window
  f.call({name:'frank'}) // {name: 'frank'}, []
  f.call({name:'frank'},1) // {name: 'frank'}, [1]
  f.call({name:'frank'},1,2) // {name: 'frank'}, [1,2]

this 为什么必须是对象因为 this 就是函数与对象之间的羁绊

var person = {
          name: 'frank',
          sayHi: function(person){
              console.log('Hi, I am' + person.name)
          },
          sayBye: function(person){
              console.log('Bye, I am' + person.name)
          },
          say: function(person, word){
              console.log(word + ', I am' + person.name)
          }
      }
      person.sayHi(person)
      person.sayBye(person)
      person.say(person, 'How are you')

      // 能不能变成 
      person.sayHi()
      person.sayBye()
      person.say('How are you')

      // 那么源代码就要改了
      var person = {
          name: 'frank',
          sayHi: function(){
              console.log('Hi, I am' + this.name)
          },
          sayBye: function(){
              console.log('Bye, I am' + this.name)
          },
          say: function(word){
              console.log(word + ', I am' + this.name)
          }
      }
      // 如果你不想吃语法糖
      person.sayHi.call(person)
      person.sayBye.call(person)
      person.say.call(person, 'How are you')

      // 还是回到那句话：this 是 call 的第一个参数
      // this 是参数，所以，只有在调用的时候才能确定
      person.sayHi.call({name:'haha'})  // 这时 sayHi 里面的 this 就不是 person 了
      // this 真的很不靠谱

      // 新手疑惑的两种写法
      var fn = person.sayHi
      person.sayHi() // this === person
      fn()  // this === window

call / apply fn.call(asThis, p1,p2) 是函数的正常调用方式当你不确定参数的个数时，就使用 apply fn.apply(asThis, params)
bind call 和 apply 是直接调用函数，而 bind 则是返回一个新函数（并没有调用原来的函数），这个新函数会 call 原来的函数，call 的参数由你指定。
return 每个函数都有 return 如果你不写 return，就相当于写了 return undefined
柯里化 / 高阶函数返回函数的函数
- 柯里化：将 f(x,y) 变成 f(x=1)(y) 或 f(y=1)x
```
//柯里化之前
  function sum(x,y){
      return x+y
  }
  //柯里化之后
  function addOne(y){
      return sum(1, y)
  }
  //柯里化之前
  function Handlebar(template, data){
      return template.replace('{{name}}', data.name)
  }
  //柯里化之后
  function Handlebar(template){
      return function(data){
          return template.replace('{{name}}', data.name)
      }
  }
```
  柯里化可以将真实计算拖延到最后再做
  
  关于柯里化的高级文章：
  1. http://www.yinwang.org/blog-cn/2013/04/02/currying
  2. https://zhuanlan.zhihu.com/p/31271179
- 高阶函数：
  
  在数学和计算机科学中，高阶函数是至少满足下列一个条件的函数：
  1. 接受一个或多个函数作为输入：forEach sort map filter reduce
  2. 输出一个函数：lodash.curry
  3. 不过它也可以同时满足两个条件：Function.prototype.bind
回调名词形式：被当做参数的函数就是回调动词形式：调用这个回调注意回调跟异步没有任何关系
构造函数返回对象的函数就是构造函数一般首字母大写

课后题答案：

function curry(func , fixedParams){
    if ( !Array.isArray(fixedParams) ) { fixedParams = [ ] }
    return function(){
        let newParams = Array.prototype.slice.call(arguments); // 新传的所有参数
        if ( (fixedParams.length+newParams.length) < func.length ) {
            return curry(func , fixedParams.concat(newParams));
        }else{
            return func.apply(undefined, fixedParams.concat(newParams));
        }
    };
}