这些2D阵列包含结构不同的相同信息。 如何将一个转换为另一个？

Question

我有这个数组数组，其中类别的每个组合都是一行，并与一个数字关联。

var input = [
    ['Season',  'Type',     'Dollars'], // header
    ['Winter',  'Sales',     1000],
    ['Winter',  'Expenses',  400],
    ['Winter',  'Profit',    250],
    ['Spring',  'Sales',     1170],
    ['Spring',  'Expenses',  460],
    ['Spring',  'Profit',    250],
    ['Summer',  'Sales',     660],
    ['Summer',  'Expenses',  1120],
    ['Summer',  'Profit',    300],
    ['Fall',    'Sales',     1030],
    ['Fall',    'Expenses',  540],
    ['Fall',    'Profit',    350]
];

我有这个数组数组，每个类别都是一个轴。

var desiredOutput = [
    ['Season',  'Sales', 'Expenses', 'Profit'], // header
    ['Winter',  1000,    400,        200],
    ['Spring',  1170,    460,        250],
    ['Summer',  660,     1120,       300],
    ['Fall',    1030,    540,        350]
];

首先，有人知道这两种类型的数组是否有不同的名称？ 我经常以一种方式组织数据，并且需要手动将其切换到另一种以便以图形方式对其进行分析或进行某种处理，我只是想知道是否存在正式的区别。

我设法使用这个残酷的功能将input转换为desiredOutput input ：

function restructure(input) {
    var output = [];

    var cat1 = [],
        cat1Lookup = {},
        cat2 = [],
        cat2Lookup = {};

    input.forEach(function (d, i) {
        cat1.push(d[0]);
        cat2.push(d[1]);
    });

    unique(cat1).forEach(function (d, i) {
        var r = [d];

        if (i === 0) {
            output.push([d]);
            return true;
        }

        unique(cat2).forEach(function (d, i) {
            r.push();
        });

        output.push(r);
        cat1Lookup[d] = i;
    });

    unique(cat2).forEach(function (d, i) {
        if (i === 0) return true;
        output[0].push(d);
        cat2Lookup[d] = i;

    });

    input.forEach(function (d, i) {

        if (i === 0) return true;
        var y = cat1Lookup[d[0]];
        var x = cat2Lookup[d[1]];

        output[y][x] = d[2];
    });
    return output;
}

function unique(input) {
    var u = {}, a = [];
    for (var i = 0, l = input.length; i < l; ++i) {
        if (u.hasOwnProperty(input[i])) {
            continue;
        }
        a.push(input[i]);
        u[input[i]] = 1;
    }
    return a;
}

但我敢肯定，必须有更好的方法来做到这一点。 谁能提供更清洁的解决方案？

的jsfiddle

Answer 1

我同意上面的评论并回答说，使用Objects比使用带有标签的数组更好，但是，如果不能这样做，那么这就是我保留格式的方法：

// helper function
function addIfMissing(array, value) {
    var found = false;
    for(var i = 0; i < array.length; i++)
        if(array[i] === value)
            return array;
    array.push(value);
    return array;
}

function restructure(input) {
    var output = [], headerX = [], headerY = [], xCoor, yCoor;

    // first create non-repeating headers
    headerX.push(input[0][0]);
    headerY.push(input[0][0]);
    for(var i = 1; i < input.length; i++)
        headerX = addIfMissing(headerX, input[i][0]), headerY = addIfMissing(headerY, input[i][1]);

    // put headers into output array
    for(var i = 0; i < headerX.length; i++)
        output.push([headerX[i]]);
    output[0] = headerY;

    // find correct headers on both axes and input data
    for(var i = 1; i < input.length; i++) {
        for(var k = 1; k < headerX.length; k++)
            if(output[k][0] == input[i][0])
                xCoor = k;
        for(var j = 1; j < headerY.length; j++)
            if(output[0][j] == input[i][1])
                yCoor = j;
        output[xCoor][yCoor] = input[i][2];
    }

    return output;
}

这是JSFiddle.net上的内容 。

Answer 2

如果数据是一致的，您可能会放弃一些版本：

var temp = input[1][0],
    output = [[input[0][0]],[temp]],
    len = input[1].length,
    j = 1;

