国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

[譯] ES6 中 Arguments 和 Parameters 用法解析

msup / 2517人閱讀

摘要:默認參數(shù)有了我們不需要再去檢測哪些值為并且給它們設定默認值了。我們甚至可以使用函數(shù)去找回默認參數(shù)的值注意這個函數(shù)只有在第二個參數(shù)省略時才會被調(diào)用。瀏覽器對默認參數(shù)的支持情況桌面瀏覽器移動端瀏覽器解構賦值解構賦值是的新特性。

原文地址:https://www.smashingmagazine.com/2016/07/how-to-use-arguments-and-parameters-in-ecmascript-6

By Faraz Kelhini

July 20th, 2016

JavaScriptTools

7 Comments

ECMAScript 6 (也稱 ECMAScript 2015) 是ECMAScript 標準的最新版本,顯著地完善了JS中參數(shù)的處理方式。除了其它新特性外,我們還可以使用rest參數(shù)、默認值、解構賦值等。

本教程中,我們將詳細探索arguments和parameters,看看ES6是如果改善升級它們的。

對比 Arguments 和 Parameters Link

通常情況下提到 Arguments 和 Parameters, 都認為是可以互換使用的。然而,基于本教程的目的,我們做了明確的區(qū)分。在大多數(shù)標準中,parameters (形式參數(shù)) 指聲明函數(shù)名和函數(shù)體的時候使用的參數(shù),而 arguments (實際參數(shù)) 指在函數(shù)實際調(diào)用時,傳入的確定值。思考下面這個函數(shù):

function foo(param1, param2) {
    // do something
}
foo(10, 20); 

在這個函數(shù)中, param1param2 是函數(shù)的形式參數(shù)(形參), 而在函數(shù)foo調(diào)用時,傳入的 (1020) 則是實際參數(shù)(實參)。

擴展操作符 Link

在 ES5 中,用 apply() 方法可以很方便地將一個數(shù)組傳遞給函數(shù)。例如,我們經(jīng)常把它和 Math.max() 結合使用,來取得數(shù)組中的最大值。請看下面代碼:

var myArray = [5, 10, 50];
Math.max(myArray);    // Error: NaN
Math.max.apply(Math, myArray);    // 50 

Math.max() 方法并不支持傳入數(shù)組,它只接受數(shù)字。所以當我們把數(shù)組作為參數(shù)傳遞給它時,就會拋出錯誤。但是,加上 apply() 方法后,數(shù)組會被轉換成多帶帶的數(shù)字,就能被 Math.max() 處理了。

慶幸的是,ES6 引入了擴展操作符,我們不需要再使用 apply() 方法了。通過擴展操作符,我們可以很方便地為表達式傳入多個參數(shù):

var myArray = [5, 10, 50];
Math.max(...myArray);    // 50 

這里,擴展操作符把 myArray 展開成獨立的數(shù)值傳給了函數(shù)。 ES5里面使用 apply() 來模仿操作符是可以達到目的的,只是語法上令人困惑,并且缺乏擴展操作符的靈活性。 擴展操作符不僅易于使用,還涵蓋了很多其他特性。例如,它可以被多次使用,還可以在 function 調(diào)用時,和其它參數(shù)混合使用:

function myFunction() {
  for(var i in arguments){
    console.log(arguments[i]);
  }
}
var params = [10, 15];
myFunction(5, ...params, 20, ...[25]);    // 5 10 15 20 25 

擴展操作符的另一個優(yōu)點,就是它可以很簡單地和構造函數(shù)一起使用:

new Date(...[2016, 5, 6]);    // Mon Jun 06 2016 00:00:00 GMT-0700 (Pacific Daylight Time)` 

當然,我們可以用ES5重寫上面的代碼,但我們則需要用一個復雜的模式來避免類型錯誤:

new Date.apply(null, [2016, 4, 24]);    // TypeError: Date.apply is not a constructor
new (Function.prototype.bind.apply(Date, [null].concat([2016, 5, 6])));   // Mon Jun 06 2016 00:00:00 GMT-0700 (Pacific Daylight Time) 
瀏覽器對擴展操作符在函數(shù)中調(diào)用的支持情況 Link

桌面瀏覽器;

移動端瀏覽器:

Rest參數(shù) Link

rest參數(shù)和擴展操作符擁有相同的語法,不同的是,rest參數(shù)是把所有的參數(shù)收集起來轉換成數(shù)組,而擴展操作符是把數(shù)組擴展成多帶帶的參數(shù)。

function myFunction(...options) {
     return options;
}
myFunction("a", "b", "c");      // ["a", "b", "c"] 

如果函數(shù)調(diào)用時,沒有傳入實際參數(shù),則rest參數(shù)會輸出一個空數(shù)組,如下:

function myFunction(...options) {
     return options;
}
myFunction();      // [] 

rest參數(shù)在創(chuàng)建一個可變函數(shù)(即一個參數(shù)個數(shù)可變的函數(shù))時尤其有用。rest參數(shù)有著數(shù)組固有的優(yōu)勢,可以快捷地替換 arguments 對象(下文會解釋這個名詞)。下面這個函數(shù)是用ES5寫的,我們來看下:

function checkSubstrings(string) {
  for (var i = 1; i < arguments.length; i++) {
    if (string.indexOf(arguments[i]) === -1) {
      return false;
    }
  }
  return true;
}
checkSubstrings("this is a string", "is", "this");   // true 

該函數(shù)檢查字符串(this is a string)是否包括這些子串(is, this)。這個函數(shù)存在的第一個問題是,我們必須看函數(shù)體內(nèi)是否有多個參數(shù)。第二個問題是,循環(huán)必須從 1 開始,而不是從 0 開始, 因為 arguments[0] 指向的就是第一個參數(shù)(this is a string)。 如果以后我們想要在這個字符串的前面或者后面添加另一個參數(shù),我們可能會忘記更新循環(huán)體。而使用rest參數(shù),我們就可以很容易地避免這些問題:

function checkSubstrings(string, ...keys) {
  for (var key of keys) {
    if (string.indexOf(key) === -1) {
      return false;
    }
  }
  return true;
}
checkSubstrings("this is a string", "is", "this");   // true 

該函數(shù)的輸出跟前一個函數(shù)的輸出是一樣的。這里再提一下,參數(shù) string 被包含在這個函數(shù)的 argument 中,并且第一個被傳遞進來,剩下的參數(shù)都被放到一個數(shù)組,并且賦給了名為 keys 的變量。

使用rest參數(shù)替代 arguments 對象來提高代碼的可讀性和避免一些js的優(yōu)化問題1。 然而,rest參數(shù)也不是沒有缺點的。例如,它必須是最后一個參數(shù),否則就會報錯,如下面函數(shù)所示:

function logArguments(a, ...params, b) {
        console.log(a, params, b);
}
logArguments(5, 10, 15);    // SyntaxError: parameter after rest parameter 

另一個缺點是,一個函數(shù)聲明只能允許有一個rest參數(shù):

function logArguments(...param1, ...param2) {
}
logArguments(5, 10, 15);    // SyntaxError: parameter after rest parameter 
瀏覽器對Rest參數(shù)的支持情況 Link

桌面瀏覽器:

移動端瀏覽器:

默認參數(shù) Link ES5 默認參數(shù) Link

在ES5中,JS 并不支持默認參數(shù), 但是,我們也有一種變通的方案,那就是在函數(shù)中使用 OR 操作符( || )。我們簡單地模仿ES5中的默認參數(shù),請看下面函數(shù):

function foo(param1, param2) {
   param1 = param1 || 10;
   param2 = param2 || 10;
   console.log(param1, param2);
}
foo(5, 5);  // 5 5
foo(5);    // 5 10
foo();    // 10 10 

該函數(shù)預期傳入兩個參數(shù),但如果在調(diào)用該函數(shù)時,沒有傳入實參,則它會用默認值。在函數(shù)體內(nèi),如果沒有傳入實際參數(shù),則會被自動設為 undefined, 所以,我們可以檢測這些參數(shù),并且聲明他們的默認值。我們可以使用 OR 操作符(||)來檢測是否有傳入實際參數(shù),并且設定他們的默認值。OR 操作符會檢測它的第一個參數(shù),如果有實際值2,則用第一個,如果沒有,則用它的第二個參數(shù)。

