1.函数的声明定义
两种方式：
函数声明语句
function foo1(args){
var x = 'hello';
}
函数表达式
var foo2 = function(args){ var x = 'hello' };
两种的区别：
第一种，函数的定义会在执行上下文开始执行代码之前被提升，通俗的讲，就是在函数声明语句之前就可以调用函数了。
第二种，在执行上下文开始执行代码之前，只有变量foo2会被提升，变量的初始化还在原来代码的位置，所以在函数表达式之前，foo2的值为undefined。
函数声明和定义可以嵌套到其他函数里
2.函数调用
函数声明的调用foo1() //这种是作为函数调用
作为方法属性调用 obj.foo() //这种是作为方法调用
构造函数调用 new Foo() //用于新建对象
三种的区别:
以函数调用形式调用的函数其this的值为全局对象(非严格)或者undefined(严格模式)，不管这个函数声明在其他函数里还是在其他地方
以方法形式调用的函数其this的值为调用它的对象
function foo1(){
console.log(this);
foo2();
function foo2(){
console.log(this)
}
}
var obj ={name : "obj", foo : foo1};
obj.foo(); //结果输出为{name: "obj", foo: ƒ} 和window
//直接在浏览器的控制台粘贴这段代码看结果
将foo2的函数声明变为函数表达式再试试
function foo1(){
console.log(this);
var foo2 = function (){
console.log(this)
}
foo2(); //这里输出的this为什么为window??????
}
var obj ={name : "obj", foo : foo1};
obj.foo();
//对于foo2为什么输出的是window我也很疑惑，函数表达式调用其实是看作方法调用的，
//所以foo2里的this应该是调用它的作用域的变量对象，很疑惑
构造函数调用
构造函数调用创建一个新的空对象，这个对象继承自构造函数的prototype属性，构造函数可以初始化这个新的对象，并将这个对象作为其的调用上下文（this），可以用this引用新创建的对象。如 new o.m();中，m调用的上下文不是o。//一般不这么用
构造函数一般没有返回值，不过如果显式地返回一 个对象，则这个调用表达式的值就是这个对象 // 一般不这么用
3.函数的作用域(链)
函数的作用域链在函数声明定义的时候就已确定了(这里很难讲清楚，应该说是在声明定义时确定了一条作用域链，这个作用域链不包括函数本身的作用域，只有在函数被调用时，函数本身的作用域才加入到其作用域链顶部)。
不管函数在哪里被调用，它的作用域链在定义时就被确定了，作用域链只和函数被定义的地方有关。
对于作为对象方法的函数的作用域：
var obj = {name : 'obj' ,
foo : function(args){ console.log(name)} ,
callfoo : function(){ obj.foo();}
};
var name = 'scope';
function outterFoo(){ console.log(name)};
obj.foo();
outterFoo();
obj.callfoo();
//输出的结果都为scope
作为对象方法的函数的作用域链(未被调用前)和与对象在同一层的函数的作用域链是一样的。
4.函数的执行上下文
在打开页面时，全局执行上下文就被压入执行上下文栈中，当调用函数时会将向执行上下文中压入函数的执行上下文，在函数中如果调用其它函数则继续压入新的执行上下文，函数执行完之后，其执行上下文被弹出栈。
之后会写文章从内存的角度来分析函数的执行上下文。持续关注
5.函数里变量的查找
函数里变量的查找是在作用域链上依次查找的，会一层一层向外查找。变量的查找不同于this的属性的查找
this和作用域是两个完全不同的概念 this是javascript的关键字而不是变量。
6.函数的this
this也可以叫做调用上下文(和执行上下文有区别） // 个人见解
在不指定的情况下，this指向的是调用该方法的对象。
this上属性的查找是在对象的原型链上查找的
在构造函数中，this指向的是通过new关键字新建的实例对象
可以指定this属性的指向
利用call apply bind 三个函数
function foo(arg1,arg2,arg3){};
foo.call{obj,arg1,arg2...} //call指定this为obj，后面的参数作为foo的参数传进去
foo.apply{obj,[arg1,arg2]} //也是制定this为obj，但是传给foo的参数是以数组的形式
var newfoo = foo.bind(obj,arg1,arg2) // 为foo绑定this，和两个参数 bind返回的是一个新函数
调用新的函数，会调用foo，而且foo的this都是指向obj，而且传入newfoo的参数都作为参数赋值给arg3及后面的参数，因为arg1,arg2已经被绑定了。
//模拟bind , bind的一些特性还是模拟不来，功能可以模拟
Function.prototype.bind = Function.prototype.bind || function(obj...){
var self = this;
var boundArgs = arguments;
return function(){
var args=[],i;
for(i=1;i<boundArgs.length;i++) args.push(boundArgs[i]);
for(i=0;i<arguments.length;i++) args.push(arguments[i]);
return self.apply(obj,args);
}
};
7.自定义函数属性
函数也是一种特殊的对象，可以为其自定义属性。
function foo(){console.log(foo.counter++)};
foo.counter = 0;
这种做法有个问题，函数的counter属性可以被随性修改，可以利用闭包将属性私有化。
通过给构造函数添加方法和属性就模拟实现了类方法和类字段
8.闭包
一句话理解闭包，局部作用域的变量被外部引用时，其内存空间不会被销毁 （本人愚见，欢迎各路大神指正）
var unique = (function(){
var counter = 0;
return function(){ return counter++}}()); //闭包的典型例子
//函数每次调用时在内存中创建的空间是不一样的。
function getUniqueFoo(){
var counter = 0;
return function(){ return counter++} //这里返回的函数里存在外层函数的局部变量counter
}
var unique2 = getUniqueFoo(); //unique2指向返回的函数
var unique3 = geUniqueFoo(); //unique2和unique3是互不干扰的，因为内存空间不是同一块
//又一个闭包例子
function getApp(){
var appName = "xxx";
var version = "1.xxx";
var setName = function(name){
appName = name;
}
return {
get app(){ return appName}, //存取器属性
version : version,
setName : setName,
}
}
var App =getApp();
可以在外部函数将this转存为一个变量，以便在闭包中访问,外部函数的arguments 也一样
arguments是函数的类数组对象
arguments.callee 指向的是arguments所在的函数本身
之后会写文章从内存的角度来分析函数的闭包。持续关注
