JavaScript进阶11笔记.md
函数是 JavaScript 中的基本组件之一。
一个函数是 JavaScript 过程 — 一组执行任务或计算值的语句。
要使用一个函数，你必须将其定义在你希望调用它的作用域内。
一个 JavaScript 函数用function关键字定义，后面跟着函数名和圆括号。
定义函数
函数声明
一个函数定义（也称为函数声明，或函数语句）由一系列的function关键字组成，依次为：
-
函数的名称。
-
函数参数列表，包围在括号中并由逗号分隔。
-
定义函数的 JavaScript 语句，用大括号
{}括起来。
例如，以下的代码定义了一个简单的square函数：
function square(number) { //参数为number
return number * number; //return确定函数的返回值
}
函数表达式
虽然上面的函数声明在语法上是一个语句，但函数也可以由函数表达式创建。这样的函数可以是匿名的；它不必有一个名称。例如，函数square也可这样来定义：
const square = function(number) { return number * number; };
var x = square(4); // x gets the value 16
然而，函数表达式也可以提供函数名，并且可以用于在函数内部代指其本身，或者在调试器堆栈跟踪中识别该函数：
const factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};
console.log(factorial(3));
当将函数作为参数传递给另一个函数时，函数表达式很方便。下面的例子演示了一个叫map的函数如何被定义，而后使用一个表达式函数作为其第一个参数进行调用：
function map(f,a) {
let result = []; // 创建一个数组
let i; // 声明一个值，用来循环
for (i = 0; i != a.length; i++)
result[i] = f(a[i]);
return result;
}
下面的代码：
function map(f, a) {
let result = []; // 创建一个数组
let i; // 声明一个值，用来循环
for (i = 0; i != a.length; i++)
result[i] = f(a[i]);
return result;
}
const f = function(x) {
return x * x * x;
}
let numbers = [0,1, 2, 5,10];
let cube = map(f,numbers);
console.log(cube);
返回 [0, 1, 8, 125, 1000]。
在 JavaScript 中，可以根据条件来定义一个函数。比如下面的代码，当num 等于 0 的时候才会定义 myFunc ：
var myFunc;
if (num == 0){
myFunc = function(theObject) {
theObject.make = "Toyota"
}
}
调用函数
定义一个函数并不会自动的执行它。定义了函数仅仅是赋予函数以名称并明确函数被调用时该做些什么。调用函数才会以给定的参数真正执行这些动作。例如，一旦你定义了函数square，你可以如下这样调用它：
square(5);
上述语句通过提供参数 5 来调用函数。函数执行完它的语句会返回值 25。
函数一定要处于调用它们的域中，但是函数的声明可以被提升 (出现在调用语句之后)，如下例：
console.log(square(5));
/* ... */
function square(n) { return n*n }
函数域是指函数声明时的所在的地方，或者函数在顶层被声明时指整个程序。
备注： 只有使用如上的语法形式（即 function funcName(){}）才可以。而下面的代码是无效的。就是说，函数提升仅适用于函数声明，而不适用于函数表达式。
函数可以被递归，就是说函数可以调用其本身。例如，下面这个函数就是用递归计算阶乘：
function factorial(n){
if ((n == 0) || (n == 1))
return 1;
else
return (n * factorial(n - 1));
}
你可以计算 1-5 的阶乘如下：
var a, b, c, d, e;
a = factorial(1); // 1 赋值给 a
b = factorial(2); // 2 赋值给 b
c = factorial(3); // 6 赋值给 c
d = factorial(4); // 24 赋值给 d
e = factorial(5); // 120 赋值给 e
函数作用域
在函数内定义的变量不能在函数之外的任何地方访问，因为变量仅仅在该函数的域的内部有定义。相对应的，一个函数可以访问定义在其范围内的任何变量和函数。换言之，定义在全局域中的函数可以访问所有定义在全局域中的变量。在另一个函数中定义的函数也可以访问在其父函数中定义的所有变量和父函数有权访问的任何其他变量。
// 下面的变量定义在全局作用域 (global scope) 中
var num1 = 20,
num2 = 3,
name = "Chamahk";
// 本函数定义在全局作用域
function multiply() {
return num1 * num2;
}
multiply(); // 返回 60
// 嵌套函数的例子
function getScore() {
var num1 = 2,
num2 = 3;
function add() {
return name + " scored " + (num1 + num2);
}
return add();
}
getScore(); // 返回 "Chamahk scored 5"
作用域和函数堆栈
递归
一个函数可以指向并调用自身。有三种方法可以达到这个目的：
-
函数名
-
-
作用域下的一个指向该函数的变量名
例如，思考一下如下的函数定义：
var foo = function bar() {
// statements go here
};
在这个函数体内，以下的语句是等价的：
-
bar() -
arguments.callee()（译者注：ES5 禁止在严格模式下使用此属性） -
foo()
调用自身的函数我们称之为递归函数。在某种意义上说，递归近似于循环。两者都重复执行相同的代码，并且两者都需要一个终止条件（避免无限循环或者无限递归）。例如以下的循环：
var x = 0;
while (x < 10) { // "x < 10" 是循环条件
// do stuff
x++;
}
可以被转化成一个递归函数和对其的调用：
function loop(x) {
if (x >= 10) // "x >= 10" 是退出条件（等同于 "!(x < 10)"）
return;
// 做些什么
loop(x + 1); // 递归调用
}
loop(0);
不过，有些算法并不能简单的用迭代来实现。例如，获取树结构中所有的节点时，使用递归实现要容易得多：
function walkTree(node) {
if (node == null) //
return;
// do something with node
for (var i = 0; i < node.childNodes.length; i++) {
walkTree(node.childNodes[i]);
}
}
跟loop函数相比，这里每个递归调用都产生了更多的递归。
将递归算法转换为非递归算法是可能的，不过逻辑上通常会更加复杂，而且需要使用堆栈。事实上，递归函数就使用了堆栈：函数堆栈。
这种类似堆栈的行为可以在下例中看到：
function foo(i) {
if (i < 0)
return;
console.log('begin:' + i);
foo(i - 1);
console.log('end:' + i);
}
foo(3);
// 输出：
// begin:3
// begin:2
// begin:1
// begin:0
// end:0
// end:1
// end:2
// end:3
嵌套函数和闭包
你可以在一个函数里面嵌套另外一个函数。嵌套（内部）函数对其容器（外部）函数是私有的。它自身也形成了一个闭包。一个闭包是一个可以自己拥有独立的环境与变量的表达式（通常是函数）。
既然嵌套函数是一个闭包，就意味着一个嵌套函数可以”继承“容器函数的参数和变量。换句话说，内部函数包含外部函数的作用域。
可以总结如下：
-
内部函数只可以在外部函数中访问。
-
内部函数形成了一个闭包：它可以访问外部函数的参数和变量，但是外部函数却不能使用它的参数和变量。
下面的例子展示了嵌套函数：
function addSquares(a, b) {
function square(x) {
return x * x;
}
return square(a) + square(b);
}
a = addSquares(2, 3); // returns 13
b = addSquares(3, 4); // returns 25
c = addSquares(4, 5); // returns 41
由于内部函数形成了闭包，因此你可以调用外部函数并为外部函数和内部函数指定参数：
function outside(x) {
function inside(y) {
return x + y;
}
return inside;
}
fn_inside = outside(3); // 可以这样想：给一个函数，使它的值加 3
result = fn_inside(5); // returns 8
result1 = outside(3)(5); // returns 8
保存变量
注意到上例中 inside 被返回时 x 是怎么被保留下来的。一个闭包必须保存它可见作用域中所有参数和变量。因为每一次调用传入的参数都可能不同，每一次对外部函数的调用实际上重新创建了一遍这个闭包。只有当返回的 inside 没有再被引用时，内存才会被释放。
这与在其他对象中存储引用没什么不同，但是通常不太明显，因为并不能直接设置引用，也不能检查它们。
多层嵌套函数
函数可以被多层嵌套。例如，函数 A 可以包含函数 B，函数 B 可以再包含函数 C。B 和 C 都形成了闭包，所以 B 可以访问 A，C 可以访问 B 和 A。因此，闭包可以包含多个作用域；他们递归式的包含了所有包含它的函数作用域。这个称之为作用域链。（稍后会详细解释）
思考一下下面的例子：
function A(x) {
function B(y) {
function C(z) {
console.log(x + y + z);
}
C(3);
}
B(2);
}
A(1); // logs 6 (1 + 2 + 3)
在这个例子里面，C 可以访问 B 的 y 和 A 的 x。这是因为：
-
B 形成了一个包含 A 的闭包，B 可以访问 A 的参数和变量
-
C 形成了一个包含 B 的闭包
-
B 包含 A，所以 C 也包含 A，C 可以访问 B 和 A 的参数和变量。换言之，C 用这个顺序链接了 B 和 A 的作用域
反过来却不是这样。A 不能访问 C，因为 A 看不到 B 中的参数和变量，C 是 B 中的一个变量，所以 C 是 B 私有的。
命名冲突
当同一个闭包作用域下两个参数或者变量同名时，就会产生命名冲突。更近的作用域有更高的优先权，所以最近的优先级最高，最远的优先级最低。这就是作用域链。链的第一个元素就是最里面的作用域，最后一个元素便是最外层的作用域。
看以下的例子：
function outside() {
var x = 5;
function inside(x) {
return x * 2;
}
return inside;
}
outside()(10); // returns 20 instead of 10
命名冲突发生在return x上，inside的参数x和outside变量x发生了冲突。这里的作用链域是{inside, outside, 全局对象}。因此inside的x具有最高优先权，返回了 20（inside的x）而不是 10（outside的x）。
闭包
-
闭包是 JavaScript 中最强大的特性之一。JavaScript 允许函数嵌套，并且内部函数可以访问定义在外部函数中的所有变量和函数，以及外部函数能访问的所有变量和函数。
-
但是，外部函数却不能够访问定义在内部函数中的变量和函数。这给内部函数的变量提供了一定的安全性。
-
此外，由于内部函数可以访问外部函数的作用域，因此当内部函数生存周期大于外部函数时，外部函数中定义的变量和函数的生存周期将比内部函数执行时间长。当内部函数以某一种方式被任何一个外部函数作用域访问时，一个闭包就产生了。
var pet = function(name) { //外部函数定义了一个变量"name"
var getName = function() {
//内部函数可以访问 外部函数定义的"name"
return name;
}
//返回这个内部函数，从而将其暴露在外部函数作用域
return getName;
};
myPet = pet("Vivie");
myPet(); // 返回结果 "Vivie"
实际上可能会比上面的代码复杂的多。在下面这种情形中，返回了一个包含可以操作外部函数的内部变量方法的对象。
var createPet = function(name) {
var sex;
return {
setName: function(newName) {
name = newName;
},
getName: function() {
return name;
},
getSex: function() {
return sex;
},
setSex: function(newSex) {
if(typeof newSex == "string"
&& (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) {
sex = newSex;
}
}
}
}
var pet = createPet("Vivie");
pet.getName(); // Vivie
pet.setName("Oliver");
pet.setSex("male");
pet.getSex(); // male
pet.getName(); // Oliver
在上面的代码中，外部函数的name变量对内嵌函数来说是可取得的，而除了通过内嵌函数本身，没有其他任何方法可以取得内嵌的变量。内嵌函数的内嵌变量就像内嵌函数的保险柜。它们会为内嵌函数保留“稳定”——而又安全——的数据参与运行。而这些内嵌函数甚至不会被分配给一个变量，或者不必一定要有名字。
var getCode = (function(){
var secureCode = "0]Eal(eh&2"; // A code we do not want outsiders to be able to modify...
return function () {
return secureCode;
};
})();
getCode(); // Returns the secret code
备注： 尽管有上述优点，使用闭包时仍然要小心避免一些陷阱。如果一个闭包的函数定义了一个和外部函数的某个变量名称相同的变量，那么这个闭包将无法引用外部函数的这个变量。
var createPet = function(name) { // Outer function defines a variable called "name"
return {
setName: function(name) { // Enclosed function also defines a variable called "name"
name = name; // ??? How do we access the "name" defined by the outer function ???
}
}
}
使用arguments对象
函数的实际参数会被保存在一个类似数组的 arguments 对象中。在函数内，你可以按如下方式找出传入的参数：
arguments[i]
其中i是参数的序数编号（译注：数组索引），以 0 开始。所以第一个传来的参数会是arguments[0]。参数的数量由arguments.length表示。
使用 arguments 对象，你可以处理比声明的更多的参数来调用函数。这在你事先不知道会需要将多少参数传递给函数时十分有用。你可以用arguments.length来获得实际传递给函数的参数的数量，然后用arguments对象来取得每个参数。
例如，设想有一个用来连接字符串的函数。唯一事先确定的参数是在连接后的字符串中用来分隔各个连接部分的字符（译注：比如例子里的分号“；”）。该函数定义如下：
function myConcat(separator) {
var result = ''; // 把值初始化成一个字符串，这样就可以用来保存字符串了！！
var i;
// iterate through arguments
for (i = 1; i < arguments.length; i++) {
result += arguments[i] + separator;
}
return result;
}
你可以给这个函数传递任意数量的参数，它会将各个参数连接成一个字符串“列表”：
// returns "red, orange, blue, "
myConcat(", ", "red", "orange", "blue");
// returns "elephant; giraffe; lion; cheetah; "
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
// returns "sage. basil. oregano. pepper. parsley. "
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
备注： arguments 变量只是“类数组对象”，并不是一个数组。称其为类数组对象是说它有一个索引编号和length属性。尽管如此，它并不拥有全部的 Array 对象的操作方法。
函数参数
从 ECMAScript 6 开始，有两个新的类型的参数：默认参数，剩余参数。
默认参数
在 JavaScript 中，函数参数的默认值是undefined。然而，在某些情况下设置不同的默认值是有用的。这时默认参数可以提供帮助。
在过去，用于设定默认参数的一般策略是在函数的主体中测试参数值是否为undefined，如果是则赋予这个参数一个默认值。如果在下面的例子中，调用函数时没有实参传递给b，那么它的值就是undefined，于是计算a*b得到、函数返回的是 NaN。但是，在下面的例子中，这个已经被第二行获取处理：
function multiply(a, b) {
b = (typeof b !== 'undefined') ? b : 1;
return a*b;
}
multiply(5); // 5
使用默认参数，在函数体的检查就不再需要了。现在，你可以在函数头简单地把 1 设定为b的默认值：
function multiply(a, b = 1) {
return a*b;
}
multiply(5); // 5
剩余参数
这个例子是使用了一个箭头函数，这将在下一节介绍。
function multiply(multiplier, ...theArgs) {
return theArgs.map(x => multiplier * x);
}
var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]
箭头函数
箭头函数表达式（也称胖箭头函数）相比函数表达式具有较短的语法并以词法的方式绑定this。箭头函数总是匿名的。
有两个因素会影响引入箭头函数：更简洁的函数和this
更简洁的函数
在一些函数模式中，更简洁的函数很受欢迎。对比一下：
var a = [
"Hydrogen",
"Helium",
"Lithium",
"Beryllium"
];
var a2 = a.map(function(s){ return s.length });
console.log(a2); // logs [ 8, 6, 7, 9 ]
var a3 = a.map( s => s.length );
console.log(a3); // logs [ 8, 6, 7, 9 ]
this的词法
在箭头函数出现之前，每一个新函数都重新定义了自己的
function Person() {
// 构造函数 Person() 将`this`定义为自身
this.age = 0;
setInterval(function growUp() {
// 在非严格模式下，growUp() 函数将`this`定义为“全局对象”，
// 这与 Person() 定义的`this`不同，
// 所以下面的语句不会起到预期的效果。
this.age++;
}, 1000);
}
var p = new Person();
在 ECMAScript 3/5 里，通过把this的值赋值给一个变量可以修复这个问题。
function Person() {
var self = this; // 有的人习惯用`that`而不是`self`，
// 无论你选择哪一种方式，请保持前后代码的一致性
self.age = 0;
setInterval(function growUp() {
// 以下语句可以实现预期的功能
self.age++;
}, 1000);
}
另外，创建一个约束函数可以使得 this值被正确传递给 growUp() 函数。
箭头函数捕捉闭包上下文的this值，所以下面的代码工作正常。
function Person(){
this.age = 0;
setInterval(() => {
this.age++; // 这里的`this`正确地指向 person 对象
}, 1000);
}
var p = new Person();
预定义函数
JavaScript 语言有好些个顶级的内建函数：
-
eval()方法会对一串字符串形式的 JavaScript 代码字符求值。 -
uneval()方法创建的一个 -
isFinite()函数判断传入的值是否是有限的数值。如果需要的话，其参数首先被转换为一个数值。 -
isNaN()函数判断一个值是否是 -
parseFloat()函数解析字符串参数，并返回一个浮点数。 -
parseInt()函数解析字符串参数，并返回指定的基数（基础数学中的数制）的整数。 -
decodeURI()函数对先前经过 -
decodeURIComponent()方法对先前经过 -
encodeURI()方法通过用以一个，两个，三个或四个转义序列表示字符的 UTF-8 编码替换统一资源标识符（URI）的某些字符来进行编码（每个字符对应四个转义序列，这四个序列组了两个”替代“字符）。 -
encodeURIComponent()
浙公网安备 33010602011771号