函数声明和函数表达式有什么区别？
函数声明：function fn(){}
函数表达式：var fn = function(){};
- 都可以定义一个函数。
- 函数声明会产生函数的声明前置，因此可以在函数声明之前就调用函数。函数表达式只会产生变量的声明前置，因此在函数表达式之前调用会报错。
- 函数声明语句不能出现在if语句，while循环和其他任何语句中，表达式则可以。
什么是变量的声明前置？什么是函数的声明前置？
- 变量的声明前置，JavaScript代码在解析时，会首先获取所有被声明的变量（只有变量名，不包含其值），使所有变量的声明语句会提升到代码的头部。
- 函数的声明前置，JavaScript代码在解析时，先获取所有被声明的函数，使函数在执行任何代码之前都可以访问。
arguments是什么？
- arguments 是一个类数组对象，相当于传入的所有函数的集合，可以使用方括号语法访问它的每一个元素。
函数的重载怎样实现？
在JavaScript中没有函数重载的概念，函数通过名字确定唯一性，参数不同也被认为是相同的函数，后面的覆盖前面的，但可以通过自身属性模拟函数的重载。
function printPeopleInfo(name, age, sex){
if(name){
console.log(name);
}
if(age){
console.log(age);
}
if(sex){
console.log(sex);
}
}
printPeopleInfo('Byron', 26);
printPeopleInfo('Byron', 26, 'male');
立即执行函数表达式是什么？有什么作用 ?
立即执行函数表达式结构：
(function() {code} (可传入参数) );
(function () {code})(可传入参数);
```
* 不必为函数命名，避免了污染全局变量；
* 立即执行函数执行完后就会销毁，不会对作用域存在影响；
* 在函数内部形成一个单独的作用域，可以封装一些外部无法读取的私有变量；
## 什么是函数的作用域链？
作用域：指对变量存在的范围，在javascript中存在2种作用域：
（1）全局作用域：在全局作用域定义的变量称为全局变量，全局作用域指变量在整个程序中都存在，所有地方都可以读取；
（2）函数作用域：在里面的定义的变量（需在定义变量的前面加上var，否则该变量会变为全局变量）称为局部变量，它们只函数内部存在；
作用域链的原理是，如果变量在该作用域中没有，则它会逐级向上寻找，直至最顶层。
*****
## 代码
#### 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,'男');
/*
name:hunger
age:28
sex:男
["hunger",28,"男"]
name:valley
*/
getInfo('hunger',28);
/*
name:hunger
age:28
sex:undefined
["hunger",28]
name:vally
*/
getInfo('男');
/*
name:男
age:undefined
sex:undefined
["男"]
name:valley
*/
```
#### 2 写一个函数，返回参数的平方和？
```
function sumOfSquares(){
var sum = 0
for(var i=0;i<arguments.length;i++){
sum += arguments[i]*arguments[i];
}
console.log(sum);
}
sumOfSquares(2,3,4); //29
sumOfSquares(1,3); //10
```
#### 3 如下代码的输出？为什么？
```
console.log(a); //undefined
var a = 1;
console.log(b); //报错，b is not defined;
/*
由于变量的声明提升，所以在这段代码执行之前，先声明var a,在打印a，在
给a赋值，在打印b，所以有上面的结果。
*/
```
#### 4 如下代码的输出？为什么？
```
sayName('world'); //hello world
sayAge(10); //TypeError:undefined is not a function
function sayName(name){
console.log('hello ',name);
}
var sayAge = function(age){
console.log(age);
};
/*
函数声明语句会前置，所以在声明语句之前调用也可以，而函数表达式只是var sayAge;声明提升了，
此时函数还没有赋给他，还不是函数，所以调用的时候会报错。
*/
```
#### 5 如下代码的输出？为什么？
```
function fn(){}
var fn = 3;
console.log(fn);//3
/*
变量提升var fn;提升至最前,然后声明fn为函数,再将3赋值fn覆盖了函数。
*/
```
#### 6 如下代码的输出？为什么？
```
function fn(fn2){
console.log(fn2);
var fn2 =3;
console.log(fn2);
console.log(fn);
function fn2(){
console.log('fnnn2');
}
}
fn(10);
/*
依次输出：
function fn2(){
console.log('fnnn2');
}
**********
3
**********
function fn(fn2){
console.log(fn2);
var fn2 =3;
console.log(fn2);
console.log(fn);
function fn2(){
console.log('fnnn2');
}
}
原因：
由于变量声明提升和函数声明前置，代码执行顺序会变成这样
function fn(fn2){
var fn2; 声明变量，此时fn2为传入的参数10
function fn2(){ fn2声明为函数，覆盖掉10
console.log('fnnn2');
}
console.log(fn2); 输出fn2 为函数
fn2 =3; 赋值3，覆盖掉函数
console.log(fn2); 输出3
console.log(fn); 输出函数fn
}
fn(10);
*/
```
#### 7 如下代码的输出？为什么？
```
var fn = 1;
function fn(fn){
console.log(fn);
}
console.log(fn(fn)); //TypeError:number is not a function
/*
代码执行顺序为：
var fn;
function fn(fn){
console.log(fn);
}
fn = 1; fn不是函数，所以输出报错。
*/
```
#### 8 如下代码的输出？为什么？
```
console.log(j); //undefined 声明提升，未赋值
console.log(i); //undefined 声明提升，未赋值
for(var i=10; i<10; i++){
var j = 100;
}
console.log(i); //10
console.log(j); //100
```
#### 9 如下代码的输出？为什么？
```
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;
}
}
/*
输出结果：
undefined
100
10
代码的执行顺序：
var i;
var fn; 变量声明提升
function fn(){ 函数声明前置
var i; 函数中的变量声明提升
function fn2(){ 函数声明前置
i = 100;
}
console.log(i); i 未赋值；undefined
i = 99; i赋值99
fn2(); 执行fn2(),i赋值100
console.log(i); 100
}
fn(); 执行函数fn();
i = 10;
fn = 20;
console.log(i); i为10
*/
```
#### 10 如下代码的输出？为什么？
```
var say = 0;
(function say(n){
console.log(n);
if(n<3) return;
say(n-1);
}( 10 )); //立即执行函数，n=2时跳出函数,不影响后续代码。
console.log(say); //0
/*
输出结果：
10
9
8
7
6
5
4
3
2
0
*/
```