函数

1.函数声明和函数表达式有什么区别

函数声明 ：function fn() {} // fn();
1 函数声明必须有函数名 ，
2 函数可以在任意地方调用fn();
函数表达式
1 前后两个函数的名字可以相同也可以不相同 。
2 function 后面的这个名字是可以省略的 。
3 function 后面的这个名字只能再函数内部使用。
4 函数调用只有在函数表达式声明后调用。
2.什么是变量的声明前置？什么是函数的声明前置。

2.什么是变量的声明前置？什么是函数的声明前置

和变量的声明会前置一样，函数声明同样会前置，如果我们使用函数表达式那么规则和变量一样.

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

如果我们使用函数声明的方式，那么即使函数写在最后也可以在前面语句调用，前提是函数声明部分已经被下载到本地

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

3.arguments 是什么？

arguments 是JavaScript里的一个内置对象,有的[函数]都有属于自己的一个arguments对象，它包括了函所要调用的参数。object对象。

  function printPersonInfo(name, age, sex){
console.log(name);
console.log(age);
console.log(sex);
console.log(arguments);
}

4.函数的重载怎样实现。

JavasScript不支持函数的重载，但是我们可以通过arguments判断调用时传入的参数的个数，然后对不同的情况采取不同的处理方式。例子如下：

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');

5.立即执行函数表达式是什么？有什么作用 ?

立即执行函数就是声明一个匿名函数，然后马上调用这个函数。
立即执行函数的格式：(function(){console.log(立即执行函数);})()；
立即执行函数的作用是：创建一个独立的作用域，这个作用域里面的变量，外面访问不到。它可以帮你封装大量的工作而不会在背后遗留任何全局变量。你定义的所有变量都会成为立即执行函数的局部变量，所以你不用担心这些临时变量会污染全局空间。
6.什么是函数的作用域链 ?
a) 一个函数创建时，javascript后台(引擎)会默认创建一个仅供后台使用的内部属性[[Scope]]，此属性存储函数的作用域链，如果是全局函数，此时则包含一个变量对象(全局变量)，如果是嵌套函数(闭包)，作用域链还加上了父函数的变量对象。例如下面的这个全局函数:
function add(num1,num2)
{ var sum = num1 + num2; return sum;}

（此图是函数定义时的作用域链）
b) 函数被调用时--add(5,10)，javascript后台会创建一个内部对象(execution context)--“执行环境”或“运行期上下文”，执行环境有它自己的作用域链，执行环境创建时就以定义函数时的作用域链初始化它自己的作用域链，并且随后创建了一个活动对象，活动对象作为函数执行期的一个变量对象，包含所有局部变量(在函数内定义的)、命名参数、arguments、this，它会被推入到执行环境作用域链的前端(如下图)。每执行一次函数都会创建一个新的执行环境，当函数执行完毕执行环境就会被销毁。

（此图是函数运行时的作用域链）
另外关于延长作用域链问题：以下的两种情况会使作用域链延长

1. try-catch语句的catch块；
2. with语句；
   这个两个语句都会再原本的作用域链的前端添加一个变量对象。对于with语句来说，新添加的变量对象包含着with括号中指定对象的所有属性和方法所作的变量声明。对于catch来说，当try块发生错误时，代码执行流程自动转入到catch块，并将异常对象推入到作用域链的前端。catch块执行完毕后，作用域链就会返回原来的状态。

当代码流执行到一个with表达式时，执行环境的作用域链会被临时改变，此时with的变量对象会被创建添加到作用域链的前端，这就意味着此时函数的所有局部变量都被推入到第二个作用域链中的变量对象，如下图：

由上图可清晰的看到，在执行with语句时，访问局部变量的代价更高了。所以尽可能避免使用with语句，可以使用局部变量代替
代码：
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, '男');
 //name: hunger
 //age: 28
 //sex: 男
 //["hunger", 28, "男"]
 //name valley 
 getInfo('hunger', 28);
 //name: hunger
  //age: 28
  //sex: undefined
 //["hunger", 28]
 //name valle
 getInfo('男');
//name: 男
//age: undefined
//sex: undefined
//["男"]
//name valley

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

  function sumOfSquares(){
    for(var i=0;i<arguments.length;i++{
    var sum = 0;
    sum += arguments[i]*arguments[i];
 return 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)
//输出
// undefined
//Uncaught ReferenceError: b is not defined(…)

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

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

    //hello world  
    //报错，因为sayAge(10);之前未声明sayAge是一个函数

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

function fn(){}
 var fn = 3;
console.log(fn);
//3
//在同一个作用域内，变量同函数同名时，覆盖之前的函数声明

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

function fn(){}
var fn = 3;
console.log(fn);
//3
//在同一个作用域内，变量同函数同名时，覆盖之前的函数声明
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);
 console.log(fn);       
 }
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');
  }
 }

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

  var fn = 1;  
function fn(fn){
 console.log(fn);
}
console.log(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);
 //undefined i未赋值
//undefined j未赋值
//10 for循环最后i=10
// 100 var 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;
}
}
//等于
var i;
  var fn;
function fn(){
var i;
function fn2(){
    i = 100;
}
console.log(i);
i = 99;
fn2();
console.log(i);

}
 fn();
i = 10;
fn = 20;
console.log(i);
//最后输出
//undefined
//100  
//10

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

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

//先分解中间那个立即执行函数表达式，等于
var say = 0;
(function say(n){
console.log(n);
if(n<3) return;
say(n-1);
}
say(10);)
console.log(say);

//把所有声明提前，变成
var say;
(function say(n){
console.log(n); //第一次10，之后每次减1，直到2
if(n<3) return; //最后return出一个2，结束循环
say(n-1);
}
say(10);)
say=0;
console.log(say);  //这里为0
//最后就是10到2，接一个0: 10,9,8,7,6,5,4,3,2,0