- map()
是數組的方法，對數組中每一個元素執行相同的函數，并返回新的數組
可以理解為一種映射。
var a=[1,2,3,4,5,6,7,8];
var fun_a=function(item){
return item*2;
}
var aa=a.map(fun_a);
- filter()
與map()相似，但是可以根據函數返回bool值選擇是否保留當前元素，返回篩選后的新數組。
var a=[1,2,3,4,5,6,7,8];
var fun_a=function(item){
if(item%2 == 1)
return false;
else return true;
}
var aa=a.filter(fun_a);
- reduce()
也是數組的方法，將數組最后求出一個值
var a=[1,2,3,4,5,6,7,8];
var fun_a=function(i,j){
return i+j;
}
var aa=a.reduce(fun_a);
-
閉包
很難又好像很簡單，是否可以理解為在一個函數內a內聲明一個函數b，但是不直接調用函數b，只把這個函數b作為函數a的返回值，再在需要的地方調用。同時，聲明在函數a中的變量成為靜態變量，只在函數b中可以使用。
var fun_a = function(){
var i=0;
var fun_b = function(){
i+=1;
console.log(i);
}
return fun_b;
}
var fun_bb = fun_a();
console.log(fun_bb);
fun_bb();//console.log(1);
fun_bb();//console.log(2);
fun_bb();//console.log(3);
但是
需要注意的問題是，返回的函數并沒有立刻執行，而是直到調用了f()才執行。
function count() {
var arr = [];
for (var i=1; i<=3; i++) {
arr.push(function () {
return i * i;
});
}
return arr;
}
var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];
console.log( f1() );
console.log( f2() );
console.log( f3() );
在上面的例子中，每次循環，都創建了一個新的函數，然后，把創建的3個函數都添加到一個Array中返回了。
開始時我認為調用f1()，f2()和f3()結果應該是1，4，9，但實際結果是：
f1(); // 16
f2(); // 16
f3(); // 16
全部都是16！原因就在于返回的函數引用了循環變量 i，但它并非立刻執行。等到3個函數都返回時，它們所引用的變量i已經變成了4，因此最終結果為16。
返回閉包時牢記的一點就是：返回函數不要引用任何循環變量，或者后續會發生變化的變量。
如果一定要引用循環變量怎么辦？
方法是再創建一個函數，用該函數的參數綁定循環變量當前的值，也就間接將循環變量轉變為內部函數參數，作為非循環變量，無論該循環變量后續如何更改，已綁定到函數參數的值不變：
function count() {
var arr = [];
for (var i=1; i<=3; i++) {
arr.push((function (n) {
return function () {
return n * n;
}
})(i));
}
return arr;
}
var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];
f1(); // 1
f2(); // 4
f3(); // 9
閉包會使變量始終保存在內存中，如果不當使用會增大內存消耗。
javascript的垃圾回收原理：
（1）、在javascript中，如果一個對象不再被引用，那么這個對象就會被GC回收；
（2）、如果兩個對象互相引用，而不再被第3者所引用，那么這兩個互相引用的對象也會被回收。
那么使用閉包有什么好處呢？使用閉包的好處是：
1.希望一個變量長期駐扎在內存中
2.避免全局變量的污染
3.私有成員的存在
-
Generator
generator跟函數很像，定義如下：
function* foo(x) {
yield x + 1;
yield x + 2;
return x + 3;
}
generator和函數不同的是，generator由function*定義（注意多出的*號），并且，除了return語句，還可以用yield返回多次。
我們以一個著名的斐波那契數列為例，可以這么寫：
function fib(max) {
var
t,
a = 0,
b = 1,
arr = [0, 1];
while (arr.length < max) {
t = a + b;
a = b;
b = t;
arr.push(t);
}
return arr;
}
// 測試:
fib(5); // [0, 1, 1, 2, 3]
fib(10); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
函數只能返回一次，所以必須返回一個Array。但是，如果換成generator，就可以一次返回一個數，不斷返回多次。用generator改寫如下：
function* fib(max) {
var
t,
a = 0,
b = 1,
n = 1;
while (n < max) {
yield a;
t = a + b;
a = b;
b = t;
n ++;
}
return a;
}
直接調用：
fib(5);
直接調用一個generator和調用函數不一樣，fib(5)僅僅是創建了一個generator對象，還沒有去執行它。
調用generator對象有兩個方法，一是不斷地調用generator對象的next()方法：
var f = fib(5);
f.next(); // {value: 0, done: false}
f.next(); // {value: 1, done: false}
f.next(); // {value: 1, done: false}
f.next(); // {value: 2, done: false}
f.next(); // {value: 3, done: true}
next()方法會執行generator的代碼，然后，每次遇到yield x;就返回一個對象{value: x, done: true/false}，然后“暫停”。返回的value就是yield的返回值，done表示這個generator是否已經執行結束了。如果done為true，則value就是return的返回值。
當執行到done為true時，這個generator對象就已經全部執行完畢，不要再繼續調用next()了。
第二個方法是直接用for ... of循環迭代generator對象，這種方式不需要我們自己判斷done：
for (var x of fib(5)) {
console.log(x); // 依次輸出0, 1, 1, 2, 3
}
generator和普通函數相比，有什么用？
因為generator可以在執行過程中多次返回，所以它看上去就像一個可以記住執行狀態的函數，利用這一點，寫一個generator就可以實現需要用面向對象才能實現的功能。