這種方法在函數(shù)中普遍使用,但它有一個瑕疵,那就是傳入 0 或者 null 也會觸發(fā)默認值,因為 0null 都被認為是false. 所以,如果我們需要給函數(shù)傳入 0null 時,我們需要另一種方式去檢測這個參數(shù)是否缺失:

function foo(param1, param2) {
  if(param1 === undefined){
    param1 = 10;
  }
  if(param2 === undefined){
    param2 = 10;
  }
  console.log(param1, param2);
}
foo(0, null);    // 0, null
foo();    // 10, 10 

在上面這個函數(shù)中,只有當所傳的參數(shù)全等于 undefined 時,才會使用默認值。這種方式需要用到的代碼稍微多點,但是安全度更高,我們可以給函數(shù)傳入 0null

ES6 默認參數(shù) Link

有了ES6,我們不需要再去檢測哪些值為undefined并且給它們設定默認值了。現(xiàn)在我們可以直接在函數(shù)聲明中放置默認值:

function foo(a = 10, b = 10) {
  console.log(a, b);
}
foo(5);    // 5 10
foo(0, null);    // 0 null 

如你所見,省略一個參數(shù),就會觸發(fā)一個默認值,但是傳入 0 或者 null 時,則不會。 我們甚至可以使用函數(shù)去找回默認參數(shù)的值:

function getParam() {
    alert("getParam was called");
    return 3;
}
function multiply(param1, param2 = getParam()) {
    return param1 * param2;
}
multiply(2, 5);     // 10
multiply(2);     // 6 (also displays an alert dialog) 

注意 getParam 這個函數(shù)只有在第二個參數(shù)省略時才會被調(diào)用。所以當我們給 multiply 傳入兩個參數(shù)并調(diào)用它時,alert是不會出現(xiàn)的。

默認參數(shù)還有一個有趣的特性,那就是我們可以在函數(shù)聲明中指定其它參數(shù)和變量的值:

function myFunction(a=10, b=a) {
     console.log("a = " + a + "; b = "  + b);
}
myFunction();     // a=10; b=10
myFunction(22);    // a=22; b=22
myFunction(2, 4);    // a=2; b=4 

你甚至可以在函數(shù)聲明中做運算:

function myFunction(a, b = ++a, c = a*b) {
     console.log(c);
}
myFunction(5);    // 36 

請注意,JavaScript 和其它語言不同, 它是在函數(shù)被調(diào)用時,才去求參數(shù)的默認值。

function add(value, array = []) {
  array.push(value);
  return array;
}
add(5);    // [5]
add(6);    // [6], not [5, 6] 
瀏覽器對默認參數(shù)的支持情況 Link

桌面瀏覽器:

移動端瀏覽器:

解構賦值 Link

解構賦值是ES6的新特性。我們可以從數(shù)組和對象中提取值,對變量進行賦值。這種語法清晰且易于理解,尤其是在給函數(shù)傳參時特別有用。

在ES5里面,我們經(jīng)常用一個配置對象來處理大量的可選參數(shù), 特別是當對象屬性的順序可變時:

function initiateTransfer(options) {
    var  protocol = options.protocol,
        port = options.port,
        delay = options.delay,
        retries = options.retries,
        timeout = options.timeout,
        log = options.log;
    // code to initiate transfer
}
options = {
  protocol: "http",
  port: 800,
  delay: 150,
  retries: 10,
  timeout: 500,
  log: true
};
initiateTransfer(options); 

這種方式實現(xiàn)起來很好,已經(jīng)被許多JS開發(fā)者所采用。 只是我們必須看函數(shù)內(nèi)部,才知道函數(shù)預期需要哪些參數(shù)。結合解構賦值,我們就可以在函數(shù)聲明中清晰地表示這些參數(shù):

function initiateTransfer({protocol, port, delay, retries, timeout, log}) {
     // code to initiate transfer
};
var options = {
  protocol: "http",
  port: 800,
  delay: 150,
  retries: 10,
  timeout: 500,
  log: true
}
initiateTransfer(options); 

在該函數(shù)中,我們沒有傳入一個配置對象,而是以對象解構賦值的方式,給它傳參數(shù)。這樣做不僅使這個函數(shù)更加簡明,可讀性也更高。

我們也可以把解構賦值傳參和其它規(guī)則的參數(shù)一起使用:

function initiateTransfer(param1, {protocol, port, delay, retries, timeout, log}) {
     // code to initiate transfer
}
initiateTransfer("some value", options); 

注意如果函數(shù)調(diào)用時,參數(shù)被省略掉,則會拋出錯誤,如下:

function initiateTransfer({protocol, port, delay, retries, timeout, log}) {
     // code to initiate transfer
}
initiateTransfer();  // TypeError: Cannot match against "undefined" or "null" 

當我們需要讓參數(shù)都是必填時,這種方法能夠得到我們想要的結果,但如果我們希望參數(shù)是可選的時候呢?想要讓參數(shù)缺失時不會報錯,我們就需要給默認參數(shù)設定一個默認值:

function initiateTransfer({protocol, port, delay, retries, timeout, log} = {}) {
     // code to initiate transfer
}
initiateTransfer();    // no error 

上面這個函數(shù)中,需要解構賦值的參數(shù)有了一個默認值,這個默認值就是一個空對象。這時候,函數(shù)被調(diào)用時,即使沒有傳入?yún)?shù),也不會報錯了。

我們也可以給每個被解構的參數(shù)設定默認值,如下:

function initiateTransfer({
    protocol = "http",
    port = 800,
    delay = 150,
    retries = 10,
    timeout = 500,
    log = true
}) {
     // code to initiate transfer
} 

在這個例子中,每個屬性都有一個默認值,我們不需要手動去檢查哪個參數(shù)值是 undefined ,然后在函數(shù)中給它設定默認值了。

瀏覽器對解構賦值的支持情況 Link

桌面瀏覽器:

移動端瀏覽器:

參數(shù)傳遞 Link

參數(shù)能通過引用傳遞給函數(shù)。修改按引用傳遞的參數(shù),一般反映在全局中,而修改按值傳遞的參數(shù),則只是反映在函數(shù)內(nèi)部。

在像 Visual BasicPowerShell 這樣的語言中,我們可以選擇是按引用還是按值來傳遞參數(shù),但是在 JavaScript 中則不行。

按值傳遞參數(shù) Link

從技術上來講,JavaScript 只允許按值傳參。當我們給函數(shù)按值傳遞一個參數(shù)時,該函數(shù)的作用域內(nèi)就已經(jīng)復制了這個值。因此,這個值的改變,只會在函數(shù)內(nèi)部反映出來。請思考下面這個列子:

var a = 5;
function increment(a) {
    a = ++a;
    console.log(a);
}
increment(a);   // 6
console.log(a);    // 5 

這里,修改函數(shù)里面的參數(shù) a = ++a,是不會影響到原來a的值。 所以在函數(shù)外面打印 a 的值,輸出仍然是 5

按引用傳遞參數(shù) Link

在JavaScript中,一切都是按值傳遞的。但當我們給函數(shù)傳一個變量,而這個變量所指向的是一個對象(包括數(shù)組)時,這個 變量 就是對象的一個引用。通過這個變量來改變對象的屬性值,是會從根本上改變這個對象的。

來看下面這個例子:

function foo(param){
    param.bar = "new value";
}
obj = {
    bar : "value"
}
console.log(obj.bar);   // value
foo(obj);
console.log(obj.bar);   // new value 

如你所見,對象的屬性值在函數(shù)內(nèi)部被修改了,被修改的值在函數(shù)外面也是可見的。

當我們傳遞一個沒有初始值的參數(shù)時,如數(shù)組或對象,會隱形地創(chuàng)建了一個變量,這個變量指向記憶中原對象所在的位置。這個變量隨后被傳遞給了函數(shù),在函數(shù)內(nèi)部對這個變量進行修改將會影響到原對象。

參數(shù)類型檢測、參數(shù)缺失或參數(shù)多余 Link

在強類型語言中,我們必須在函數(shù)聲明中明確參數(shù)的類型,但是 JavaScript 沒有這種特性。在JavaScript中,我們傳遞給函數(shù)的參數(shù)個數(shù)不限,也可以是任何類型的數(shù)據(jù)。

假設現(xiàn)在有一個函數(shù),這個函數(shù)只接受一個參數(shù)。但是當函數(shù)被調(diào)用時,它本身沒有限制傳入的參數(shù)只能是一個,我們可以隨意地傳入一個、兩個、甚至是更多。我們也可以什么都不傳,這樣都不會報錯。

形參(arguments)和 實參(parameters)的個數(shù)不同有兩種情況:

實參少于形參

缺失的參數(shù)都會等同于 undefined

實參多于形參

多余的參數(shù)都將被忽略,但它們會以數(shù)組的形式保存于變量 arguments 中(下文會討論到)。

必填參數(shù) Link

如果一個參數(shù)在函數(shù)調(diào)用時缺失了,它將被設為 undefined。基于這一點,我們可以在參數(shù)缺失時拋出一個錯誤:

function foo(mandatory, optional) {
    if (mandatory === undefined) {
        throw new Error("Missing parameter: mandatory");
    }
} 

在 ES6 中,我們可以更好地利用這個特性,使用默認參數(shù)來設定必填參數(shù):

function throwError() {
    throw new Error("Missing parameter");
}
function foo(param1 = throwError(), param2 = throwError()) {
    // do something
}
foo(10, 20);    // ok
foo(10);   // Error: missing parameter 
參數(shù)對象 Link

為了取代參數(shù)對象,rest參數(shù)在 ECMAScript 4 中就已經(jīng)得到支持,但是 ECMAScript 4 沒有落實。隨著 ECMAScript 6 版本的發(fā)布,JS 正式支持rest參數(shù)。它也擬定計劃,準備拋棄 對參數(shù)對象 arguments object 的支持。

參數(shù)對象是一個類數(shù)組對象,可在一切函數(shù)內(nèi)使用。它允許通過數(shù)字而不是名稱,來找回被傳遞給函數(shù)的參數(shù)值。這個對象使得我們可以給函數(shù)傳遞任何參數(shù)。思考以下代碼段:

function checkParams(param1) {
    console.log(param1);    // 2
    console.log(arguments[0], arguments[1]);    // 2 3
    console.log(param1 + arguments[0]);    // 2 + 2
}
checkParams(2, 3); 

該函數(shù)預期接收一個參數(shù)。但是當我們給它傳入兩個參數(shù)并且調(diào)用它時,第一個參數(shù)通過名為 param1 的形參或者參數(shù)對象 arguments[0] 被函數(shù)所接受,而第二個參數(shù)只能被放在argument[1] 里面。此外,請注意,參數(shù)對象可以與命名參數(shù)一起使用。

參數(shù)對象給每個被傳遞給函數(shù)的參數(shù)提供了一個入口,并且第一個入口的下標從 0 開始。如果我們要給上面這個函數(shù)傳遞更多的參數(shù),我們可以寫 arguments[2],arguments[3] 等等。

我們甚至可以跳過設定命名參數(shù)這一步,直接使用參數(shù)對象:

function checkParams() {
    console.log(arguments[1], arguments[0], arguments[2]);
}
checkParams(2, 4, 6);  // 4 2 6 

事實上,命名參數(shù)只是為了方便使用,并不是必須的。類似地,rest參數(shù)也可用于反映被傳遞的參數(shù):

function checkParams(...params) {
    console.log(params[1], params[0], params[2]);    // 4 2 6
    console.log(arguments[1], arguments[0], arguments[2]);    // 4 2 6
}
checkParams(2, 4, 6); 

參數(shù)對象是一個類數(shù)組的對象,只是它沒有數(shù)組本身具備的方法,如slice()foreach()。 如果要在參數(shù)對象中使用數(shù)組的方法,首先要把它轉換成一個真正的數(shù)組。

function sort() {
    var a = Array.prototype.slice.call(arguments);
    return a.sort();
}
sort(40, 20, 50, 30);    // [20, 30, 40, 50] 

在該函數(shù)中,采用了 Array.prototype.slice.call() 來快速地把參數(shù)對象轉換成一個數(shù)組。接著,在 sort() 方法中,為這個數(shù)組排序并且把它返回。

ES6 新增了更直接的方法,用 Array.from() 把任何類數(shù)組對象轉換成數(shù)組:

function sort() {
    var a = Array.from(arguments);
    return a.sort();
}
sort(40, 20, 50, 30);    // [20, 30, 40, 50] 
長度屬性 Link

盡管參數(shù)對象從技術上來講,不算是一個數(shù)組,但仍有一個長度屬性,來檢測傳遞給函數(shù)的參數(shù)個數(shù):

function countArguments() {
    console.log(arguments.length);
}
countArguments();    // 0
countArguments(10, null, "string");    // 3 

通過 length 屬性,我們可以更好地控制傳遞給函數(shù)的參數(shù)個數(shù)。舉個例子,如果一個函數(shù)只要求兩個參數(shù),那么我們就可以使用 length 屬性來檢測所傳入的參數(shù)個數(shù),如果少于要求的個數(shù),則拋出錯誤:

function foo(param1, param2) {
    if (arguments.length < 2) {
        throw new Error("This function expects at least two arguments");
    } else if (arguments.length === 2) {
        // do something
    }
} 

rest參數(shù)是數(shù)組,所以他們都有 length 屬性。 所以上面的代碼,在ES6里面可以用rest參數(shù)寫成下面這樣:

function foo(...params) {
  if (params.length < 2) {
        throw new Error("This function expects at least two arguments");
    } else if (params.length === 2) {
        // do something
    }
} 
被調(diào)用屬性與調(diào)用屬性 Link

被調(diào)用 屬性指向當前正在執(zhí)行的函數(shù),而 調(diào)用 屬性則指向那個調(diào)用了 當前正在執(zhí)行的函數(shù) 的函數(shù)。 在ES5的嚴格模式下,這些屬性是不被支持的,如果嘗試使用它們,則會報錯。

arguments.callee 這個屬性在遞歸函數(shù)中很有用,尤其在匿名函數(shù)中。因為匿名函數(shù)沒有名稱,只能通過 arguments.callee 來指向它。

var result = (function(n) {
  if (n <= 1) {
    return 1;
  } else {
    return n * arguments.callee(n - 1);
  }
})(4);   // 24
嚴格模式和非嚴格模式下的參數(shù)對象 Link

在ES5非嚴格模式下,參數(shù)對象 有個不一般的特性:它能使 自身的值與之相對應的命名參數(shù)的值 保持同步。

請看下面這個例子:

function foo(param) {
   console.log(param === arguments[0]);    // true
   arguments[0] = 500;
   console.log(param === arguments[0]);    // true
   return param
}
foo(200);    // 500 

在這個函數(shù)里面,arguments[0] 被重新賦值為 500。由于 arguments 的值總是和對應的命名參數(shù)保持同步,所以改變了arguments[0] 的值,也就相應的改變了 param 的值。實際上,他們就像是同一個變量,擁有兩個不同的名字而已。而在 ES5嚴格模式下,參數(shù)對象的這種特性則被移除了。

"use strict";
function foo(param) {
   console.log(param === arguments[0]);    // true
   arguments[0] = 500;
   console.log(param === arguments[0]);    // false
   return param
}
foo(200);   // 200 

加上 嚴格模式, 現(xiàn)在改變 arguments[0] 的值是不會影響到 param 的值了,打印出來的值也跟預期的一致。 在 ES6中 該函數(shù)的輸出跟在 ES5 嚴格模式下是一樣的。需要記住的是,當函數(shù)聲明中使用了默認值時,參數(shù)對象是不會受到影響的:

function foo(param1, param2 = 10, param3 = 20) {
   console.log(param1 === arguments[0]);    // true
   console.log(param2 === arguments[1]);    // true
   console.log(param3 === arguments[2]);    // false
   console.log(arguments[2]);    // undefined
   console.log(param3);    // 20
}
foo("string1", "string2"); 

在這個函數(shù)中,盡管 param3 有默認值 20,但是 arguments[2] 仍然是 undefined, 因為函數(shù)調(diào)用時只傳了兩個值。換言之,設定默認值對參數(shù)對象是沒有任何影響的。

總結 Link

ES6 給 JS 帶來了上百個大大小小的改進。 越來越多的開發(fā)者正使用ES6的新特性, 所以我們都需要去了解它們。在本教程中,我們學習了ES6是如何改善JS的參數(shù)處理的,但我們?nèi)灾皇侵獣粤薊S6的皮毛。更多新的、有趣的特性值得我們?nèi)ヌ接憽?/p> 參考鏈接 Link

