日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
JavaScriptLazyevaluation：可迭代對象與迭代器

本文已經(jīng)過原作者 MelkorNemesis 授權(quán)翻譯。

10多年專注成都網(wǎng)站制作，成都企業(yè)網(wǎng)站建設(shè)，個人網(wǎng)站制作服務(wù)，為大家分享網(wǎng)站制作知識、方案，網(wǎng)站設(shè)計流程、步驟,成功服務(wù)上千家企業(yè)。為您提供網(wǎng)站建設(shè),網(wǎng)站制作,網(wǎng)頁設(shè)計及定制高端網(wǎng)站建設(shè)服務(wù),專注于成都企業(yè)網(wǎng)站建設(shè),高端網(wǎng)頁制作,對成都自上料攪拌車等多個方面，擁有多年的網(wǎng)站運維經(jīng)驗。

Lazy evaluation

Lazy evaluation常被譯為“延遲計算”或“惰性計算”，指的是僅僅在真正需要執(zhí)行的時候才計算表達式的值。

與惰性求值相反的是及早求值(eager evaluation)及早求值，也被稱為貪婪求值(greedy evaluation)或嚴格求值，是多數(shù)傳統(tǒng)編程語言的求值策略。

充分利用惰性求值的特性帶來的好處主要體現(xiàn)在以下兩個方面：

  • 避免不必要的計算，帶來性能上的提升。
  • 節(jié)省空間，使得無限循環(huán)的數(shù)據(jù)結(jié)構(gòu)成為可能。

迭代器

ES6 中的迭代器使惰性求值和創(chuàng)建用戶定義的數(shù)據(jù)序列成為可能。迭代是一種遍歷數(shù)據(jù)的機制。迭代器是用于遍歷數(shù)據(jù)結(jié)構(gòu)元素(稱為Iterable)的指針，用于產(chǎn)生值序列的指針。

迭代器是一個可以被迭代的對象。它抽象了數(shù)據(jù)容器，使其行為類似于可迭代對象。

迭代器在實例化時不計算每個項目的值，僅在請求時才生成下一個值。這非常有用，特別是對于大型數(shù)據(jù)集或無限個元素的序列。

可迭代對象

可迭代對象是希望其元素可被公眾訪問的數(shù)據(jù)結(jié)構(gòu)。JS 中的很多對象都是可迭代的，它們可能不是很好的察覺，但是如果仔細檢查，就會發(fā)現(xiàn)迭代的特征：

  • new Map([iterable])
  • new WeakMap([iterable])
  • new Set([iterable])
  • new WeakSet([iterable])
  • Promise.all([iterable])
  • Promise.race([iterable])
  • Array.from([iterable])

還有需要一個可迭代的對象，否則，它將拋出一個類型錯誤，例如：

  • for ... of
  • ... (展開操作符)const [a, b, ..] = iterable (解構(gòu)賦值)
  • yield* (生成器)

JavaScript中已有許多內(nèi)置的可迭代項：

String,Array,TypedArray,Map,Set。

迭代協(xié)議

迭代器和可迭對象遵循迭代協(xié)議。

協(xié)議是一組接口，并規(guī)定了如何使用它們。

迭代器遵循迭代器協(xié)議，可迭代遵循可迭代協(xié)議。

可迭代的協(xié)議

要使對象變得可迭代，它必須實現(xiàn)一個通過Symbol.iterator的迭代器方法，這個方法是迭代器的工廠。

使用 TypeScript，可迭代協(xié)議如下所示：

 
 
 
 
    
  
  
  
  
  1. interface Iterable {
    2. 
  
  
  
  
  2.   [Symbol.iterator]() : Iterator;
    3. 
  
  
  
  
  3. }
    4.

Symbol.iterator]()是無參數(shù)函數(shù)。在可迭代對象上調(diào)用它，這意味著我們可以通過this來訪問可迭代對象，它可以是常規(guī)函數(shù)或生成器函數(shù)。

迭代器協(xié)議

迭代器協(xié)議定義了產(chǎn)生值序列的標準方法。

