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所在的函数本身

之后会写文章从内存的角度来分析函数的闭包。持续关注

Javascript函数全解析