函数

函数声明与函数表达式
内置函数
call和apply的使用与区别?
深入理解匿名函数与闭包

面试指南

，参考：arguments对象
如何理解JavaScript中的引用传递与值传递？JS中是否拥有引用传递？，参考：
经典面试题：什么是匿名函数和闭包？，参考：深入理解匿名函数与闭包

函数声明与函数表达式

对于函数声明解释器会首先读取，并使其在执行任何代码之前可用；对于函数表达式，则必须等到解释器执行到它所在的代码行，才会被真正解析。

例如下面例子，函数表达式test2必须声明在其调用之前才可用

const factorial = (function f(num){
    if(num <= 1){
        return 1;
    }else{
        return num * f(num -1);
    }
});
console.log(factorial(3)); // 6

内置函数

push()

let a = [].push('test'); 输出a的值为1而不是['test']，因为push()返回的是数组的长度。

let a  = [];
a.push('test');
console.log(a); //['test']

arguments对象

系统内置的arguments对象，可以用于获取函数参数、参数长度等

面试：递归调用实现一个阶乘函数

function sum(num){
    if(num <= 1){
        //获取参数长度
        console.log('arguments.length: ', arguments.length);
        return 1;
    }else{
        return num * arguments.callee(num-1);
    }
}
console.log(sum(3));

apply使用情况

function box(num1,num2){
    return num1+num2;
}
function sum(num1,num2){
    return box.apply(this,[num1,num2]);
    //或者下面写法arguments可以当数组传递
    //return box.apply(this,arguments);
}
console.log(sum(10,10)); //输出结果: 20

call的使用示例

function box(num1,num2){
    return num1+num2;
}
function sum2(num1,num2){
}
console.log(sum(10,10)); //输出结果: 20

总结两种情况区别： apply传递参数是按照数组传递，call是一个一个传递

引用传递

示例一：js代码按值传递

如果按引用传递，那么函数里面的num会变成类似全局变量，最后输出60

示例二：php代码传递一个参数：

php中的引用传递，会改变外部的num值，最后num也会输出60。

function box(&$num){ 
    //加上&符号将num变成全局变量
    $num+=10;
    return $num;
}
$num = 50;
echo box($num);    // 60
echo $num;    // 60

示例三：js代码传递一个对象

function box(obj){ // 按对象传递
    obj.num+=10;
    return obj.num;
}
var obj = { num: 50 };
console.log(box(obj));  // 60
console.log(obj.num);    // 60

匿名函数与闭包

匿名函数就是没有名字的函数，闭包是可访问一个函数作用域里变量的函数，由于闭包作用域返回的局部变量资源不会被立刻销毁回收，所以可能会占用更多的内存。过度使用闭包会导致性能下降，建议在非常有必要的时候才使用闭包。

匿名函数的自我执行

(function(num){
        return num;
    })(1) //1

函数里放一个匿名函数将会产生闭包

使用局部变量实现累加功能。
定义函数test1，返回一个匿名函数形成一个闭包
将test1赋给test2，此时test2会初始化变量a，值为test1返回的匿名函数
执行test2()

{
function test1(){
    var a = 1;
    return function(){
        // a++;
        // return a;
        // 或以下写法
        return ++a;
    }
}
var test2 = test1();
console.log(test2()); // 2
console.log(test2()); // 3
console.log(test2()); // 4
//不能这样写,这样外层函数每次也会执行，从而age每次都会初始化
console.log(test1()()); // 2
console.log(test1()()); // 2
}

闭包中使用this对象将会导致的一些问题

var box={
    getThis:function(){
        return this;
    }
}
console.log(box.getThis()); // { getThis: [Function: getThis] }

闭包中的this将返回全局对象，浏览器中window对象，Node.js中global对象，可以使用对象冒充或者赋值来解决闭包中this全局对象问题。

对象冒充

var box={
    user: 'zs',
    getThis:function(){
        return function(){
            return this;   
        };
    }
}
console.log(box.getThis().call(box)); // { user: 'zs', getThis: [Function: getThis] }

赋值

var box={
    user: 'zs',
    getThis:function(){
        var that = this; // 此时的this指的是box对象
        return function(){
            return that.user;   
        };
    }
}
console.log(box.getThis()());

一个例子看懂循环和闭包之间的关系

下例，循环中的每个迭代器在运行时都会给自己捕获一个i的副本，但是根据作用域的工作原理，尽管循环中的五个函数分别是在各个迭代器中分别定义的，但是它们都会被封闭在一个共享的全局作用域中，实际上只有一个i，结果每次都会输出6

for(var i=1; i <= 5; i++){
    setTimeout(function(){
        console.log(i);
    })
}

解决上面的问题，在每个循环迭代中都需要一个闭包作用域，下面示例，循环中的每个迭代器都会生成一个新的作用域。

for(var i=1; i <= 5; i++){
    (function(j){
        setTimeout(function(){
            console.log(j);
        })
    })(i)
}

也可以使用let解决，let声明，可以用来劫持块作用域，并且在这个块作用域中声明一个变量。

for(let i=1; i <= 5; i++){
    setTimeout(function(){
        console.log(i);
    })