[ Leksykon ] [ JavaScript ] [ Tablice ] [ Metody ] [ Właściwości ] [ Array() ]

Array.prototype.flatMap()

flatMap(callbackFn)
flatMap(callbackFn, thisArg)

[_] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]

 

Przykłady:

const tablica = [1, 2, 3, 4];
const wynik = tablica.flatMap((znak) => (znak === 2 ? [5, 5] : 0));
console.log(wynik);
// Array [0, 5, 5, 0, 0]

  

const tablica = [1, 2, 3, 4, 5, 6];
wynik = tablica.flatMap((x) => [x, x * 5]);
console.log(wynik);
const a = tablica.length;
console.log(a);
const nowaTablica = new Array(a * 2);
for (let i = 0; i < a; i++) {
 const x = tablica[i];
 nowaTablica[i * 2] = x;
 nowaTablica[i * 2 + 1] = x * 2;
}
console.log(nowaTablica);
// Array [1, 5, 2, 10, 3, 15, 4, 20, 5, 25, 6, 30]
// 6
// Array [1, 2, 2, 4, 3, 6, 4, 8, 5, 10, 6, 12]

 

const tablica = [1, 2, 3, 4];
const wynik1 = tablica.map((x) => [x * 2]);
console.log(wynik1);
// Array [Array [2], Array [4], Array [6], Array [8]]
const wynik2 = tablica.flatMap((x) => [x * 2]);
console.log(wynik2);
// Array [2, 4, 6, 8]
const wynik3 = tablica.flatMap((x) => [[x * 2]]);
console.log(wynik3);
// Array [Array [2], Array [4], Array [6], Array [8]]

 

const tablica = ["jeden", "dwa", "trzy"];
const wynik1 = tablica.map((x) => x.split(" "));
console.log(wynik1);
// Array [Array ["jeden"], Array ["dwa"], Array ["trzy"]]
const wynik2 = tablica.flatMap((x) => x.split(" "));
console.log(wynik2);
// Array ["jeden", "dwa", "trzy"]

 

const tablica = [1, 4, -2, 5, 11, -3, -7, 18];
const wynik = tablica.flatMap((x) => {
 if (x < 0) {
 return [];
 }
 return x % 2 === 0 ? [x] : [x - 1, 5];
});
console.log(wynik); 
// Array [0, 5, 4, 4, 5, 10, 5, 18]

 

console.log([1, 2, , 4, 5].flatMap((x) => [x, x * 5])); 
// Array [1, 5, 2, 10, 4, 20, 5, 25]
console.log([1, 2, 3, 4].flatMap((x) => [, x * 5])); 
// Array [5, 10, 15, 20]

 

const tablica = {
 length: 3,
 0: 1,
 1: 2,
 2: 3,
 3: 4,
};
console.log(Array.prototype.flatMap.call(tablica, (x) => [x, x * 5]));
// Array [1, 5, 2, 10, 3, 15]
console.log(
 Array.prototype.flatMap.call(tablica, (x) => ({
 length: 2,
 0: x,
 1: x+1,
 })),
);
// Array [Object { 0: 1, 1: 2, length: 2 }, Object { 0: 2, 1: 3, length: 2 },
// Object { 0: 3, 1: 4, length: 2 }]

Opis:
Metoda Array.flatMap() instancji Array zwraca nową tablicę utworzoną poprzez zastosowanie danej funkcji zwrotnej do każdego elementu tablicy, a następnie spłaszczenie wyniku o jeden poziom. Jest identyczny z map() a flat() o głębokości 1 ( arr.map(...args).flat()), ale nieco bardziej wydajny niż wywoływanie tych dwóch metod osobno. Parametr pierwszy Funkcja do wykonania dla każdego elementu tablicy. Powinien zwrócić tablicę zawierającą nowe elementy nowej tablicy lub pojedynczą wartość niebędącą tablicą, która ma zostać dodana do nowej tablicy. Funkcja wywoływana jest z argumentami. Pierwszy argument bieżący element przetwarzany w tablicy. Drugi argument indeks bieżącego elementu przetwarzanego w tablicy. trzeci argument tablica flatMap() została wywołana. Drugi parametr opcjonalny wartość, która ma być używana this podczas wykonywania pierwszego parametru. Wartość zwracana nowa tablica, w której każdy element jest wynikiem funkcji wywołania zwrotnego i jest spłaszczony o głębokość 1. Metoda flatMap() jest metodą iteracyjną. Zobacz Array.prototype.map() szczegółowy opis funkcji wywołania zwrotnego. Wartość zwrócona z pierwszym parametrze musi być tablicą, jeśli ma zostać spłaszczona.

Linki: