Jak tworzyć tablice z tablicy [zamknięte]

33

Jestem początkującym w JavaScript i próbuję utworzyć dwie różne tablice z wartościami z jednej głównej tablicy.

Moja główna tablica wygląda następująco:

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 ]

I muszę utworzyć dwie tablice, najpierw wyglądające jak:

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]

(pierwsza i druga wartość)

a po drugie:

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]

(pierwsza i trzecia wartość)

Próbuję splicować, filtrować itp., Ale nie wiem, jak zacząć.

Nie jest konieczne napisanie mi dokładnego rozwiązania, a jedynie kroki, jak to zrobić.

javascript arrays

— Dominik Lev
źródło

Dziękuję bardzo za wspaniałe odpowiedzi. Działają świetnie. Mogę mieć jedno pytanie na przyszłość. Czy można to zrobić, aby nie było przymocowane do dwóch pól? Ale nawet trzy, cztery itd.?

— Dominik Lev

3

Jaki faktyczny problem próbujesz tutaj rozwiązać? Wydaje się prawdopodobne, że lepszym rozwiązaniem jest użycie tablicy obiektów.

— BlueRaja - Danny Pflughoeft

Sugestia: zamiast mieć wyraźne kolejne lata w tablicy, możesz mieć rok domyślny z danego punktu początkowego. Następnie potrzebujesz tylko jednego skalarnego punktu początkowego, a rok dla dowolnego elementu jest znany na podstawie jego indeksu tablicowego. (Działa tylko wtedy, gdy lata są zawsze ciągłe i rosnące, jak w tym przykładzie. Ale ładnie upraszcza to od szeregu par do szeregu pierwotnych liczb).

— Peter Cordes

29

Możesz zastosować podejście dynamiczne i uzyskać wszystkie elementy tablicy po wartości klucza dla każdej nowej tablicy.

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; }

Rozwiń fragment kodu

— Nina Scholz
źródło

Dziękuję bardzo za świetną odpowiedź. Czy mogę zadać pytanie na przyszłość? Czy można to naprawić nie tylko na 2 tablicach, ale także na więcej?

— Dominik Lev

1

można zastąpić [first, second]z arrayi masz tablice ze wszystkimi kolumnami danych, jak tablice.

— Nina Scholz

2

Zamiast tego raczej powolnego r[i] = r[i] || []należy użyć Array.from({length: (data[0]?.length ?? 1) - 1}, () => [])początkowej wartości akumulatora

— Bergi

3

@NinaScholz Nie, miałem na myśli, że sprawdzasz, czy r[i]istnieje w każdej iteracji pętli, podczas gdy możesz po prostu utworzyć niezbędne tablice wyników poza reducewywołaniem.

— Bergi

1

@Klaycon Nie, dostęp do tablicy poza jej granicami jest bardzo wolny, więc „sprawdź, czy już istnieje” nie działa dobrze. Mój komentarz nie miał martwić się wydajnością, ale preferował czysty i przewidywalny (poprawny) kod. Najpierw napisałem „raczej brzydki i powolny”, zanim zdałem sobie sprawę, że moja sugestia, która wyraźnie mówi, że radzenie sobie z pustą skrzynką nie jest prawdziwa.

— Bergi

14

Możesz użyć .map()do iteracji swoich danych i użyć Destrukturyzacji tablicy, aby uzyskać pożądane dane wyjściowe:

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; }

Rozwiń fragment kodu

— Mohammad Usman
źródło

Dziękuję bardzo za świetną odpowiedź. Czy mogę zadać pytanie na przyszłość? Czy można to naprawić nie tylko na 2 tablicach, ale także na więcej?

— Dominik Lev

1

@DominikLev W takim przypadku możesz użyć odpowiedzi opublikowanej przez Ninę. To jest dobre.

— Mohammad Usman,

1

Można to uogólnić, używając składni parametru rest do([year, ...values]) => [year, values[n]]

— JollyJoker

@JollyJoker - powinieneś zamieścić to jako odpowiedź, to naprawdę miłe i zwięzłe uogólnione rozwiązanie

— Filip Milovanović

@ FilipMilovanović Zrobiłem już stackoverflow.com/a/60166014/7126740

— JollyJoker

6

Możesz użyć Array.prototype.forEachdo iteracji elementów oryginalnej tablicy, a następnie utwórz nowe elementy i wepchnij je do nowych tablic:

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);

Wynik:

Dynamiczne generowanie naszych tablic, dzięki czemu rozwiązanie działa bez względu na liczbę elementów oryginalnych tablic:

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);

Wynik:

— Ismael Padilla
źródło

Dziękuję bardzo za świetną odpowiedź. Czy mogę zadać pytanie na przyszłość? Czy można to naprawić nie tylko na 2 tablicach, ale także na więcej?

— Dominik Lev

1

Możliwe jest dynamiczne generowanie tablic bez wcześniejszej wiedzy o tym, ile elementów będą miały oryginalne tablice. Spójrz na moją zredagowaną odpowiedź :)

— Ismael Padilla

4

Przede wszystkim macie tablicę na początku. Możesz ustawić maptę tablicę na dwie różne tablice, używając destructuringw zwięzły sposób każdej wartości z podrzędnych:

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));

Rozwiń fragment kodu

— Alberto Trindade Tavares
źródło

4

Zapętlaj główną tablicę i zwróć nową tablicę, używając stałych wartości indeksu, aby uzyskać dostęp do wartości tablic podrzędnych.

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)

Rozwiń fragment kodu

— Eugen Sunic
źródło

3

Możesz użyć funkcji zmniejsz w następujący sposób, która iteruje tylko raz:

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; }

Rozwiń fragment kodu

— Ele
źródło

Dlaczego CSS w tej odpowiedzi?

— Joshua Fox

1

@JoshuaFox tylko dla zwiększenia wysokości konsoli.

— Ele

3

Proszę bardzo

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);

Rozwiń fragment kodu

— Muhammad Zeeshan
źródło

2

Użyłem map for loop, dwóch tablic do wypchnięcia potrzebnych wartości.

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)

Rozwiń fragment kodu

— iEfimoff
źródło

1

inne rozwiązanie :

 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]]]). redukcja ((a, b) => a.concat (b), [])

— Cem Tuğut
źródło

1

Jeśli chodzi o ogólne rozwiązanie, myślę, że budowanie tablicy indeksów dla kolumn wartości daje prosty sposób mapowania pełnych danych na pożądane tablice.

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

daje tablicę indeksów minus jedna kolumna, która była rokiem, i

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

daje tablicę, którą chcesz dla kolumny n-tej wartości. Więc:

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; }

Rozwiń fragment kodu

— JollyJoker
źródło

0

Inne rozwiązanie dla tablic wejściowych o ogólnej długości.

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);

Rozwiń fragment kodu

— Linus
źródło

0

Skorzystaj z tego rozwiązania, aby wykonać dowolną ogólną kombinację z istniejącej macierzy wielowymiarowej. Musisz jawnie przekazać indeks przedmiotów do wybrania, a to czyni go ogólnym.

    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));

Rozwiń fragment kodu

— rach8garg
źródło