摘要：學習筆記函數擴展函數參數的默認值如果參數默認值是變量，那么參數就不是傳值的，而是每次都重新計算默認值表達式的值。屬性函數的屬性，返回該函數的函數名。箭頭函數詳細鏈接參考引用函數擴展

function Point(x = 0, y = 0) {
    this.x = x;
    this.y = y;
}

var p = new Point();
console.log(p) // { x: 0, y: 0 }

如果參數默認值是變量，那么參數就不是傳值的，而是每次都重新計算默認值表達式的值。也就是說，參數默認值是惰性求值的。

let x = 99;
function foo(p = x + 1) {
    console.log(p);
}

foo() // 100

x = 100;
foo() // 101

function foo({x, y = 5}) {
    console.log(x, y);
}

foo({}) // undefined, 5,觸發默認值
foo({x: 1}) // 1, 5 ,觸發默認值
foo({x: 1, y: 2}) // 1, 2
//因為參數是一個對象,對象之后才會解析x y參數
foo() // TypeError: Cannot read property "x" of undefined

//雙重默認值,第一重是對象默認值,第二重是對象里面的屬性的默認值
function fetch(url, { method = "GET" } = {}) {
    console.log(method);
}
//當觸發兩重的默認值的時候,會使用最里面的默認值
fetch("http://example.com")
// "GET"

function foo(x = 5, y = 6) {
    console.log(x, y);
}

//undefiend會觸發默認值,null則不會
foo(undefined, null)
// 5 null

指定了默認值以后，函數的length屬性，將返回沒有指定默認值的參數個數。也就是說，指定了默認值后，length屬性將失真。

console.log((function (a) {}).length) // 1
console.log((function (a = 5) {}).length) // 0
console.log((function (a, b, c = 5) {}).length) // 2

一旦設置了參數的默認值，函數進行聲明初始化時，參數會形成一個多帶帶的作用域（context）。等到初始化結束，這個作用域就會消失。這種語法行為，在不設置參數默認值時，是不會出現的。

var x = 1;
//即使x=1,但是沒有影響里面的值
function f(x, y = x) {
    console.log(y);
}

f(2) // 2
//---------------------------

let x = 1;
//同理,不過這里是函數里面設置了x值來測試
function f(y = x) {
    let x = 2;
    console.log(y);
}

f() // 1

如果參數的默認值是一個函數，該函數的作用域也遵守這個規則

let foo = "outer";
//設置了一個默認值func,是一個匿名函數,匿名函數返回的是foo變量
//這個變量指向的是外部的foo,因為默認值形成的多帶帶作用域沒有foo,所以會向上層繼續找
function bar(func = x => foo) {
    let foo = "inner";
    console.log(func()); // outer
}
//觸發默認值,所以輸出
bar();

var x = 1;
//y的默認值是一個匿名函數,并且里面設置了x=2,
//這個x是指向參數里的x,他們屬于同一個多帶帶的作用域(默認值生成的)
function foo(x, y = function() { x = 2; }) {
    var x = 3;
    y();//執行y后并沒有改變內部函數的x
    console.log(x);//所以輸出3
}

foo() // 3
console.log(x) // 1,x沒有變化,所以是1

參數的默認值不是在定義時執行，而是在運行時執行（即如果參數已經賦值，默認值中的函數就不會運行）

//參數默認值設為undefined，表明這個參數是可以省略的。
function foo(optional = undefined) { ··· }

ES6 引入 rest 參數（形式為“...變量名”），用于獲取函數的多余參數，這樣就不需要使用arguments對象了。rest 參數搭配的變量是一個數組，該變量將多余的參數放入數組中。

function add(...values) {
    let sum = 0;

    for (var val of values) {
        sum += val;
    }

    return sum;
}
//自動獲取了其他參數
console.log(add(2, 5, 3)) // 10

// arguments變量的寫法
function sortNumbers() {
  return Array.prototype.slice.call(arguments).sort();
}

// rest參數的寫法
const sortNumbers = (...numbers) => numbers.sort();

function push(array, ...items) {//...的是數組
  items.forEach(function(item) {//支持數組的方法forEach
    array.push(item);
    console.log(item);
  });
}

var a = [];
push(a, 1, 2, 3)

擴展運算符（spread）是三個點（...）。它好比 rest 參數的逆運算，將一個數組轉為用逗號分隔的參數序列。(輸出結果并沒有使用逗號分隔)

console.log(...[1, 2, 3])
// 1 2 3

console.log(1, ...[2, 3, 4], 5)
// 1 2 3 4 5

由于擴展運算符可以展開數組，所以不再需要apply方法，將數組轉為函數的參數了。

// ES5的寫法
function f(x, y, z) {
  // ...
}
var args = [0, 1, 2];
f.apply(null, args);

// ES6的寫法
function f(x, y, z) {
  // ...
}
var args = [0, 1, 2];
f(...args);

// ES5的寫法
Math.max.apply(null, [14, 3, 77])

// ES6的寫法
Math.max(...[14, 3, 77])

// 等同于
Math.max(14, 3, 77);

（1）合并數組

var arr1 = ["a", "b"];
var arr2 = ["c"];
var arr3 = ["d", "e"];

// ES5的合并數組
console.log(arr1.concat(arr2, arr3));
// [ "a", "b", "c", "d", "e" ]

// ES6的合并數組
console.log([...arr1, ...arr2, ...arr3])
// [ "a", "b", "c", "d", "e" ]

（2）與解構賦值結合

const [first, ...rest] = [1, 2, 3, 4, 5];
//位置是對應的
console.log(first) // 1
console.log(rest)  // [2, 3, 4, 5]

const [first, ...rest] = [];
//當沒有參數的時候,rest參數能夠獲取空數組
console.log(first) // undefined
console.log(rest)  // []:

const [first, ...rest] = ["foo"];
//有參數的時候,按順序
console.log(first)  // "foo"
console.log(rest)   // []

（3）函數的返回值
直接返回多個值

var dateFields = [1,2,3,4,5];
var d = test(...dateFields);
function test(x,y,z,a,b) {
    console.log(x);
    console.log(y);
    console.log(z);
    console.log(a);
    console.log(b);
}
d;

（4）字符串
將字符串轉為數組

[..."hello"]
// [ "h", "e", "l", "l", "o" ]

（5）實現了Iterator接口的對象
任何Iterator接口的對象，都可以用擴展運算符轉為真正的數組。

在ES6中，有三類數據結構原生具備Iterator接口：數組、某些類似數組的對象、Set和Map結構,但是其他數據結構并沒有(主要是對象),需要自己手動設置

（6）Map和Set結構，Generator函數
擴展運算符內部調用的是數據結構的Iterator接口，因此只要具有Iterator接口的對象，都可以使用擴展運算符，比如Map結構。

ECMAScript 2016標準》做了一點修改，規定只要函數參數使用了默認值、解構賦值、或者擴展運算符，那么函數內部就不能顯式設定為嚴格模式，否則會報錯。

函數的name屬性，返回該函數的函數名。

詳細鏈接

參考引用:

es6函數擴展