Como criar matrizes a partir da matriz [fechada]

33

Eu sou iniciante em JavaScript e estou tentando criar duas matrizes diferentes com valores de uma matriz principal.

Minha matriz principal se parece com:

0: Array(3) [ 2011, 127072.7, 51584 ]
1: Array(3) [ 2012, 125920.3, 59974 ]
2: Array(3) [ 2013, 129305.4, 15468 ]
3: Array(3) [ 2014, 135364, 84554 ]
4: Array(3) [ 2015, 136757, 98754 ]
5: Array(3) [ 2016, 155653.5, 155548 ]
6: Array(3) [ 2017, 164130.5, 284848 ]

E eu preciso criar duas matrizes, primeiro parecendo:

0: Array(2) [ 2011, 127072.7]
1: Array(2) [ 2012, 125920.3]
2: Array(2) [ 2013, 129305.4]
3: Array(2) [ 2014, 135364]
4: Array(2) [ 2015, 136757]
5: Array(2) [ 2016, 155653.5]
6: Array(2) [ 2017, 164130.5]

(primeiro e segundo valor)

e segundo como:

0: Array(2) [ 2011, 51584]
1: Array(2) [ 2012, 59974]
2: Array(2) [ 2013, 15468]
3: Array(2) [ 2014, 84554]
4: Array(2) [ 2015, 98754]
5: Array(2) [ 2016, 155548]
6: Array(2) [ 2017, 284848]

(primeiro e terceiro valor)

Estou tentando emendar, filtrar etc., mas não sei como começar.

Não é necessário me escrever uma solução exata, mas apenas as etapas de como fazê-lo.

javascript arrays

— Dominik Lev
fonte

Muito obrigado pelas ótimas respostas. Eles funcionam muito bem. Eu posso ter uma pergunta para o futuro. Isso pode ser feito para que não seja fixado em dois campos? Mas até três, quatro, etc?

— Dominik Lev

3

Qual é o problema real que você está tentando resolver aqui? Parece provável que usar uma matriz de objetos seja a melhor opção.

— BlueRaja - Danny Pflughoeft

Sugestão: em vez de ter anos consecutivos explícitos em sua matriz, é possível que o ano esteja implícito a partir de um determinado ponto de partida. Então você só precisa de um ponto de partida escalar e o ano para qualquer elemento é conhecido com base em seu índice de matriz. (Só funciona se os seus anos são sempre contíguas e em ordem ascendente como este exemplo, mas não muito bem simplificar a partir de uma matriz de pares para apenas uma matriz de números primitivos..)

— Peter Cordes

29

Você pode adotar uma abordagem dinâmica e obter todos os itens da matriz após o valor da chave para cada nova matriz.

var data = [[2011, 127072.7, 51584], [2012, 125920.3, 59974], [2013, 129305.4, 15468], [2014, 135364, 84554], [2015, 136757, 98754], [2016, 155653.5, 155548], [2017, 164130.5, 284848]],
    [first, second] = data.reduce(
        (r, [k, ...a]) => {
            a.forEach((v, i) => r[i].push([k, v]));
            return r;
        },
        Array.from({ length: Array.isArray(data[0]) ? data[0].length - 1 : 0 }, () => [])
    );

console.log(first);
console.log(second);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Expandir snippet

— Nina Scholz
fonte

Muito obrigado por uma ótima resposta. Posso fazer uma pergunta para o futuro? É possível corrigi-lo não apenas em 2 matrizes, mas também em mais?

— Dominik Lev

11

você pode substituir [first, second]por arraye obter matrizes com todas as colunas dos dados como matrizes.

— Nina Scholz

2

Em vez de muito lento, r[i] = r[i] || []você deve usar apenas Array.from({length: (data[0]?.length ?? 1) - 1}, () => [])o valor inicial do acumulador

— Bergi 11/02

3

@NinaScholz Não, eu quis dizer que você está verificando se r[i]existe em cada iteração de loop, enquanto você pode simplesmente criar as matrizes de resultados necessárias fora da reducechamada.

— Bergi 11/02

11

@Klaycon Não, os acessos à matriz fora dos limites da matriz são super lentos; portanto, "verifique se já existe" não funciona bem. Meu comentário não foi feito para se preocupar com o desempenho, mas para preferir um código limpo e previsível (correto). Escrevi pela primeira vez "bastante feio e lento" antes de perceber que minha sugestão que torna explícito lidar com o caso vazio também não é uma verdadeira beleza.

— Bergi 11/02

14

Você pode usar .map()para iterar sobre seus dados e usar alguma Reestruturação de Matriz para obter a saída desejada:

const data = [
  [ 2011, 127072.7, 51584 ],
  [ 2012, 125920.3, 59974 ],
  [ 2013, 129305.4, 15468 ],
  [ 2014, 135364, 84554 ],
  [ 2015, 136757, 98754 ],
  [ 2016, 155653.5, 155548 ],
  [ 2017, 164130.5, 284848 ]
];

const arr1 = data.map(([year, val]) => ([year, val]));
const arr2 = data.map(([year, _, val]) => ([year, val]));

console.log(arr1);
console.log(arr2);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Expandir snippet

— Mohammad Usman
fonte

Muito obrigado por uma ótima resposta. Posso fazer uma pergunta para o futuro? É possível corrigi-lo não apenas em 2 matrizes, mas também em mais?

— Dominik Lev

11

@DominikLev Nesse caso, você pode usar a resposta postada por Nina. É uma boa.

— Mohammad Usman

11

Isso pode ser generalizado usando a sintaxe do parâmetro rest para([year, ...values]) => [year, values[n]]

— JollyJoker

@JollyJoker - você deve postar isso como resposta, essa é uma solução generalizada muito boa e concisa

— Filip Milovanović

@ FilipMilovanović Eu já fiz stackoverflow.com/a/60166014/7126740

— JollyJoker

6

Você pode usar Array.prototype.forEachpara iterar sobre os itens da matriz original, criar os novos itens e enviá-los para novas matrizes:

var original = [[ 2011, 127072.7, 51584 ], [ 2012, 125920.3, 59974 ], [ 2013, 129305.4, 15468 ]]

var array1 = []
var array2 = []

original.forEach(item => {
  array1.push([item[0], item[1]]);
  array2.push([item[0], item[2]]);
});

console.log(array1);
console.log(array2);

Resultado:

Gerando nossas matrizes dinamicamente para que a solução funcione, independentemente de quantos itens as matrizes originais tiverem:

var original = [
  [2011, 127072.7, 51584, 1, 2, 3],
  [2012, 125920.3, 59974, 4, 5, 6],
  [2013, 129305.4, 15468, 7, 8, 9]
]

// Array of arrays
var myArray = []

// Fill it with empty arrays
for (var i = 0; i < original[0].length - 1; i++)
  myArray.push([])

// Iterate over original
// For each original, insert the first and i-th element into our array of arrays
original.forEach(item => {
  for (var i = 1; i < item.length; i++) {
    myArray[i - 1].push([item[0], item[i]]);
  }
});

console.log(myArray);

Resultado:

— Ismael Padilla
fonte

Muito obrigado por uma ótima resposta. Posso fazer uma pergunta para o futuro? É possível corrigi-lo não apenas em 2 matrizes, mas também em mais?

— Dominik Lev

11

É possível gerar as matrizes dinamicamente sem saber antecipadamente quantos itens as matrizes originais terão. Dê uma olhada na minha resposta editada :)

— Ismael Padilla

4

Primeiro de tudo, você tem uma matriz de matrizes no início. Você pode mapessa matriz para duas matrizes diferentes usando destructuringpara obter cada valor das sub- matrizes de maneira concisa:

const data = [
  [ 2011, 127072.7, 51584 ],
  [ 2012, 125920.3, 59974 ],
  [ 2013, 129305.4, 15468 ],
  [ 2014, 135364, 84554 ],
  [ 2015, 136757, 98754 ],
  [ 2016, 155653.5, 155548 ],
  [ 2017, 164130.5, 284848 ],
];

const array1 = data.map(([first, second, third]) => [first, second]);
const array2 = data.map(([first, second, third]) => [first, third]);

console.log(JSON.stringify(array1));
console.log(JSON.stringify(array2));

Expandir snippet

— Alberto Trindade Tavares
fonte

4

Faça um loop na matriz principal e retorne uma nova matriz usando valores de índice fixos para acessar os valores das matrizes filho.

const multiDimArr = [
  [2011, 127072.7, 51584],
  [2012, 125920.3, 59974],
  [2013, 129305.4, 15468],
  [2014, 135364, 84554],
  [2015, 136757, 98754],
  [2016, 155653.5, 155548],
  [2017, 164130.5, 284848],
]

const arr1= multiDimArr.map(x=>[x[0],x[1]]);
const arr2= multiDimArr.map(x=>[x[0],x[2]]);

console.log(arr1)
console.log(arr2)

Expandir snippet

— Eugen Sunic
fonte

3

Você pode usar a função reduzir da seguinte maneira, que itera apenas uma vez:

let matrix = [[ 2011, 127072.7, 51584 ],[ 2012, 125920.3, 59974 ],[ 2013, 129305.4, 15468 ],[ 2014, 135364, 84554 ],[ 2015, 136757, 98754 ],[ 2016, 155653.5, 155548 ],[ 2017, 164130.5, 284848 ]];

let result = matrix.reduce((a, [year, k, v]) => {
  a.second.push([year, k]);
  a.third.push([year, v]);
  return a;
}, {second: [], third: []});

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Expandir snippet

— Ele
fonte

Por que o CSS nesta resposta?

— Joshua Fox

11

@ JosuéFox apenas por expandir a altura do console.

— Ele

3

Aqui está

let values = [[ 2011, 127072.7, 51584 ],[ 2012, 125920.3, 59974 ],[ 2013, 129305.4, 15468 ],[ 2014, 135364, 84554 ],[ 2015, 136757, 98754 ],[ 2016, 155653.5, 155548 ],[ 2017, 164130.5, 284848 ]];

let chunk1 = values.map(arr1 => {
  return [arr1[0], arr1[1]]
});
let chunk2 = values.map(arr1 => {
  return [arr1[0], arr1[2]]
})

console.log("Chunk 1", chunk1);
console.log("Chunk 2", chunk2);

Expandir snippet

— Muhammad Zeeshan
fonte

2

Eu usei map for loop, duas matrizes para enviar os valores necessários.

let point_table = []
let integer_table = []
const historical_table = [
  [2011, 127072.7, 51584],
  [2012, 125920.3, 59974],
  [2013, 129305.4, 15468],
  [2014, 135364, 84554],
  [2015, 136757, 98754],
  [2016, 155653.5, 155548],
  [2017, 164130.5, 284848]
]
historical_table.map(row => {
  point_table.push([row[0], row[1]])
  integer_table.push([row[0], row[2]])
})
console.log(point_table, integer_table)

Expandir snippet

— iEfimoff
fonte

1

outra solução:

 const original= [  [ 2011, 127072.7, 51584 ], [ 2012, 125920.3, 59974 ],[ 2013, 129305.4, 15468 ],  [ 2014, 135364, 84554 ],  [ 2015, 136757, 98754 ],  [ 2016, 155653.5, 155548 ],  [ 2017, 164130.5, 284848 ]];

original.map (x => [[x [0], x [1]], [x [0], x [2]]]) .reduce ((a, b) => a.concat (b), [])

— Cem Tuğut
fonte

1

Para a solução genérica, acho que a criação de uma matriz de índices para as colunas de valor oferece uma maneira simples de mapear os dados completos para as matrizes que você deseja.

[...data[0].keys()].slice(0,-1)

fornece uma matriz de índices, menos a coluna que foi o ano e

n => data.map(([year, ...values]) => [year, values[n]])

fornece a matriz que você deseja para a coluna de enésimo valor. Assim:

var data = [[2011, 127072.7, 51584], [2012, 125920.3, 59974], [2013, 129305.4, 15468], [2014, 135364, 84554], [2015, 136757, 98754], [2016, 155653.5, 155548], [2017, 164130.5, 284848]]

const yearArrays = arr => [...arr[0].keys()].slice(0,-1)
       .map(arr.map(([year, ...values]) => [year, values[n]]))

console.log(yearArrays(data));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Expandir snippet

— JollyJoker
fonte

0

Outra solução para matrizes de entrada de comprimento genérico.

const input = [[1,11,111,1111],[2,22,222,2222]];

const result = input.reduce((accumulator, [head, ...tail]) => {
  tail.forEach((item, index) => {
    accumulator[index] = accumulator[index] || [];
    accumulator[index].push([head, item]);
  });
  return accumulator;
}, [])

console.log(result);

Expandir snippet

— Linus
fonte

0

Use esta solução para fazer qualquer combinação genérica da matriz multidimensional existente. Você precisa passar o índice de itens para escolher explicitamente e é isso que o torna genérico.

    const multiDimArr = [
      [2011, 127072.7, 51584],
      [2012, 125920.3, 59974],
      [2013, 129305.4, 15468],
      [2014, 135364, 84554],
      [2015, 136757, 98754],
      [2016, 155653.5, 155548],
      [2017, 164130.5, 284848],
    ]


    function arrayCombo (idxA, idxB){
      return multiDimArr.map(x=>[x[idxA],x[idxB]]);
    }

    console.log(arrayCombo(0, 1));
    console.log(arrayCombo(0, 2));
    console.log(arrayCombo(1, 2));

Expandir snippet

— rach8garg
fonte