相关疑难解决方法(0)

假设你有一个类似数组的Javascript ES6 Iterable,你事先知道它的长度是有限的,将它转换为Javascript数组的最佳方法是什么？

这样做的原因是许多js库(如下划线和lodash)仅支持Arrays,因此如果您希望在Iterable上使用它们的任何函数,则必须首先将其转换为Array.

在python中,您可以使用list()函数.在ES6中是否有相同的东西？

从现在开始,我正在使用这个循环迭代数组的元素,即使我在其中放置具有各种属性的对象,它也能正常工作.

var cubes[];

for (i in cubes){
     cubes[i].dimension
     cubes[i].position_x
     ecc..
}

现在,让我们假设cubes []以这种方式声明

var cubes[][];

我可以在Javascript中执行此操作吗？我怎样才能自动迭代

cubes[0][0]
cubes[0][1]
cubes[0][2]
cubes[1][0]
cubes[1][1]
cubes[1][2]
cubes[2][0]
ecc...

作为一种解决方法,我可以声明:

var cubes[];
var cubes1[];

并与两个数组分开工作.这是更好的解决方案吗？

首先,让我为那些不认识的人定义什么是捷径融合.在JavaScript中考虑以下数组转换:

var a = [1,2,3,4,5].map(square).map(increment);

console.log(a);

function square(x) {
    return x * x;
}

function increment(x) {
    return x + 1;
}

这里我们有一个数组,[1,2,3,4,5]其元素首先被平方,[1,4,9,16,25]然后递增[2,5,10,17,26].因此,虽然我们不需要中间数组[1,4,9,16,25],但我们仍然创建它.

捷径融合是一种优化技术,它可以通过将一些函数调用合并为一个来消除中间数据结构.例如,可以将快捷融合应用于上述代码以产生:

var a = [1,2,3,4,5].map(compose(square, increment));

console.log(a);

function square(x) {
    return x * x;
}

function increment(x) {
    return x + 1;
}

function compose(g, f) {
    return function (x) {
        return f(g(x));
    };
}

如您所见,通过组合和函数将两个单独的map调用融合到一个map调用中.因此,不创建中间阵列.squareincrement

现在,我理解像Immutable.js和Lazy.js这样的库在JavaScript中模仿延迟评估.延迟评估意味着仅在需要时计算结果. …

我可以使用Map然后设置值：

const a = new Map([["a", "b"], ["c", "d"]])

现在，如果我想以一种功能性的方式（不带for ... of或.forEach）将一个功能应用于所有值，我想我可以做这样的事情：

const b = a.map(([k, v]) => [k, doSomethingWith(v)]);

但是上没有任何map功能Map。是否有内置/优雅的映射方式Map？

在ES6生成器中使用新ES5阵列功能的正确方法是什么？我是否必须先将iterable显式转换为数组,还是有更好的方法？例如:

function* range(low, high) {
    var i = low;
    while(i < high)
        yield i++;
}

// Sum of numbers in range, doesn't work
console.log(range(0, 10).reduce((x,y) => x + y));

给定 an iterator，创建 an 的最佳方法是什么Array？

例如，

让地图=新地图（）；
map.set( 'key1', '数据' );
map.set( 'key2', '更多数据' );
...
// 现在，希望有一个键数组
让 arr = //??// map.keys() //??//

我可以做一些蹩脚的事情，比如

函数 iter2array( iter ) {
  让 arr = new Array();
  for( 让 e in iter ) arr.push(e);
  返回 arr；
}

但必须有更好的方法。

我一直在阅读有关map、reduce的文章，filter因为它们在 React 和 FP 中的使用量很大。如果我们写这样的东西：

let myArr = [1,2,3,4,5,6,7,8,9]
let sumOfDoubleOfOddNumbers = myArr.filter(num => num % 2)
                                   .map(num => num * 2)
                                   .reduce((acc, currVal) => acc + currVal, 0);

运行 3 个不同的循环。

我也读过有关 Java 8 流的内容，并且知道它们使用所谓的 monad，即首先存储计算。它们仅在一次迭代中执行一次。例如，

Stream.of("d2", "a2", "b1", "b3", "c")
    .map(s -> {
        System.out.println("map: " + s);
        return s.toUpperCase();
    })
    .filter(s -> {
        System.out.println("filter: " + s);
        return s.startsWith("A");
    })
    .forEach(s -> System.out.println("forEach: " + s));

// map:     d2
// filter:  D2 …