為了使對象成為迭代器，它必須實現(xiàn)next()方法。迭代器可以實現(xiàn)return()方法，我們將在本文后面討論這個問題。

使用 TypeScript，迭代器協(xié)議如下所示：

 
 
 
 
    
  
  
  
  
  1. interface Iterator {
    2. 
  
  
  
  
  2.     next() : IteratorResult;
    3. 
  
  
  
  
  3.     return?(value?: any): IteratorResult;
    4. 
  
  
  
  
  4. }
    5.

IteratorResult 的定義如下：

 
 
 
 
    
  
  
  
  
  1. interface IteratorResult {
    2. 
  
  
  
  
  2.     value?: any;
    3. 
  
  
  
  
  3.     done: boolean;
    4. 
  
  
  
  
  4. }
    5.
  • done通知消費者迭代器是否已經(jīng)被使用，false表示仍有值需要生成，true表示迭代器已經(jīng)結(jié)束。
  • value 可以是任何 JS 值，它是向消費者展示的值。

當done為true時，可以省略value。

組合

迭代器和可以可迭代對象可以用下面這張圖來表示：

事例

基礎(chǔ)知識介紹完了，接著，我們來配合一些事例來加深我們的映像。

范圍迭代器

我們先從一個非?；镜牡鏖_始，createRangeIterator迭代器。

我們手動調(diào)用it.next()以獲得下一個IteratorResult。最后一次調(diào)用返回{done：true}，這意味著迭代器現(xiàn)在已被使用，不再產(chǎn)生任何值。

 
 
 
 
    
  
  
  
  
  1. function createRangeIterator(from, to) {
    2. 
  
  
  
  
  2.   let i = from;
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.   return {
    5. 
  
  
  
  
  5.     next() {
    6. 
  
  
  
  
  6.       if (i <= to) {
    7. 
  
  
  
  
  7.         return { value: i++, done: false };
    8. 
  
  
  
  
  8.       } else {
    9. 
  
  
  
  
  9.         return { done: true };
    10. 
  
  
  
  
  10.       }
    11. 
  
  
  
  
  11.     }
    12. 
  
  
  
  
  12.   }
    13. 
  
  
  
  
  13. }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15. const it = createRangeIterator(1, 3);
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. console.log(it.next());
    18. 
  
  
  
  
  18. console.log(it.next());
    19. 
  
  
  
  
  19. console.log(it.next());
    20. 
  
  
  
  
  20. console.log(it.next());
    21.

可迭代范圍迭代器

在本文的前面，我已經(jīng)提到 JS 中的某些語句需要一個可迭代的對象。因此，我們前面的示例在與for ... of循環(huán)一起使用時將不起作用。

但是創(chuàng)建符合迭代器和可迭代協(xié)議的對象非常容易。

 
 
 
 
    
  
  
  
  
  1. function createRangeIterator (from, to) {
    2. 
  
  
  
  
  2.   let i = from
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.   return {
    5. 
  
  
  
  
  5.     [Symbol.iterator] () {
    6. 
  
  
  
  
  6.       return this
    7. 
  
  
  
  
  7.     },
    8. 
  
  
  
  
  8.     next() {
    9. 
  
  
  
  
  9.       if (i <= to) {
    10. 
  
  
  
  
  10.         return { value: i++, done: false }
    11. 
  
  
  
  
  11.       } else {
    12. 
  
  
  
  
  12.         return { done: true }
    13. 
  
  
  
  
  13.       }
    14. 
  
  
  
  
  14.     }
    15. 
  
  
  
  
  15.   }
    16. 
  
  
  
  
  16. }
    17. 
  
  
  
  
  17. 
  
  
  
  
  18. const it = createRangeIterator(1, 3)
    19. 
  
  
  
  
  19. 
  
  
  
  
  20. for (const i of it) {
    21. 
  
  
  
  
  21.   console.log(i)
    22. 
  
  
  
  
  22. }
    23.

無限序列迭代器

迭代器可以表示無限制大小的序列，因為它們僅在需要時才計算值。

注意不要在無限迭代器上使用擴展運算符(...)，JS 將嘗試消費迭代器，由于迭代器是無限的，因此它將永遠不會結(jié)束。所以你的應(yīng)用程序?qū)⒈罎?，因為?nèi)存已被耗盡 ??

同樣，for ... of 循環(huán)也是一樣的情況，所以要確保能退出循環(huán)：

 
 
 
 
    
  
  
  
  
  1. function createEvenNumbersIterator () {
    2. 
  
  
  
  
  2.   let value = 0
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.   return {
    5. 
  
  
  
  
  5.     [Symbol.iterator] () {
    6. 
  
  
  
  
  6.       return this
    7. 
  
  
  
  
  7.     },
    8. 
  
  
  
  
  8.     next () {
    9. 
  
  
  
  
  9.       value += 2
    10. 
  
  
  
  
  10.       return { value, done: false}
    11. 
  
  
  
  
  11.     }
    12. 
  
  
  
  
  12.   }
    13. 
  
  
  
  
  13. }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15. const it = createEvenNumbersIterator()
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. const [a, b, c] = it
    18. 
  
  
  
  
  18. console.log({a, b, c})
    19. 
  
  
  
  
  19. 
  
  
  
  
  20. const [x, y, z] = it
    21. 
  
  
  
  
  21. console.log({ x, y, z })
    22. 
  
  
  
  
  22. 
  
  
  
  
  23. for (const even of it) {
    24. 
  
  
  
  
  24.   console.log(even)
    25. 
  
  
  
  
  25.   if (even > 20) {
    26. 
  
  
  
  
  26.     break
    27. 
  
  
  
  
  27.   }
    28. 
  
  
  
  
  28. }
    29.

關(guān)閉迭代器

前面我們提到過，迭代器可以有選擇地使用return()方法。當?shù)髦钡阶詈蠖紱]有迭代時使用此方法，并讓迭代器進行清理。

for ... of循環(huán)可以通過以下方式更早地終止迭代：

  • break
  • continue
  • throw
  • return
 
 
 
 
    
  
  
  
  
  1. function createCloseableIterator () {
    2. 
  
  
  
  
  2.   let idx = 0
    3. 
  
  
  
  
  3.   const data = ['a', 'b', 'c', 'd', 'e']
    4. 
  
  
  
  
  4. 
  
  
  
  
  5.   function cleanup() {
    6. 
  
  
  
  
  6.     console.log('Performing cleanup')
    7. 
  
  
  
  
  7.   }
    8. 
  
  
  
  
  8.   return {
    9. 
  
  
  
  
  9.     [Symbol.iterator]() { return this },
    10. 
  
  
  
  
  10.     next () {
    11. 
  
  
  
  
  11.       if (idx <= data.length - 1) {
    12. 
  
  
  
  
  12.         return { value: data[idx++], done: false }
    13. 
  
  
  
  
  13.       } else {
    14. 
  
  
  
  
  14.         cleanup()
    15. 
  
  
  
  
  15.         return { done: true }
    16. 
  
  
  
  
  16.       }
    17. 
  
  
  
  
  17.     },
    18. 
  
  
  
  
  18.     return () {
    19. 
  
  
  
  
  19.       cleanup()
    20. 
  
  
  
  
  20.       return { done: true }
    21. 
  
  
  
  
  21.     }
    22. 
  
  
  
  
  22.   }
    23. 
  
  
  
  
  23. }
    24. 
  
  
  
  
  24. 
  
  
  
  
  25. const it = createCloseableIterator()
    26. 
  
  
  
  
  26. 
  
  
  
  
  27. for (const value of it) {
    28. 
  
  
  
  
  28.   console.log(value)
    29. 
  
  
  
  
  29.   if (value === 'c') {
    30. 
  
  
  
  
  30.     break
    31. 
  
  
  
  
  31.   }
    32. 
  
  
  
  
  32. }
    33. 
  
  
  
  
  33. 
  
  
  
  
  34. console.log('\n----------\n')
    35. 
  
  
  
  
  35. 
  
  
  
  
  36. const _it = createCloseableIterator();
    37. 
  
  
  
  
  37. for (const value of _it) {
    38. 
  
  
  
  
  38.   console.log(value);
    39. 
  
  
  
  
  39. }
    40.

  • 如果知道迭代器已經(jīng)結(jié)束，則手動調(diào)用cleanup()函數(shù)。
  • 如果突然完成，則return()起作用并為我們進行清理。

額外的內(nèi)容

如果你已經(jīng)做到了這一點，我們來看看一些額外的內(nèi)容。

組合器

組合器是將現(xiàn)有可迭代對象組合在一起以創(chuàng)建新可迭代對象的函數(shù)。

因此，我們能夠創(chuàng)建許多實用函數(shù)。那map或者filter呢?看看下面的代碼，花一分鐘時間來理解它。

 
 
 
 
    
  
  
  
  
  1. function createEvenNumbersIterator() {
    2. 
  
  
  
  
  2.   let value = 0;
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.   return {
    5. 
  
  
  
  
  5.     [Symbol.iterator]() {
    6. 
  
  
  
  
  6.       return this;
    7. 
  
  
  
  
  7.     },
    8. 
  
  
  
  
  8.     next() {
    9. 
  
  
  
  
  9.       value += 2;
    10. 
  
  
  
  
  10.       return { value, done: false };
    11. 
  
  
  
  
  11.     }
    12. 
  
  
  
  
  12.   }
    13. 
  
  
  
  
  13. }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15. function map(fn, iterable) {
    16. 
  
  
  
  
  16.   const iter = iterable[Symbol.iterator]();
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.   return {
    19. 
  
  
  
  
  19.     [Symbol.iterator]() {
    20. 
  
  
  
  
  20.       return this;
    21. 
  
  
  
  
  21.     },
    22. 
  
  
  
  
  22.     next() {
    23. 
  
  
  
  
  23.       const n = iter.next();
    24. 
  
  
  
  
  24.       if (!n.done) {
    25. 
  
  
  
  
  25.         return { value: fn(n.value), done: false };
    26. 
  
  
  
  
  26.       } else {
    27. 
  
  
  
  
  27.         return { done: true };
    28. 
  
  
  
  
  28.       }
    29. 
  
  
  
  
  29.     }
    30. 
  
  
  
  
  30.   }
    31. 
  
  
  
  
  31. }
    32. 
  
  
  
  
  32. 
  
  
  
  
  33. function filter(fn, iterable) {
    34. 
  
  
  
  
  34.   const iter = iterable[Symbol.iterator]();
    35. 
  
  
  
  
  35. 
  
  
  
  
  36.   return {
    37. 
  
  
  
  
  37.     [Symbol.iterator]() {
    38. 
  
  
  
  
  38.       return this;
    39. 
  
  
  
  
  39.     },
    40. 
  
  
  
  
  40.     next() {
    41. 
  
  
  
  
  41.       const n = iter.next();
    42. 
  
  
  
  
  42.       if (!n.done) {
    43. 
  
  
  
  
  43.         if (fn(n.value)) {
    44. 
  
  
  
  
  44.           return { value: n.value, done: false };
    45. 
  
  
  
  
  45.         } else {
    46. 
  
  
  
  
  46.           return this.next();
    47. 
  
  
  
  
  47.         }
    48. 
  
  
  
  
  48.       } else {
    49. 
  
  
  
  
  49.         return { done: true };
    50. 
  
  
  
  
  50.       }
    51. 
  
  
  
  
  51.     }
    52. 
  
  
  
  
  52.   }
    53. 
  
  
  
  
  53. }
    54. 
  
  
  
  
  54. 
  
  
  
  
  55. function take(n, iterable) {
    56. 
  
  
  
  
  56.   const iter = iterable[Symbol.iterator]();
    57. 
  
  
  
  
  57. 
  
  
  
  
  58.   return {
    59. 
  
  
  
  
  59.     [Symbol.iterator]() {
    60. 
  
  
  
  
  60.       return this;
    61. 
  
  
  
  
  61.     },
    62. 
  
  
  
  
  62.     next() {
    63. 
  
  
  
  
  63.       if (n > 0) {
    64. 
  
  
  
  
  64.         n--;
    65. 
  
  
  
  
  65.         return iter.next();
    66. 
  
  
  
  
  66.       } else {
    67. 
  
  
  
  
  67.         return { done: true };
    68. 
  
  
  
  
  68.       }
    69. 
  
  
  
  
  69.     }
    70. 
  
  
  
  
  70.   }
    71. 
  
  
  
  
  71. }
    72. 
  
  
  
  
  72. 
  
  
  
  
  73. function cycle(iterable) {
    74. 
  
  
  
  
  74.   const iter = iterable[Symbol.iterator]();
    75. 
  
  
  
  
  75.   const saved = [];
    76. 
  
  
  
  
  76.   let idx = 0;
    77. 
  
  
  
  
  77.   
    78. 
  
  
  
  
  78.   return {
    79. 
  
  
  
  
  79.     [Symbol.iterator]() {
    80. 
  
  
  
  
  80.       return this;
    81. 
  
  
  
  
  81.     },
    82. 
  
  
  
  
  82.     next() {
    83. 
  
  
  
  
  83.       const n = iter.next();
    84. 
  
  
  
  
  84.       if (!n.done) {
    85. 
  
  
  
  
  85.         saved[idx++] = n.value;
    86. 
  
  
  
  
  86.         return { value: n.value, done: false };
    87. 
  
  
  
  
  87.       } else {
    88. 
  
  
  
  
  88.         return { value: saved[idx++ % saved.length], done: false };
    89. 
  
  
  
  
  89.       }
    90. 
  
  
  
  
  90.     }
    91. 
  
  
  
  
  91.   }
    92. 
  
  
  
  
  92. }
    93. 
  
  
  
  
  93. 
  
  
  
  
  94. function collect(iterable) {
    95. 
  
  
  
  
  95.   // consumes the iterator
    96. 
  
  
  
  
  96.   return Array.from(iterable);
    97. 
  
  
  
  
  97. }
    98. 
  
  
  
  
  98. 
  
  
  
  
  99. const evenNumbersIterator = createEvenNumbersIterator();
    100. 
  
  
  
  
  100. const result = collect(                 // 7. and collect the result
    101. 
  
  
  
  
  101.   filter(                               // ?? 6. keep only values higher than 1
    102. 
  
  
  
  
  102.     val => val > 1, map(                // ?? 5. divide obtained values by 2
    103. 
  
  
  
  
  103.       val => val / 2, take(             // ?? 4. take only six of them
    104. 
  
  
  
  
  104.         6, cycle(                       // ?? 3. make an infinite cycling sequence of them
    105. 
  
  
  
  
  105.           take(                         // ?? 2. take just three of them
    106. 
  
  
  
  
  106.             3, evenNumbersIterator      // ?? 1. infinite sequence of even numbers
    107. 
  
  
  
  
  107.           )
    108. 
  
  
  
  
  108.         )
    109. 
  
  
  
  
  109.       )
    110. 
  
  
  
  
  110.     )
    111. 
  
  
  
  
  111.   )
    112. 
  
  
  
  
  112. );
    113. 
  
  
  
  
  113. 
  
  
  
  
  114. console.log(result);
    115.

這是一大堆代碼，很快我們將看到如何使用生成器和函數(shù)式編程概念來重構(gòu)所有這些內(nèi)容。保持關(guān)注，并注意我的后續(xù)文章，我們?nèi)匀挥泻芏鄡?nèi)容要講。

作者：MelkorNemesis 譯者：前端小智 來源：medium

原文：https://medium.com/@MelrNemesis/javascript-lazy-evaluation-iterables-iterators-e0770a5de96f

本文轉(zhuǎn)載自微信公眾號「 大遷世界」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系 大遷世界公眾號。


網(wǎng)頁名稱：JavaScriptLazyevaluation：可迭代對象與迭代器
轉(zhuǎn)載注明：http://m.5511xx.com/article/dhgcdod.html