Funtion类型，需要理解原型链

1.定义

每个函数都是Function类型的实例，因此函数也是对现象。
如何理解这句话呢？我们从一个例子入手
（1）阐述

__proto__的含义是 实例对象指向实例原型
实例的原型对象就是构造函数.prototype

let fun = new Function()
function test () {}
console.log(fun.__proto__ === Function.prototype)
console.log(test.__proto__ === Function.prototype)
console.log(fun.__proto__ === test.__proto__ )

所有函数.__proto__ === Function.Prototype

（2）奇特之处

Function.__proto__===Function.Prototype // true

（3）深入理解

Function作为一个函数对象实例，它有__proto__,指向原型。
Function又是一个构造函数，有它自己的prototype，指向原型。
然后 Function.__proto__ === Object.prototype // false

（4）Function 与 Object 的关系

所有函数.prototype虽然是实例原型,但是实例原型本质还是一个对象,也就是说所有的实例原型对象是Object()构造函数的实例

String.prototype.__proto__=== Object.prototype //true
Number.prototype.__proto__=== Object.prototype //true
Boolean.prototype.__proto__=== Object.prototype //true
//同理
Function.prototype.__proto__=== Object.prototype //true

总结

1. 如果把函数看成对象，那么函数.__proto__ === Function.prototype
2. 如果把 Function 看成对象，那么 Function.__proto__ === Function.prototype
3. 因此：实例对象.proto === 构造函数.prototype
4. 原型链：每层的__proto__都指向上一层的原型,所以一层一层的__proto__组成的链就成为原型链
5. 最终 Object.prototype.proto // null

2.函数声明与函数表达式

// 函数声明
function sum (num1, num2) {
	return num1 + num2
}
// 函数表达式
let num = function (num1, num2) {
	return num1 + num2
}

解析器会先读入函数声明，并使其在执行任何代码之前可以访问（会出现变量提升现象）；
函数表达式必须等到解析器执行到它所在位置时，才会被解析执行。

// 可以正常执行
console.log(sum1(1, 20))
function sum1 (num1, num2) {
	return num1 + num2
}

//  Cannot access 'sum2' before initialization
console.log(sum2(1, 20))
let num2 = function (num1, num2) {
	return num1 + num2
}

3.函数内部属性

函数内部有两个特殊的对象： arguments和this。
arguments 是一个类数组对象，包含着传入函数中的所有参数。
this 引用的是函数执行环境对象（this值）

// arguments参与阶乘计算
function factorial (num) {
	if (num <= 1) {
		return 1 
	} else {
		return num * arguments.callee(num - 1)
	}
}

// this 指向
window.color = 'red'
let obj = {
    color: 'blue'
}
function showColor () {
    console.log(this.color)
}

showColor() // 'red'

obj.showColor = showColor
obj.showColor() // 'blue'