函数

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

答：函数声明的写法
function 函数名称 (参数){函数体}
其中参数可写可不写：
例：function(){}
函数表达式：
var 变量=function 函数名称 (参数){函数体}
例：var fn= function(){}
区别：函数声明会提升到执行环境的顶部，而函数表达式不会
例：

fn()//输出1
function fn(){
    console.log("a");
}

搜狗截图16年08月19日1802_1.png

fn()//输出undefined
var fn= function (){
    console.log("a");
}

• 函数声明有声明提前的特点，函数声明会被提前到函数作用域的前面，即使把声明放在后面，代码解析时也会将声明提取出来提前。而函数表达式做不到这点，函数表达式时把函数赋值给变量，是把函数放在语句中而不是代码主流中，只有浏览器解析到这条语句的时候才会被调用，而且不会像函数声明那样提前调用。
• 函数表达式可以在后面加括号执行，而函数声明不可以。

function a(){}(); // 不可以执行。必须得通过函数名调用 a();
var a = function a(){} (); // 加括号就可以直接执行

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

答：1.变量声明前置

var a = 1;
function fn(){
     console.log(a);
}
fn()//输出1

var a = 1;
function fn(){
    console.log(a);
    var a = 2;
}
fn()//输出undefined

第二个例子出现undefined的原因，因为脚本解析的时候自动将变量声明前置，是这样的：

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

因为它的声明变量提升了，而他的赋值没有跟着声明变量提升，所以输出的是undefined。
2函数声明前置；

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

函数声明前置会跟变量声明前置一样提升到执行环境的顶部。

3.arguments 是什么

答：arguments的意思是参数，是一个类数组对象，代表传给一个function的参数列表,argument是函数内部的本地变量，已经不再是函数的属性了。

可以在函数体内使用argument对象来访问这个数组，获取传递给函数的每个参数：

function fn(){
 console.log(arguments[0]);
 console.log(arguments[1]);
}
fn("hello","world");

搜狗截图16年08月20日1402_2.png

可以通过argument对象的length属性来获知有多少个参数传递给了函数：

function fn(){
 console.log(arguments.length);
}
fn("hello","world");
fn()
fn("2","3","1")
fn(1)

搜狗截图16年08月20日1407_3.png

arguments.caller也是argument的另外一个重要的属性，指的是拥有argument这个对象的函数 例：

function fn () {
 console.log(arguments.callee);
}
fn();

输出结果还是这个函数。
arguments不是必须的，JS中允许省略arguments,被省略的参数的值就变为undefined。

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

答：在其他编译语言中，相同名字的函数参数个数不同或者顺序不同都被认为是不同的函数，这就叫做函数重载，JS中没有办法直接实现方法重载，因为在JS中如果定义了多个名称相同，但参数个数不一样的方法，其实只有最后一个方法能被真正调用，其他的方法都被覆盖掉了。
但在JS中每个参数都有一个特殊的参数argument，利用它可以实现重载，例：

function fn() {
 if(arguments.length == 1)
 { console.log(arguments[0] + 3); }
 else if(arguments.length == 2)
 { console.log(arguments[0] * arguments[1]); } 
} 
fn(2, 4);

实现结果如下：

搜狗截图16年08月20日1625_4.png

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

答：立即执行函数表达式（Immediately-Invoked Function Expression，简称IIFE。主要有以下两种方法表达：

(function fn(){}())//在函数最前和最后加括号,推荐这种写法。
(function fn(){})()//在function外面加括号。

作用：

• 立即执行函数可以将写在函数体内的语句直接执行。区别于普通语句，立即执行函数内的变量不会干扰函数体外，形成一个类似区块的空间。
• 解决闭包冲突。
• 模块模式，可以避免变量空间污染，构建更多私有变量。

6.什么是函数的作用域链

答：任何程序语言都有作用域的概念，作用于就是变量与函数可以访问的范围，作用域控制着变量与函数的可见性与生命周期。作用域有全局作用域和局部作用域两种。

• 全局作用域：
  在代码中任意地方都能访问到对象拥有全局作用域。
• 函数最外层和函数最外层之外定义的变量拥有全局作用域：

var a=1;
function fn(){
b=2;
}

在上面代码中a和fn都拥有全局作用域b没有全局作用域。

• 所有未定义直接赋值的变量自动声明为拥有全局作用域。

function fn(){
    var a=1;
    b=2;
}

在上面代码中a不是全局作用域b是全局作用域。

• 所有window对象的属性拥有全局作用域。
• 局部作用域：
  局部作用域一般只在固定代码的片段内可以访问到，在函数的内部，所以人们把它称之为函数作用域。例：

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

上述代码中变量a与fn2都只有局部作用域。

• 作用域链：
  函数对象和其他对象一样，拥有可以通过代码访问的属性和一系列供JS引擎访问的内部属性，其中一个内部属性是[scope]，该属性包括了函数被创建的作用域中的对象集合，这个集合称为函数的作用域链，它决定了哪些能够被函数访问,果变量在该作用域中没有，则它会逐级向上寻找，直至最顶层。

代码部分：

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

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

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

结果：

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

变量声明a提升到console.log(a)之前但是未赋值，所以输出是undefined。
console.log(b)既没有声明也没有赋值所以报错。

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

第一个因为函数声明会前置，sayName函数会提升到代码头部，则会在执行时正常输出结果。
第二个因为它是函数表达式，只把var sayAge提升到了头部，并没有把函数提升上来，所以会报错。

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

因为变量声明前置var=fn会被提升到代码头部，fn=3被赋予fn所以输出结果为3，同一名称后者覆盖前者。

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

搜狗截图16年08月20日1746_11.png

它的执行顺序为：

function fn(fn2){
    var fn2;
    function fn2(){
         console.log('fnnn2');
     }
    console.log(fn2);//输出fn2函数
    fn = 3;
    console.log(fn2);//输出3
    console.log(fn);//输出fn函数
 }
fn(10);

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

因为变量提升函数提升之后，fn被赋值为1，此时fn已经不是一个函数所以会报错。

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

因为变量提升之后，i和j并没有被赋值所以前两个console.log会undefined，之后i与j被赋值了，所以后两个console.log会有值。

    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(){
    console.log(i);//此时i没有赋值所以为undefined；
    i=99;
    function fn2(){
    i=100;
}
    console.log(i);//此时赋值为100；
}
}
i=10;
fn=20;
console.log(i)//此时赋值为10；

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

这是一个立即执行函数表达式，所以会按顺序执行,console.log(n)会按照给定参数执行 10,9,8,7,6,5,4,3,2当执行到n<3时会触发return跳出函数，在外部函数变量say=0覆盖方法赋值，所以最后一个为0。

本文版权归本人和饥人谷所有，转载请注明来源