Question

我有3个嵌套数组的数组，每个数组包含3个对象。如何使用d3语法在所有数据中找到data1的最大值？

是不是

function find_max(all_data, i){
    return d3.max(all_data[i].data1)
}

这是我的数据结构：

all_data = [
        [{data1:2, age:6},
         {data1:4, age:5},
         {data1:5, age:4}],

        [{data1:7, age:2},
         {data1:1, age:9},
         {data1:0, age:8}],

        [{data1:5, age:9},
         {data1:6, age:9},
         {data1:8, age:6}]
       ]

基本上，我希望它返回8。感谢您的帮助！我不太正确。

Answer 1

我们可以混合使用d3.max和Array.map操作：

d3.max(all_data.map(d => d3.max(d.map(n => n.data1)))) // 8

这使用d3.max查找最大值，并使用map操作将每个嵌套数组的最大值转换为data1值的数组（{{1} }用于第一个嵌套数组。

[2, 4, 5]

对于每个子最大值，我们再次使用[{data1:2, age:6}, {data1:4, age:5}, {data1:5, age:4}].map(n => n.data1) // [2, 4, 5] d3.max([{data1:2, age:6}, {data1:4, age:5}, {data1:5, age:4}].map(n => n.data1)) // 5查找全局最大值。

d3.max

var all_data = [
  [{data1:2, age:6},
    {data1:4, age:5},
    {data1:5, age:4}],

  [{data1:7, age:2},
    {data1:1, age:9},
    {data1:0, age:8}],

  [{data1:5, age:9},
    {data1:6, age:9},
    {data1:8, age:6}]
];

console.log(d3.max(all_data.map(d => d3.max(d.map(n => n.data1)))));

如果您对flatMap的概念感到满意，还可以执行以下操作：

<script src="https://d3js.org/d3.v5.min.js"></script>

但是这需要为数组创建一个d3.max(all_data.flatMap(d => d.map(n => n.data1))); // 8函数：

flatMap

Array.prototype.flatMap = function(lambda) { return Array.prototype.concat.apply([], this.map(lambda)); };操作将嵌套列表展平：

flatMap

最后，如果您想一次获得最大值和最小值，我们可以混合使用all_data.flatMap(d => d.map(n => n.data1)) // [2, 4, 5, 7, 1, 0, 5, 6, 8]和d3.extent：

Array.flatMap

Answer 2

最简单的方法可能是嵌套d3.max()：

function findMax(data) {
  return d3.max(data, arr =>    // return max of all nested max values
    d3.max(arr, d => d.data1)   // return max of each nested array
  );
}

对d3.max()的外部调用使用其访问器函数来访问每个嵌套数组的最大值。内部调用将确定每个嵌套数组的最大值。为此，它定义了一个访问器函数以返回data1属性。

看看以下工作演示：

const all_data = [
        [{data1:2, age:6},
         {data1:4, age:5},
         {data1:5, age:4}],

        [{data1:7, age:2},
         {data1:1, age:9},
         {data1:0, age:8}],

        [{data1:5, age:9},
         {data1:6, age:9},
         {data1:8, age:6}]
       ];
       
function findMax(data) {
  return d3.max(data, arr =>
    d3.max(arr, d => d.data1)
  );
}

console.log(findMax(all_data));

<script src="https://d3js.org/d3.v5.js"></script>

或者，您可以先使用d3.merge()将嵌套数组合并为一个，然后将d3.max()应用于该合并数组。

function findMax(data) {
  return d3.max(d3.merge(data), d => d.data1);
}

这是工作示例：

const all_data = [
        [{data1:2, age:6},
         {data1:4, age:5},
         {data1:5, age:4}],

        [{data1:7, age:2},
         {data1:1, age:9},
         {data1:0, age:8}],

        [{data1:5, age:9},
         {data1:6, age:9},
         {data1:8, age:6}]
       ];
       
function findMax(data) {
  return d3.max(d3.merge(all_data), d => d.data1);
}

console.log(findMax(all_data));

<script src="https://d3js.org/d3.v5.js"></script>

Answer 3

您可以映射内部data1的值并获取最大值，然后获取外部数组的结果。

var all_data = [[{ data1: 2, age: 6 }, { data1: 4, age: 5 }, { data1: 5, age: 4 } ], [{ data1: 7, age: 2 }, { data1: 1, age: 9 }, { data1: 0, age: 8 }], [{ data1: 5, age: 9 }, { data1: 6, age: 9 }, { data1: 8, age: 6 }]],
    maxData1 = Math.max(...all_data.map(a => Math.max(...a.map(({ data1 }) => data1))));
    
console.log(maxData1);

d3-在嵌套数组中查找最大kay /值

3 个答案: