Question

我有一个数组

const nodes = [
    { layer: '0' },
    { layer: 'input' },
    { layer: '0' },
    { layer: 'output' },
    { layer: '1' }
};

我想保留数组，但应更改所有图层值。

输入图层的值应为1，所有数值应增加2，输出图层应具有新的最高数值加1.所有值应为数字而不是字符串。

所以新数组将是

const nodes = [
    { layer: 2 },
    { layer: 1 },
    { layer: 2 },
    { layer: 4 },
    { layer: 3 }
};

我用

完成了这个

const nodes = [
    { layer: '0' },
    { layer: 'input' },
    { layer: '0' },
    { layer: 'output' },
    { layer: '1' }
};

const output = Math.max.apply(Math, nodes.map((node) => Number.parseInt(node.layer, 10) || 0)) + 3;

nodes.map((node) => {
  layer: neuron.layer === 'input' ? 1 : (neuron.layer === 'output' ? output : Number.parseInt(neuron.layer, 10) + 2)
})

它似乎有用，但代码真的很难看。

我想知道它是否可以比这更完整。

Answer 1

这可能是完成这项工作的一种方式;

＆＃13;

var nodes = [
    { layer: '0' },
    { layer: 'input' },
    { layer: '0' },
    { layer: 'output' },
    { layer: '1' }
],
result = nodes.map(n => isNaN(+n.layer) ? n.layer === "input" ? {layer:1}
                                                              : {layer: n.layer}
                                        : n.layer = {layer:+n.layer + 2});
result.find(o => o.layer === "output").layer = result.filter(f => !isNaN(f.layer))
                                                     .reduce((p,c) => p.layer > c.layer ? p : c)
                                                     .layer + 1;
console.log(result);

＆＃13;

Answer 2

这个怎么样：

＆＃13;

const nodes = [
    { layer: '0' },
    { layer: 'input' },
    { layer: '0' },
    { layer: 'output' },
    { layer: '1' }
];

nodes.filter( o => o.layer === 'output' )[0].layer = 
    1 + nodes.reduce( (max, node) => Math.max(max, 
        node.layer = +(node.layer === 'input') || +node.layer+2 || 0), 0);

console.log(nodes);

＆＃13;

对于那些想知道const的人：恒定性质只保护变量不被重新分配;但是存储在数组中的对象可以自由变异。

映射对象数组中的值

2 个答案: