一、函数
函数是⼀段可以反复调⽤的代码块。函数还能接受输⼊的参数，不同的参数会返回不同的值。
函数概述
函数的声明
JavaScript 有三种声明函数的⽅法。
1. function 命令 function命令声明的代码区块，就是⼀个函数。function命令后⾯是函数名，函数名后⾯是⼀对圆括号，⾥⾯是传⼊函数的参数。函数体放在⼤括号⾥⾯。
function print(s) { console.log(s); }
2. 函数表达式 除了⽤function命令声明函数，还可以采⽤变量赋值的写法
var print = function(s) { console.log(s); };
3. Function 构造函数 第三种声明函数的⽅式是Function构造函数。
var add = new Function( 'x', 'y', 'return x + y' ); // 等同于 function add(x, y) { return x + y; }
总的来说，这种声明函数的⽅式⾮常不直观，⼏乎⽆⼈使⽤。
函数的重复声明
如果同⼀个函数被多次声明，后⾯的声明就会覆盖前⾯的声明。
function f() { console.log(1); } f() // 2 function f() { console.log(2); } f() // 2
第⼀等公⺠
JavaScript 语⾔将函数看作⼀种值，与其它值（数值、字符串、布尔值等等）地位相同。凡是可以使⽤值的地⽅，就能使⽤函数。⽐如，可以把函数赋值给变量和对象的属性，也可以当作参数传⼊其他函数，或者作为函数的结果返回。函数只是⼀个可以执⾏的值，此外并⽆特殊之处。
由于函数与其他数据类型地位平等，所以在 JavaScript 语⾔中⼜称函数为第⼀等公⺠。
function add(x, y) { return x + y; } // 将函数赋值给⼀个变量 var operator = add; // 将函数作为参数和返回值 function a(op){ return op; } a(add)(1, 1) // 2
函数名的提升
JavaScript 引擎将函数名视同变量名，所以采⽤function命令声明函数时，整个函数会像变量声明⼀样，被提升到代码头部。所以，下⾯的代码不会报错。
f(); function f() {}
但是，如果采⽤赋值语句定义函数，JavaScript 就会报错。
f(); var f = function (){}; // TypeError: undefined is not a function
不能在条件语句中声明函数
根据 ES5 的规范，不得在⾮函数的代码块中声明函数，最常⻅的情况就是if语句
if (foo) { function x() {} }
函数的属性和⽅法
name 属性
函数的name属性返回函数的名字。
function f1() { } f1.name // "f1"
如果是通过变量赋值定义的函数，那么name属性返回变量名。
var f2 = function () {}; f2.name // "f2"
name属性的⼀个⽤处，就是获取参数函数的名字。
var myFunc = function () {}; function test(f) { console.log(f.name); } test(myFunc) // myFunc
length 属性
函数的length属性返回函数预期传⼊的参数个数，即函数定义之中的参数个数。
function f(a, b) {} f.length // 2
toString()
函数的toString⽅法返回⼀个字符串，内容是函数的源码。
function f() { a(); b(); c(); } f.toString() // function f() { // a(); // b(); // c(); // }
函数作⽤域
定义
作⽤域（scope）指的是变量存在的范围。在 ES5 的规范中
JavaScript 只有两种作⽤域：⼀种是全局作⽤域，变量在整个程序中⼀直存在，所有地⽅都可以读取；
另⼀种是函数作⽤域，变量只在函数内部存在。
ES6 ⼜新增了块级作⽤域
函数外部声明的变量就是全局变量（global variable），它可以在函数内部读取。
var v = 1; function f() { console.log(v); } f() // 1
在函数内部定义的变量，外部⽆法读取，称为“局部变量”（local variable）。
function f(){ var v = 1; } v // ReferenceError: v is not defined
函数内部定义的变量，会在该作⽤域内覆盖同名全局变量。
var v = 1; function f(){ var v = 2; console.log(v); } f() // 2 v // 1
注意，对于var命令来说，局部变量只能在函数内部声明，在其他区块中声明，⼀律都是全局变量。
if (true) { var x = 5; } console.log(x); // 5
函数内部的变量提升
与全局作⽤域⼀样，函数作⽤域内部也会产⽣“变量提升”现象。var命令声明的变量，不管在什么位置，变量声明都会被提升到函数体的头部。
function foo(x) { if (x > 100) { var tmp = x - 100; } }
函数本身的作⽤域
函数本身也是⼀个值，也有⾃⼰的作⽤域。它的作⽤域与变量⼀样，就是其声明时所在的作⽤域，与其运⾏时所在的作⽤域⽆关。
var a = 1; var x = function () { console.log(a); }; function f() { var a = 2; x(); } f() // 1
函数参数
函数运⾏的时候，有时需要提供外部数据，不同的外部数据会得到不同的结果，这种外部数据就叫参数。
function square(x) { return x * x; } square(2) // 4 square(3) // 9
参数的省略
函数参数不是必需的，Javascript 允许省略参数。
function f(a, b) { return a; } f(1, 2, 3) // 1 f(1) // 1 f() // undefined f.length // 2
传递⽅式
函数参数如果是原始类型的值（数值、字符串、布尔值），传递⽅式是传值传递（passes by value）。这意味着，在函数体内修改参数值，不会影响到函数外部。
var p = 2; function f(p) { p = 3; } f(p); p // 2
同名参数
如果有同名的参数，则取最后出现的那个值。
function f(a, a) { console.log(a); } f(1, 2) // 2
arguments 对象
由于 JavaScript 允许函数有不定数⽬的参数，所以需要⼀种机制，可以在函数体内部读取所有参数。这就是 arguments 对象的由来。
var f = function (one) { console.log(arguments[0]); console.log(arguments[1]); console.log(arguments[2]); } f(1, 2, 3)
与数组的关系
需要注意的是，虽然arguments很像数组，但它是⼀个对象。数组专有的⽅法（⽐如slice和forEach），不能在arguments对象上直接使⽤。
如果要让arguments对象使⽤数组⽅法，真正的解决⽅法是将arguments转为真正的数组。下⾯是两种常⽤的
转换⽅法：slice⽅法和逐⼀填⼊新数组。
var args = Array.prototype.slice.call(arguments); // 或者 var args = []; for (var i = 0; i < arguments.length; i++) { args.push(arguments[i]); }
函数其他知识
⽴即调⽤的函数表达式
在 Javascript 中，圆括号()是⼀种运算符，跟在函数名之后，表示调⽤该函数。⽐如，print()就表示调⽤print函数。那如何让函数⾃⼰执⾏呢?
(function(){ /* code */ }()); // 或者 (function(){ /* code */ })();
eval 命令
eval命令的作⽤是，将字符串当作语句执⾏
eval('var a = 1;'); a // 1
闭包
闭包（closure）是 Javascript 语⾔的⼀个难点，也是它的特⾊，很多⾼级应⽤都要依靠闭包实现。理解闭包，⾸先必须理解变量作⽤域。前⾯提到，JavaScript 有两种作⽤域：全局作⽤域和函数作⽤域。函数内部可以直接读取全局变量。
var n=999; function f1(){ alert(n); } f1(); // 999
另⼀⽅⾯，在函数外部⾃然⽆法读取函数内的局部变量。
function f1(){ var n=999; } alert(n); // error
这⾥有⼀个地⽅需要注意，函数内部声明变量的时候，⼀定要使⽤var命令。如果不⽤的话，你实际上声明了⼀个全局变量！
function f1(){ n=999; } f1(); alert(n); // 999
如何从外部读取局部变量
出于种种原因，我们有时候需要得到函数内的局部变量。但是，前⾯已经说过了，正常情况下，这是办不到的，只有通过变通⽅法才能实现。
那就是在函数的内部，再定义⼀个函数。
function f1(){ var n=999; function f2(){ alert(n); // 999 } }
在上⾯的代码中，函数f2就被包括在函数f1内部，这时f1内部的所有局部变量，对f2都是可⻅的。但是反过来就不⾏，f2内部的局部变量，对f1就是不可⻅的。
这就是Javascript语⾔特有的"链式作⽤域"结构（chainscope），⼦对象会⼀级⼀级地向上寻找所有⽗对象的变量。所以，⽗对象的所有变量，对⼦对象都是可⻅的，反之则不成⽴。
function f1(){ var n=999; function f2(){ alert(n); } return f2; } var result=f1(); result(); // 999
闭包的概念
上⼀节代码中的f2函数，就是闭包。
各种专业⽂献上的"闭包"（closure）定义⾮常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。
由于在Javascript语⾔中，只有函数内部的⼦函数才能读取局部变量，因此可以把闭包简单理解成 "定义在⼀个函数内部的函数"。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的⼀座桥梁。
闭包的⽤途
闭包可以⽤在许多地⽅。它的最⼤⽤处有两个，⼀个是前⾯提到的可以读取函数内部的变量，另⼀个就是让这些变量的值始终保持在内存中。
function f1(){ var n=999; nAdd=function(){n+=1} function f2(){ alert(n); } return f2; } var result=f1(); result(); // 999 nAdd(); result(); // 1000
在这段代码中，result实际上就是闭包f2函数。它⼀共运⾏了两次，第⼀次的值是999，第⼆次的值是1000。
这证明了，函数f1中的局部变量n⼀直保存在内存中，并没有在f1调⽤后被⾃动清除。
为什么会这样呢？原因就在于f1是f2的⽗函数，⽽f2被赋给了⼀个全局变量，这导致f2始终在内存中，⽽f2的存在依赖于f1，因此f1也始终在内存中，不会在调⽤结束后，被垃圾回收机制（garbage collection）回收。
这段代码中另⼀个值得注意的地⽅，就是"nAdd=function(){n+=1}"这⼀⾏，⾸先在nAdd前⾯没有使⽤var关键字，因此nAdd是⼀个全局变量，⽽不是局部变量。其次，nAdd的值是⼀个匿名函数（anonymous function），⽽这个匿名函数本身也是⼀个闭包，所以nAdd相当于是⼀个setter，可以在函数外部对函数内部的局部变量进⾏操作。
使⽤闭包的注意点
1. 由于闭包会使得函数中的变量都被保存在内存中，内存消耗很⼤，所以不能滥⽤闭包，否则会造成⽹⻚的性能问题，在IE中可能导致内存泄露。解决⽅法是，在退出函数之前，将不使⽤的局部变量全部删除。
2. 闭包会在⽗函数外部，改变⽗函数内部变量的值。所以，如果你把⽗函数当作对象（object）使⽤，把闭包当作它的公⽤⽅法（Public Method），把内部变量当作它的私有属性（private value），这时⼀定要⼩⼼，不要随便改变⽗函数内部变量的值。
var name = "The Window"; var object = { name : "My Object", getNameFunc : function(){ return function(){ return this.name; }; } }; alert(object.getNameFunc()());
var name = "The Window"; var object = { name : "My Object", getNameFunc : function(){ var that = this; return function(){ return that.name; }; } }; alert(object.getNameFunc()());
函数的应⽤
实现阶乘：5 4 3 2 1 的结果
function f(a){ if(a<=1){ return 1 }else{ return a*f(a-1) } }
二、对象
对象（object）是 JavaScript 语⾔的核⼼概念，也是最重要的数据类型。
什么是对象？简单说，对象就是⼀组“键值对”（key-value）的集合，是⼀种⽆序的复合数据集合。
var obj = { foo: 'Hello', bar: 'World' };
上⾯代码中，⼤括号就定义了⼀个对象，它被赋值给变量obj，所以变量obj就指向⼀个对象。
该对象内部包含两个键值对（⼜称为两个“成员”），第⼀个键值对是foo: 'Hello'，其中foo是“键名”（成员的名称），字符串Hello是“键值”（成员的值）。
键名与键值之间⽤冒号分隔。第⼆个键值对是bar: 'World'，bar是键名，World是键值。
两个键值对之间⽤逗号分隔对象的所有键名都是字符串（ES6 ⼜引⼊了 Symbol 值也可以作为键名），所以加不加引号都可以。上⾯的代码也可以写成下⾯这样。
var obj = { 'foo': 'Hello', 'bar': 'World' };
如果键名不符合标识名的条件（⽐如第⼀个字符为数字，或者含有空格或运算符），且也不是数字，则必须加上引号，否则会报错。
// 报错 var obj = { 1p: 'Hello World' }; // 不报错 var obj = { '1p': 'Hello World', 'h w': 'Hello World', 'p+q': 'Hello World' };
对象的每⼀个键名⼜称为“属性”（property），它的“键值”可以是任何数据类型。如果⼀个属性的值为函数，通常把这个属性称为“⽅法”，它可以像函数那样调⽤。
var obj = { p: function (x) { return 2 * x; } }; obj.p(1) // 2
如果属性的值还是⼀个对象，就形成了链式引⽤。
查看所有属性
查看⼀个对象本身的所有属性，可以使⽤Object.keys⽅法。
var obj = { key1: 1, key2: 2 }; Object.keys(obj); // ['key1', 'key2']
delete 命令
delete命令⽤于删除对象的属性，删除成功后返回true。
var obj = { p: 1 }; Object.keys(obj) // ["p"] delete obj.p // true obj.p // undefined Object.keys(obj) // []
