JavaScript里的函数

函数

函数, function, 是一个关键字, 表示声明一个函数, 是一个变量的特例.

每个函数,都必须有一个return, 若是不写return, 默认会添加return undefined.

函数本质

函数就是将作一件相同事情的代码整合到一块儿,做为代码块, 能够被反复调用,能够执行代码的对象就是函数.

函数的五种声明方式

1. 具名函数

function x(input1, input2){ return }
复制代码

2. 匿名函数

var x = function(input1, input2){ return }
// 匿名函数必须给一个变量
复制代码

3. 具名函数赋值

var x = function y(input1, input2){ return }
复制代码

4. Window.function

var x = new Function('x', 'y', 'return x + y')
复制代码

5. 箭头函数

var x = (x, y) => { return x + y}
var x = (x, y) => { let n = x * 3; let m = y * 4; return n + m;}
复制代码

具名函数和具名函数赋值两种声明的区别:

不一致性, 做用域不一样, 垃圾特性.

分别声明具名函数和具名函数赋值, 并console.log(函数):

console.log()原理

console.log = function(a){
    alert(a)
    return undefined
}
// 因而可知, console.log 永远返回undefined, 返回什么和打印什么 一点关系没有
复制代码

函数的name属性

var f2 = function(){}
f2.name = "f2";

var f3 = function f4(){}
f3.name = "f4"

var f5 = new Function('x','y','return x + y')
f5.name = "anonymous" // 匿名的意思
复制代码

如何调用函数

function f(x,y){ return x + y }

f(1,2) // 3

// 骨灰级写法, 真正的函数调用
f.call(undefined, 1, 2)

复制代码

call()原理:

var f = new Function('x','y','console.log(1)')
f.call() // 1
// Function构造函数, 除了最后一个参数是函数体, 其余的都是参数
// 分解以下
var f = {};
f.parmas = ['x','y'];
f.functionBody = 'console.log(1)';
f.call = function(){
    window.eval(f.functionBody)
}
f.call() // 1
复制代码

由上可得出: 为何说函数是对象, 由于调用的过程就是执行eval函数体的过程, 能够执行代码的对象就是函数

f和f.call()的区别:

f 是对象, f.call 是执行对象的函数体

this 和 arguments

call()的第一个参数能够用this获得.后面的参数能够用arguments获得.

• this

上述代码中f.call(undefined, 1, 2), undefined就是this, 当时要求JS必须长的像java, 全部强行加了this

• arguments

上述代码中f.call(undefined, 1, 2), [1,2]就是arguments.

• arguments也是一个伪数组, 由于长的像数组, 原型链中没有Array.prototype, 或者是____proto____没有指向Array.prototype.

function f(){
    console.log(this)
}
f.call(1) // Number 对象 1


function f(){
 'use strict' // 严格模式
    console.log(this)
}
f.call(1) // 1
复制代码

做用域

做用域（scope）指的是变量存在的范围。在 ES5 的规范中，Javascript 只有两种做用域：一种是全局做用域，变量在整个程序中一直存在，全部地方均可以读取；另外一种是函数做用域，变量只在函数内部存在.只要有函数就有做用域

做用域对应的数据结构是树:

var a = 1;
function f(){
    console.log(a)
    var a = 2;
   
    function f2(){
        console.log(a)
    }
}
function f1(){
    var a = 3;
    console.log(a)
}

console.log(a)
f()

// 代码做用域以下图:
复制代码

• 函数外部声明的变量就是全局变量（global variable），它能够在函数内部读取。

• 在函数内部定义的变量，外部没法读取，称为“局部变量”（local variable）。

函数内部的变量提高

与全局做用域同样，函数做用域内部也会产生“变量提高”现象。var命令声明的变量，无论在什么位置，变量声明都会被提高到函数体的头部。

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

// 等同于
function f(){
    var a;
    console.log(a);
    var a = 1;
}

// a 打印出undefined
复制代码

函数自己的做用域

函数自己也是一个值，也有本身的做用域。它的做用域与变量同样，就是其声明时所在的做用域，与其运行时所在的做用域无关。

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

function f(){
    var a = 2;
    x();
}
f(); // 1

// 等同于
var a;
a = 1;
function x(){
    console.log(a); // 1
}

function f(){
    var a;
    a = 2;
    x();
}
f();
复制代码

上面代码中，函数x是在函数f的外部声明的，因此它的做用域绑定外层，内部变量a不会到函数f体内取值，因此输出1，而不是2。

总之，函数执行时所在的做用域，是定义时的做用域，而不是调用时所在的做用域.

闭包

若是一个函数, 使用了它范围外的值, 那么(这个函数+这个变量)就叫作闭包.