JavaScript Lazy evaluation：可迭代对象与迭代器

时间  2020-11-26
标签 javascript 前端 java git github 面试 编程 微信 数据结构 编程语言 栏目 JavaScript 繁體版
原文   原文链接
做者：MelkorNemesis
译者：前端小智
来源：medium
点赞再看，养成习惯

本文 GitHub https://github.com/qq44924588... 上已经收录，更多往期高赞文章的分类，也整理了不少个人文档，和教程资料。欢迎Star和完善，你们面试能够参照考点复习，但愿咱们一块儿有点东西。javascript

Lazy evaluation

Lazy evaluation常被译为“延迟计算”或“惰性计算”，指的是仅仅在真正须要执行的时候才计算表达式的值。前端

与惰性求值相反的是及早求值(eager evaluation)及早求值，也被称为贪婪求值（greedy evaluation）或严格求值，是多数传统编程语言的求值策略。java

充分利用惰性求值的特性带来的好处主要体如今如下两个方面：git

  • 避免没必要要的计算，带来性能上的提高。
  • 节省空间，使得无限循环的数据结构成为可能。

迭代器

ES6 中的迭代器使惰性求值和建立用户定义的数据序列成为可能。迭代是一种遍历数据的机制。 迭代器是用于遍历数据结构元素（称为Iterable）的指针，用于产生值序列的指针。github

迭代器是一个能够被迭代的对象。它抽象了数据容器，使其行为相似于可迭代对象。面试

迭代器在实例化时不计算每一个项目的值，仅在请求时才生成下一个值。 这很是有用，特别是对于大型数据集或无限个元素的序列。编程

可迭代对象

可迭代对象是但愿其元素可被公众访问的数据结构。JS 中的不少对象都是可迭代的，它们可能不是很好的察觉，可是若是仔细检查，就会发现迭代的特征：微信

  • 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 (解构赋值)编程语言

  • yield* (生成器)

JavaScript中已有许多内置的可迭代项：

String,Array,TypedArray,Map,Set。

迭代协议

迭代器和可迭对象遵循迭代协议。

协议是一组接口，并规定了如何使用它们。

迭代器遵循迭代器协议，可迭代遵循可迭代协议。

可迭代的协议

要使对象变得可迭代，它必须实现一个经过Symbol.iterator的迭代器方法，这个方法是迭代器的工厂。

使用 TypeScript，可迭代协议以下所示：

interface Iterable {
  [Symbol.iterator]() : Iterator;
}

Symbol.iterator]()是无参数函数。 在可迭代对象上调用它，这意味着咱们能够经过this来访问可迭代对象，它能够是常规函数或生成器函数。

迭代器协议

迭代器协议定义了产生值序列的标准方法。

为了使对象成为迭代器，它必须实现next()方法。 迭代器能够实现return()方法，咱们将在本文后面讨论这个问题。

使用 TypeScript，迭代器协议以下所示：

interface Iterator {
    next() : IteratorResult;
    return?(value?: any): IteratorResult;
}

IteratorResult 的定义以下：

interface IteratorResult {
    value?: any;
    done: boolean;
}
  • done通知消费者迭代器是否已经被使用，false表示仍有值须要生成，true表示迭代器已经结束。
  • value 能够是任何 JS 值，它是向消费者展现的值。

当done为true时，能够省略value。

组合

迭代器和能够可迭代对象能够用下面这张图来表示：

clipboard.png

事例

基础知识介绍完了，接着，咱们来配合一些事例来加深咱们的映像。

范围迭代器

咱们先从一个很是基本的迭代器开始，createRangeIterator迭代器。

咱们手动调用it.next()以得到下一个IteratorResult。 最后一次调用返回{done：true}，这意味着迭代器如今已被使用，再也不产生任何值。

function createRangeIterator(from, to) {
  let i = from;

  return {
    next() {
      if (i <= to) {
        return { value: i++, done: false };
      } else {
        return { done: true };
      }
    }
  }
}

const it = createRangeIterator(1, 3);

console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());

clipboard.png

可迭代范围迭代器

在本文的前面，我已经提到 JS 中的某些语句须要一个可迭代的对象。 所以，咱们前面的示例在与for ... of循环一块儿使用时将不起做用。

可是建立符合迭代器和可迭代协议的对象很是容易。

clipboard.png

function createRangeIterator (from, to) {
  let i = from

  return {
    [Symbol.iterator] () {
      return this
    },
    next() {
      if (i <= to) {
        return { value: i++, done: false }
      } else {
        return { done: true }
      }
    }
  }
}

const it = createRangeIterator(1, 3)

for (const i of it) {
  console.log(i)
}

无限序列迭代器

迭代器能够表示无限制大小的序列，由于它们仅在须要时才计算值。

注意不要在无限迭代器上使用扩展运算符(...)，JS 将尝试消费迭代器，因为迭代器是无限的，所以它将永远不会结束。 因此你的应用程序将崩溃，由于内存已被耗尽 😱

一样，for ... of 循环也是同样的状况，因此要确保能退出循环：

function createEvenNumbersIterator () {
  let value = 0

  return {
    [Symbol.iterator] () {
      return this
    },
    next () {
      value += 2
      return { value, done: false}
    }
  }
}

const it = createEvenNumbersIterator()

const [a, b, c] = it
console.log({a, b, c})

const [x, y, z] = it
console.log({ x, y, z })

for (const even of it) {
  console.log(even)
  if (even > 20) {
    break
  }
}

clipboard.png

关闭迭代器

前面咱们提到过，迭代器能够有选择地使用return()方法。 当迭代器直到最后都没有迭代时使用此方法，并让迭代器进行清理。

for ... of循环能够经过如下方式更早地终止迭代：

  • break
  • continue
  • throw
  • return
function createCloseableIterator () {
  let idx = 0
  const data = ['a', 'b', 'c', 'd', 'e']

  function cleanup() {
    console.log('Performing cleanup')
  }
  return {
    [Symbol.iterator]() { return this },
    next () {
      if (idx <= data.length - 1) {
        return { value: data[idx++], done: false }
      } else {
        cleanup()
        return { done: true }
      }
    },
    return () {
      cleanup()
      return { done: true }
    }
  }
}

const it = createCloseableIterator()

for (const value of it) {
  console.log(value)
  if (value === 'c') {
    break
  }
}

console.log('\n----------\n')

const _it = createCloseableIterator();
for (const value of _it) {
  console.log(value);
}

clipboard.png

  • 若是知道迭代器已经结束，则手动调用cleanup()函数。
  • 若是忽然完成，则return()起做用并为咱们进行清理。

💥 额外的内容

若是你已经作到了这一点，咱们来看看一些额外的内容。

组合器

组合器是将现有可迭代对象组合在一块儿以建立新可迭代对象的函数。

所以，咱们可以建立许多实用函数。那map或者filter呢?看看下面的代码，花一分钟时间来理解它。

function createEvenNumbersIterator() {
  let value = 0;

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      value += 2;
      return { value, done: false };
    }
  }
}

function map(fn, iterable) {
  const iter = iterable[Symbol.iterator]();

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      const n = iter.next();
      if (!n.done) {
        return { value: fn(n.value), done: false };
      } else {
        return { done: true };
      }
    }
  }
}

function filter(fn, iterable) {
  const iter = iterable[Symbol.iterator]();

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      const n = iter.next();
      if (!n.done) {
        if (fn(n.value)) {
          return { value: n.value, done: false };
        } else {
          return this.next();
        }
      } else {
        return { done: true };
      }
    }
  }
}

function take(n, iterable) {
  const iter = iterable[Symbol.iterator]();

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      if (n > 0) {
        n--;
        return iter.next();
      } else {
        return { done: true };
      }
    }
  }
}

function cycle(iterable) {
  const iter = iterable[Symbol.iterator]();
  const saved = [];
  let idx = 0;
  
  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      const n = iter.next();
      if (!n.done) {
        saved[idx++] = n.value;
        return { value: n.value, done: false };
      } else {
        return { value: saved[idx++ % saved.length], done: false };
      }
    }
  }
}

function collect(iterable) {
  // consumes the iterator
  return Array.from(iterable);
}

const evenNumbersIterator = createEvenNumbersIterator();
const result = collect(                 // 7. and collect the result
  filter(                               // ⬆️ 6. keep only values higher than 1
    val => val > 1, map(                // ⬆️ 5. divide obtained values by 2
      val => val / 2, take(             // ⬆️ 4. take only six of them
        6, cycle(                       // ⬆️ 3. make an infinite cycling sequence of them
          take(                         // ⬆️ 2. take just three of them
            3, evenNumbersIterator      // ⬆️ 1. infinite sequence of even numbers
          )
        )
      )
    )
  )
);

console.log(result);

这是一大堆代码，很快咱们将看到如何使用生成器和函数式编程概念来重构全部这些内容。保持关注，并注意个人后续文章，咱们仍然有不少内容要讲。

代码部署后可能存在的BUG无法实时知道，过后为了解决这些BUG，花了大量的时间进行log 调试，这边顺便给你们推荐一个好用的BUG监控工具 Fundebug。

原文：https://medium.com/@MelrNemes...

交流

文章每周持续更新，能够微信搜索「 大迁世界 」第一时间阅读和催更（比博客早一到两篇哟），本文 GitHub https://github.com/qq449245884/xiaozhi 已经收录，整理了不少个人文档，欢迎Star和完善，你们面试能够参照考点复习，另外关注公众号，后台回复福利，便可看到福利，你懂的。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程