ECMAScript 6 Compatibility Table3, Juriy Zaytsev

ECMAScript 2015 Language Specification4, ECMA International

(rb, ml, al, il)

Front page image credits: JavaScript Planet5.

腳注 Link

1 https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments

2 https://developer.mozilla.org/en-US/docs/Glossary/Truthy

3 https://kangax.github.io/compat-table/es6/

4 http://www.ecma-international.org/ecma-262/6.0/

5 https://www.youtube.com/channel/UCzVnCG4ItKitN1SCBM7-AbA

文章版權歸作者所有,未經(jīng)允許請勿轉載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/86436.html

相關文章

  • []ES6 模塊化入門

    摘要:當我們學習的模塊化,就會發(fā)現(xiàn)它的發(fā)展深受的影響。嚴格模式在模塊系統(tǒng)中,嚴格模式是默認開啟的。同樣的,模塊內(nèi)部的聲明只在模塊內(nèi)部有效。在中,我們使用導入內(nèi)容在模塊中,我們只需要為導入的綁定起一個名字我們也可以導入具名導出的內(nèi)容。 ES6 模塊系統(tǒng) 在 ES6 之前,我們已經(jīng)知道了 RequireJS,AngularJS 的依賴注入,以及 CommonJS,具體可以看筆者的上一篇文章《JS...

    shmily 評論0 收藏0
  • [] 設計模式:發(fā)布/訂閱模式解析

    摘要:發(fā)布訂閱者模式實現(xiàn)了松耦合你可以讓發(fā)布者發(fā)布消息,訂閱者接受消息而不是尋找一種方式把兩個分離的系統(tǒng)連接在一起。這會導致惡意的消息被發(fā)布,訂閱者能夠獲得他們以前并不能獲得的消息。發(fā)布訂閱模式例子 原文:Design Patterns:PubSub Explained 介紹 這個模式用來作為中間人,一個把發(fā)布者和訂閱者架接在一起的代理。發(fā)布者是當完成某些過程的時候觸發(fā)事件的對象,訂閱者是希...

    niuxiaowei111 評論0 收藏0
  • ES6指北【4】——ES6的函數(shù)參數(shù)處理,超乎你想象

    摘要:參數(shù)搭配的變量是一個數(shù)組,該變量將多余的參數(shù)放入數(shù)組中。從上面的概念中,我們至少可以知道如下三個信息語法變量。 一、函數(shù)的默認參數(shù)值 1. ES6之前,我們?nèi)绾螌崿F(xiàn)函數(shù)默認參數(shù) 1.1 方式一:使用邏輯運算符【||】 function test(x) { x = x || 默認值 // 使用||設置默認值 console.log(x) } test() // 默認值 但這樣...

    Pandaaa 評論0 收藏0
  • 如何使用ES6的參數(shù)

    摘要:我們可以利用這一點,如果參數(shù)缺失就拋出錯誤在中,我們可以更近一步,使用默認參數(shù)來設置強制參數(shù)對象在的時候默認參數(shù)就被加入,來代替對象,但并沒有實現(xiàn)。隨著的發(fā)布,現(xiàn)在官方支持了默認參數(shù)。 ECMAScript 6(或者叫 ECMAScript 2015)是 ECMAScript 的最新標準,極大的提高了 JavaScript 中處理參數(shù)的能力。現(xiàn)在我們可以使用 rest 參數(shù)(rest ...

    Hanks10100 評論0 收藏0
  • ES6對函數(shù)的改動

    摘要:改動函數(shù)的改變不算太大,都是一些其他語言早就有的功能,而一直比較欠缺的,比如函數(shù)參數(shù)默認值,任意參數(shù)的表示法,最大的變化應該是支持箭頭函數(shù)其他語言稱之為表達式,一種對匿名函數(shù)的一種簡寫方式,以下來探討一下函數(shù)在中的一些改變默認參數(shù)任意參數(shù)操 ES6 functions改動 ????ES6函數(shù)的改變不算太大,都是一些其他語言早就有的功能,而Javascript一直比較欠缺的,比如函數(shù)參數(shù)...

    kk_miles 評論0 收藏0

發(fā)表評論

0條評論

最新活動
閱讀需要支付1元查看
<