for (var i=1; i<input.length; i++){
  if (input[i][0] != temp){
    temp = input[i][0];
    output[++j] = [temp];
  }
  output[j].push(input[i][len-1]);
  if (j == 1){
    output[0].push(input[i][1]);
  }
}

Answer 3

我会使用对象，而不是数组。

而且您不应该将标头与内容存储在同一数组中...

// header: Season, Type, Dollars
    var input = [
        ['Winter',  'Sales',     1000],
        ['Winter',  'Expenses',  400],
        ['Winter',  'Profit',    250],
        ['Spring',  'Sales',     1170],
        ['Spring',  'Expenses',  460],
        ['Spring',  'Profit',    250],
        ['Summer',  'Sales',     660],
        ['Summer',  'Expenses',  1120],
        ['Summer',  'Profit',    300],
        ['Fall',    'Sales',     1030],
        ['Fall',    'Expenses',  540],
        ['Fall',    'Profit',    350]
    ];

    var desired_output = {};

    for(var i in input) {
        var season = input[i][0];
        if(!desired_output.hasOwnProperty(season)) {
            desired_output[season] = {};
        }
        switch(input[i][1]) {
            case 'Sales':
                if(!desired_output[season].hasOwnProperty('sales')) {
                    desired_output[season]['sales'] = 0;
                }
                desired_output[season]['sales'] += input[i][2];
                break;
            case 'Expenses': 
                if(!desired_output[season].hasOwnProperty('expenses')) {
                    desired_output[season]['expenses'] = 0;
                }
                desired_output[season]['expenses'] += input[i][2];
                break;
            case 'Profit':
                if(!desired_output[season].hasOwnProperty('profit')) {
                    desired_output[season]['profit'] = 0;
                }
                desired_output[season]['profit'] += input[i][2];
                break;
            default:

                break; 
        }
    }
    console.log(desired_output);

那将返回：

{
"Winter": {
    "sales": 1000,
    "expenses": 400,
    "profit": 250
},
"Spring": {
    "sales": 1170,
    "expenses": 460,
    "profit": 250
},
"Summer": {
    "sales": 660,
    "expenses": 1120,
    "profit": 300
},
"Fall": {
    "sales": 1030,
    "expenses": 540,
    "profit": 350
}
}

更新：

如果您仍需要该特定格式的值，

// header: Season, Type, Dollars
    var input = [
        // ['Season',  'Type',     'Dollars'], // header
        ['Winter',  'Sales',     1000],
        ['Winter',  'Expenses',  400],
        ['Winter',  'Profit',    250],
        ['Spring',  'Sales',     1170],
        ['Spring',  'Expenses',  460],
        ['Spring',  'Profit',    250],
        ['Summer',  'Sales',     660],
        ['Summer',  'Expenses',  1120],
        ['Summer',  'Profit',    300],
        ['Fall',    'Sales',     1030],
        ['Fall',    'Expenses',  540],
        ['Fall',    'Profit',    350]
    ];

    var desired_output_object = {};

    for(var i in input) {
        var season = input[i][0];
        if(!desired_output_object.hasOwnProperty(season)) {
            desired_output_object[season] = {};
        }
        switch(input[i][1]) {
            case 'Sales':
                if(!desired_output_object[season].hasOwnProperty('sales')) {
                    desired_output_object[season]['sales'] = 0;
                }
                desired_output_object[season]['sales'] += input[i][2];
                break;
            case 'Expenses': 
                if(!desired_output_object[season].hasOwnProperty('expenses')) {
                    desired_output_object[season]['expenses'] = 0;
                }
                desired_output_object[season]['expenses'] += input[i][2];
                break;
            case 'Profit':
                if(!desired_output_object[season].hasOwnProperty('profit')) {
                    desired_output_object[season]['profit'] = 0;
                }
                desired_output_object[season]['profit'] += input[i][2];
                break;
            default:

                break; 
        }
    }
    console.log(desired_output_object);


    var desired_output = [];
    for(var o in desired_output_object) {
        var output = desired_output_object[o];
        desired_output.push(output);
    }
    console.log(desired_output);

结果将是：

[{
"sales": 1000,
"expenses": 400,
"profit": 250
}, {
"sales": 1170,
"expenses": 460,
"profit": 250
}, {
"sales": 660,
"expenses": 1120,
"profit": 300
}, {
"sales": 1030,
"expenses": 540,
"profit": 350
}]