一、函数声明和函数表达式有什么区别？（*）

ECMAScript里面规定了三种声明函数的方式：

• 构造函数
  函数也是对象的一种，可以通过其构造函数，使用new来创建一个函数对象。

var printName = new Function("console.log('Cttin');");

但是这种方法不推荐使用。

• 函数声明
  函数声明通过关键字function来声明，关键词后面是函数名，名称后面有个小括号，括号里面放的是函数的参数，最后是一对花括号，函数的代码块就放在这个花括号里面。

function  printName(){
    console.log('Cttin');
}
printName();

• 函数表达式
  函数表达式不是以function开始，而是一般出现在代码中间的部分，后面紧跟可选的函数名，然后是小括号，里面可以放置函数的参数，最后是花括号，用于放置函数主体。

var printName = function(){
    console.log('Cttin');
};

函数声明和函数表达式比较容易混淆，它们的区别主要有：

• 函数声明总是以function关键词开始，如果不是，那么它就是函数表达式。
• 函数声明最后面一般不写分号，而函数表达式有分号。
• 还有一个很重要的区别，对于函数声明，并不仅仅是函数名被提前了，整个函数的定义也被提前了。而对于函数表达式，规则和声明变量提前一样。也就是说，函数表达式只是变量被提前，它所赋的值并没有被提前。这一点，在下面将会详细说明。

二、什么是变量的声明前置？什么是函数的声明前置 ？（**）

JS和C、Java等语言不同，JS能够在变量和函数被声明之前使用它们。

• 变量的声明提前
  先来看个例子。
  DEMO
  
  
  运行上面的代码，结果会报错。这也是在预料之中，因为变量a并没有声明。
  然后再修改一下上面的代码看看。
  DEMO
  
  
  虽然变量是在语句调用之后定义的，但是结果并没有报错。这就变量声明提前的作用，它其实相当于如下的代码：

var a;
console.log(a);
a = 718;

JS的解析器会把当前作用域内声明的所有变量和函数都放到作用域的开始处。但是对于变量来说，它只是把变量的声明提前到作用域的开始处，而变量的赋值仍然按照顺序执行。而根据JS的语法，未被赋值的变量会自动赋值为undefined，所以这里运行的结果就是undefined。
再来看个例子。
DEMO

var name = "hunger";
(function(){
  var name;
  console.log("Original name was " + name);
  name = "cttin";
  console.log("New name was " + name);
})();

所以第一次打印出的是没有赋值的undefined，第二次才打印出cttin。

• 函数的声明前置
  函数的声明前置包括两种情况，分别为函数声明和函数表达式。
• 函数声明
  DEMO
  
  
  JS解释器允许你在函数声明之前使用，即函数声明并不仅仅是函数名被提前，整个函数的定义也被提前了。它相当于如下的代码：

function fn(){
    console.log('1');
}
fn();

• 函数表达式
  还是先来看个例子。
  DEMO
  
  
  在上面的代码中，sayAge变量被前置了，但是它的赋值并没有提前，这样看来函数表达式的提前就和上面所说的变量提前是一回事。上面的代码相当于：

var sayAge;
sayAge(10);
sayAge = function(age){
console.log(age);
}

因为被提前的变量的默认值是 undefined，undefined不是函数，当然不能被调用，所以报的错误属于“类型不匹配”。

总结：

• 变量声明会提前到作用域的顶部，而赋值会被保留在原地，依然是按次序执行。
• 函数声明整个会被前置到变量声明的后面，即使函数写在最后也可以在前面语句调用。
• 函数作为值赋给变量时，只有变量提前，函数并没有被提前。和变量声明提前一样。

所以我们在分析代码的时候，可以把变量和函数声明放在作用域的顶部，这样分析出来的结果一般不容易出错。

三、arguments 是什么？（*）

arguments是一个类数组对象，代表传给一个function的参数列表。arguments对象是函数内部的本地变量，不再是函数的属性。
arguments只在函数内部有效，可以在函数内部通过使用 arguments对象来获取函数的所有参数。这个对象为传递给函数的每个参数建立一个条目，条目的索引号从 0 开始。参数也可以被重新赋值。
DEMO
arguments对象类似于数组，但它并不是真正的数组，除了length，它没有数组所特有的属性和方法。
arguments主要用途：arguments对于参数数量是一个可变量的函数来说比较有用。 当这个函数的参数数量比它显式声明的参数数量更多的时候，你就可以使用 arguments对象获取到该函数的所有传入参数。

四、函数的重载怎样实现？（**）

重载是很多面向对象语言实现多态的手段之一，相同名字的函数参数个数不同或者顺序不同都被认为是不同的函数，称为函数重载。
但是在JS中，没有函数重载的概念，函数通过名字唯一确定，就算参数不同也被认为是相同的函数，后面的会覆盖前面的。
DEMO

五、立即执行函数表达式（IIFE）是什么？有什么作用？（***）

• 立即执行函数表达式（Immediately-Invoked Function Expression）
  在JS中，()在函数名之后，是一种运算符，表示调用这个函数。有的时候，我们需要在定义函数之后，立即调用该函数。你不能在函数的定义之后加上圆括号，这会产生语法错误。例如：

function(n){
    var i = 888;
    console.log(n);
    console.log('hello hunger',i);
}

(function(){ 
...
})();

(function(){
}());  //注意后面的分号

利用立即执行函数上面的代码就可以成功的运行啦。

立即执行函数表达式一般不需要给函数命名，因为只需要立刻执行就行。如果要命名，一般是用于递归函数。例如：

(function say(n){
    var i = 888;
    console.log(n);
    console.log('hello hunger' ,i);
    if(i<0)  return;
    say(n-1);
})(10);

• IIFE的作用
• 函数都有一个作用域，立即执行函数表达式包裹一段代码，让它有自己的作用域，这也是封装的第一步。生成一个局部变量，执行完就销毁。
• 可以不必为函数命名，避免了污染全局变量。

可以参考立即调用的函数表达式（IIFE）

六、什么是函数的作用域链 （****）

• 作用域
  作用域就是函数和变量可以访问的范围，JS中变量的作用域分为全局作用域和局部作用域。JS的作用域是靠函数来形成的，也就是说一个函数内定义的变量函数外不可以访问，变量在声明它们的函数体及其子函数内是可见的。
  这里需要注意一下语句的变量作用域范围。

console.log(j);  //undefined
console.log(i);  //undefined
for(var i=0;i<10;i++){   //不是函数，是控制语句，所以这里的i和j是全局作用域。
    var j = 100;
}
console.log(i);  //10
console.log(j);  //100

最外层函数和在最外层函数外面定义的变量拥有全局作用域，只有函数才有局部作用域。

for(var i=0;i<10;i++){
    var j = 100;
}
function fn(){
    var i = 99;
    console.log(i);   //只有函数才有局部的作用域，先在内部找（找不到再一层层往上面的作用域找），所以输出为99。
}
fn();  // 99
console.log(i); //10,只能取到for里面的10.但是如果上面函数里面的var i = 99;改成i = 99;打印结果为99，所以如果不加var就是全局变量。

当然也不是说不带var的就是全局作用域，再来看个例子。

for(var i=0;i<10;i++){
    var j = 100;
}
function fn2(){
    console.log(i);
    var i = 99;   //如果去掉var，结果应该是10，100，100
function fn2(){   
    i = 100;     //没有加var，可以认为这个函数里面变量的作用域在父亲的范围内
}
fn2();     //再执行这个，也就是内部的fn2(),得到100
console.log(i);
}
fn2();     //先执行这个调用，也就是大函数fn2()，得到undefined
console.log(i);   //最后执行。这里是全局变量的i，为10

总的来说：

• 变量没有在函数内声明或者声明的时候没有带var就是全局变量（除了在函数内部定义的子函数情况），拥有全局作用域；
• window对象的所有属性拥有全局作用域，在代码任何地方都可以访问；
• 函数内部声明并且以var修饰的变量就是局部变量，只能在函数体内使用；
• 函数的参数虽然没有使用var，但仍然是局部变量。
• 作用域链
  代码在执行的过程中，会创建一个作用域链，用来保证执行的环境对变量和函数的有序访问。在函数运行过程中标识符的解析是沿着作用域链一级一级搜索的过程，从当前所在的作用域开始，逐级向上寻找，直到找到同名标识符为止，找到后不再继续遍历，找不到就报错。
  详细资料还可以参考：
  JavaScript 开发进阶：理解 JavaScript 作用域和作用域链
  JavaScript作用域链

七、代码

1.以下代码输出什么？ （难度**）

function getInfo(name, age, sex){ 
    console.log('name:',name); 
    console.log('age:', age);
    console.log('sex:', sex); 
    console.log(arguments); 
    arguments[0] = 'valley'; 
    console.log('name', name);
 } 
getInfo('hunger', 28, '男'); 
getInfo('hunger', 28);
getInfo('男');

getInfo('hunger', 28, '男');

getInfo('hunger', 28);

getInfo('男');

2.写一个函数，返回参数的平方和？如 （难度**）

function sumOfSquares(){
 } 
sumOfSquares(2,3,4); // 29 
sumOfSquares(1,3); // 10

function sumOfSquares(){
    sum = 0;
    for(var i = 0;i<arguments.length;i++){
        sum = sum + arguments[i]*arguments[i];
  }
    console.log(sum);
}
sumOfSquares(2,3,4); //29
sumOfSquares(1,3); //10

运行结果

3.如下代码的输出？为什么 （难度*）

console.log(a); 
var a = 1; 
console.log(b);  

根据变量提升，以上代码相当于：

var a;
console.log(a);
a = 1;
console.log(b);

运行结果

4.如下代码的输出？为什么（难度*）

sayName('world'); 
sayAge(10); 
function sayName(name){ 
console.log('hello ', name);
} 
var sayAge = function(age){ 
console.log(age); 
};

以上代码相当于：

var sayAge;
function sayName(name){
    console.log('hello ', name);
}
sayName('world');
sayAge(10);
sayAge = function(age){
    console.log(age);
};

运行结果

5.如下代码的输出？为什么（难度**）

function fn(){} 
var fn = 3; 
console.log(fn);

以上代码相当于：

var fn;
function fn(){}  //变量的声明会提升到函数声明的前面，函数的声明会覆盖方法的声明
fn = 3;  //变量的赋值会覆盖方法的声明。如果没有这句赋值语句，输出就是function fn(){}
console.log(fn);

function fn(fn2){
console.log(fn2);
var fn2 = 3;
console.log(fn2);
console.log(fn);
function fn2(){
    console.log('fnnn2');
}
}
fn(10);

以上的代码相当于：

function fn(fn2){
var fn2;  //先是变量声明提前
function fn2(){
    console.log('fnnn2');
}  //再是函数声明提前到变量声明的后面
console.log(fn2);  //当函数执行有命名冲突的时候，函数执行时载入顺序是变量、函数、参数，所以此处的输出应该是上面的函数。
fn2 = 3; 
console.log(fn2);  //经过上面的赋值语句，覆盖了上面的方法声明，所以输出3
console.log(fn);  //打印出函数fn
}
fn(10);  //根据此处的函数调用，执行上面的fn函数

运行结果

var fn = 1; 
function fn(fn){ 
console.log(fn);
 } 
console.log(fn(fn)); 

上述代码相当于：

var fn;  //先声明变量fn
function fn(fn){ 
console.log(fn);
 }   //再声明函数，函数的声明会覆盖变量的声明
fn = 1;  //然后给fn赋值为1，会覆盖上面的方法声明，此时fn为数字1
console.log(fn(fn));  //这里是调用函数fn，但是此时fn是数字1，不能当作函数来调用，所以会报错

运行结果

8.如下代码的输出？为什么（难度**）

//作用域 console.log(j);
console.log(i);
for(var i=0; i<10; i++){
var j = 100; 
}
console.log(i); 
console.log(j);

因为for是控制语句，不是函数，所以它里面的变量i和j都是全局的，所以它相当于如下的代码：

var i;
var j;
console.log(i);
for(i=0; i<10; i++){
  j = 100; 
}
console.log(i); 
console.log(j);

运行结果

fn();
var i = 10;
var fn = 20; 
console.log(i);
function fn(){ 
    console.log(i); 
    var i = 99; 
    fn2(); 
    console.log(i); 
    function fn2(){
    i = 100; 
    }
}

上述代码相当于：

var i;  //声明变量
var fn;  //声明变量
function fn(){ 
    var i;
    function fn2(){
    i = 100; 
    }
    console.log(i);  //因为上面函数fn2中的变量i是局部作用域，只在函数内部有效，外部无法访问，所以这里的输出结果为undefined
    i = 99; 
    fn2();  //调用fn2函数，此时i为100
    console.log(i);  //输出i的值100
}  //声明函数
fn();  //调用函数，执行函数fn
i = 10;  //函数执行完后，i被赋值为10
fn = 20;   //fn被赋值为20，此时fn已经不是函数了，因为被赋值语句覆盖了，变成了数字20
console.log(i);  //打印出i的值10

运行结果

var say = 0; 
(function say(n){ 
console.log(n); 
if(n<3) return; 
say(n-1); 
}( 10 )); 
console.log(say);

function外部加了个括号，所以为立即执行函数，里面又嵌套了say(n-1)，所以为递归函数。把函数最后面的参数10传递进去，所以一开始打印的就是10，依次递减直到等n小于3，也就是当n等于2的时候退出整个循环。
然后再执行最后一句，打印出say的值，注意这里并不是函数调用哦，后面没有括号。

运行结果

var say = 0; 
var n = 10;
function say(n){ 
console.log(n); 
if(n<3) return; 
say(n-1); 
}; 
console.log(say());

运行结果