目录
一、函数
函数是⼀段可以反复调⽤的代码块。函数还能接受输⼊的参数，不同的参数会返回不同的值。
函数概述
函数的声明
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) // myFunclength 属性
函数的length属性返回函数预期传⼊的参数个数，即函数定义之中的参数个数。
function f(a, b) {}
f.length // 2toString()
函数的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) // 2arguments 对象
由于 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) // []