Question

我需要从给定的对象数组中获取另一个对象数组，但稍微处理一下。例如：

 var arr =   [
      {
        "level": "INF",
        "model": "A"
      },{
        "level": "INF",
        "model": "B"
      },{
        "level": "INF",
        "model": "C"
      },{
        "level": "INC",
        "model": "A"
      },{
        "level": "IND",
        "model": "A"
      },{
        "level": "IND",
        "model": "B"
      }
]

process_array(arr)

应该返回：

      [{
        "level": "INF",
        "model": "A-B-C"
      },{
        "level": "INC",
        "model": "A"
      },{
        "level": "IND",
        "model": "A-D"
      }]

我的意思是，每个不同级别只会有一个对象，并且该级别的所有不同模型将被“ - ”连接。

实现目标的简单方法是什么？

我的方法是获得不同级别的数组：

function process_array(array) {
    var values_seen = {}; // for removing duplicates
    for (var i = 0; i < array.length; i++) {
        values_seen[array[i]["level"]] = true;
    }
    return Object.keys(values_seen);
}

现在我需要获得每个级别的连接模型..

Answer 1

只需将数组缩减为对象：

return array.reduce(function(total, current) {
  if (total[current.level]) { // existing
    total[current.level].model += '-' + current.model;
  } else { // new
    total[current.level] = current;
  }
  return total;
}, {});

Demo

在每次迭代中，您修改total对象，然后返回它以在下一次迭代中使用。该对象的最终值将返回给调用者。

另见Array.prototype.reduce()

Answer 2

＆＃13;

var arr =   [
      {
        "level": "INF",
        "model": "A"
      },{
        "level": "INF",
        "model": "B"
      },{
        "level": "INF",
        "model": "C"
      },{
        "level": "INC",
        "model": "A"
      },{
        "level": "IND",
        "model": "A"
      },{
        "level": "IND",
        "model": "B"
      }
]

function processArray(array) {
    
    var count = array.length, i, item, result = [], temp = {};
    
    for (i = 0; i < count; i++) {
        item = array[i];
      
        if (temp[item.level] !== undefined) {
            result[temp[item.level]].model += '-' + item.model;        
        } else {
            temp[item.level] = result.length;
            result.push(item);
        }
        
    }

    return result;
}

alert(JSON.stringify(processArray(arr)));

＆＃13;

Answer 3

您所指的也称为投影。

This code使用EcmaScript 5。

var arr =   [
      {
        "level": "INF",
        "model": "A"
      },{
        "level": "INF",
        "model": "B"
      },{
        "level": "INF",
        "model": "C"
      },{
        "level": "INC",
        "model": "A"
      },{
        "level": "IND",
        "model": "A"
      },{
        "level": "IND",
        "model": "B"
      }
];

function processArray(input) {
    var buf = {}, result = [];
    input.forEach(function(item) {
        var model = item.model;
        var existing = buf[item.level];
        if (existing) {
           existing.model += '-' + item.model;         
        } else {
            existing = buf[item.level] = {
                level: item.level,
                model: model
            };
            result.push(existing);
        }
    });
    return result;
}

var processed = processArray(arr);
console.log(processed);

Answer 4

function processArray(arr) {
    var result = [];
    arr
        .map(function(v) {return v.level;})
        .forEach(function(v, i) {
            var resultValue = result.filter(function(el, j) {
                return el.level === v;
            })[0];

            if(!resultValue) {
              result.push(arr[i]); 
            } else {
              resultValue.model += '-' + arr[i].model;
            }
        });
    return result;
}

var arr = [
      {
        "level": "INF",
        "model": "A"
      },{
        "level": "INF",
        "model": "B"
      },{
        "level": "INF",
        "model": "C"
      },{
        "level": "INC",
        "model": "A"
      },{
        "level": "IND",
        "model": "A"
      },{
        "level": "IND",
        "model": "B"
      }
];

alert(JSON.stringify(processArray(arr), null, 2));

javascript处理一个对象数组以获取一个新的对象数组

4 个答案: