Operațiuni cu tablouri
JavaScript oferă ample posibilități pentru manipularea tablourilor, realizate prin intermediul metodelor obiectului Array:
- concat(): unifică elementele a două tablouri într-un singur tablou
- every(): verifică dacă toate elementele corespund unei anumite condiții
- filter(): filtrează elementele unui tablou
- find(): returnează primul element al unui tablou care satisface o anumită condiție
- findLast(): returnează ultimul element care satisface o condiție
- findIndex(): returnează indexul primului element dintr-un tablou care satisface o condiție
- findLastIndex(): returnează indexul ultimului element care satisface o condiție
- flat(): simplifică structura elementelor tabloului în mod recursiv
- forEach(): aplică o funcție specifică fiecărui element al tabloului
- includes(): verifică dacă o valoare există în tablou
- indexOf(): returnează indexul primei apariții a unui element în tablou
- join(): unește elementele tabloului într-un șir de caractere
- lastIndexOf(): returnează indexul ultimei apariții a unui element în tablou
- map(): transformă fiecare element al tabloului în altă valoare în funcție de o funcție de proiecție
- pop(): elimină ultimul element al tabloului
- push(): adaugă un element la sfârșitul tabloului
- reduce(): combină elementele tabloului într-o singură valoare
- reverse(): inversează ordinea elementelor în tablou
- shift(): elimină primul element al tabloului
- slice(): extrage porțiuni de elemente din tablou
- splice(): adaugă sau elimină elemente la/din anumite poziții din tablou
- some(): verifică dacă cel puțin un element corespunde unei condiții
- sort(): sortează elementele tabloului
- unshift(): adaugă un nou element la începutul tabloului
Să analizăm aplicarea acestor metode.
Adăugarea de date
push()
Metoda push() adaugă un element la sfârșitul unui array.
const people = [];
people.push("Tom");
people.push("Sam");
people.push("Bob", "Mike");
console.log("În tabloul people există elemente: ", people.length);
console.log(people); // ["Tom", "Sam", "Bob", "Mike"]unshift()
Metoda unshift() adaugă un nou element la începutul unui array.
const people = ["Bob"];
people.unshift("Alice");
console.log(people); // ["Alice", "Bob"]
people.unshift("Tom", "Sam");
console.log(people); // ["Tom", "Sam", "Alice", "Bob"]Adăugarea datelor la un anumit index
Metoda splice permite inserarea de elemente la o anumită poziție. Primul argument reprezintă indexul în tablou unde trebuie adăugate noile elemente. Al doilea argument reprezintă numărul de elemente care trebuie eliminate (această metodă este de asemenea folosită și pentru ștergere). Pentru adăugare, acest argument este setat la valoarea 0. Toate celelalte argumente reprezintă elementele care trebuie adăugate în tablou.
const people = ["Tom", "Sam", "Bob"];
people.splice(1, 0, "Alice"); // Adăugăm elementul "Alice" la indexul 1.
console.log(people); // ["Tom", "Alice", "Sam", "Bob"]În această situație, adăugăm elementul "Alice" la indexul 1.
De asemenea, se poate adăuga un set de elemente începând de la un anumit index:
const people = ["Tom", "Sam", "Bob"];
people.splice(1, 0, "Alice", "Alex", "Kate"); // Adăugăm elementul "Alice" la indexul 1.
console.log(people); // ["Tom", "Alice", "Alex", "Kate", "Sam", "Bob"]Eliminarea datelor
pop()
Metoda pop() elimină ultimul element dintr-un array.
const people = ["Tom", "Sam", "Bob", "Mike"];
const lastPerson = people.pop(); //Extragem ultimul element dintr-un array.
console.log(lastPerson ); // Mike
console.log(people); // ["Tom", "Sam", "Bob"]În calitate de rezultat, metoda pop returnează elementul eliminat.
shift()
Metoda shift() extrage și elimină primul element dintr-un array:
const people = ["Tom", "Sam", "Bob", "Mike"];
const first = people.shift(); //Extragem primul element dintr-un array.
console.log(first); // Tom
console.log(people); // ["Sam", "Bob", "Mike"]Eliminarea unui element după index.splice()
Metoda splice() elimină, de asemenea, elemente de la un anumit index. De exemplu, eliminarea elementelor de la indexul al treilea:
const people = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const deleted = people.splice(3);
console.log(deleted); // [ "Alice", "Kate" ]
console.log(people); // [ "Tom", "Sam", "Bill" ]Metoda splice() returnează elementele eliminate sub forma unui nou array.
În această situație, eliminarea începe de la începutul tabloului. Dacă se furnizează un index negativ, eliminarea va începe de la sfârșitul tabloului. De exemplu, să eliminăm ultimul element:
const people = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const deleted = people.splice(-1);
console.log(deleted); // [ "Kate" ]
console.log(people); // ["Tom", "Sam", "Bill", "Alice"]Varianta suplimentară a metodei permite specificarea numărului de elemente de eliminat. De exemplu, să eliminăm trei elemente de la primul index:
const people = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const deleted = people.splice(1, 3);
console.log(deleted); // ["Sam", "Bill", "Alice"]
console.log(people); // ["Tom", "Kate"]Înlocuirea elementelor
Metoda splice() permite atât adăugarea, cât și eliminarea elementelor. Putem combina aceste două funcționalități pentru a înlocui unii elemente dintr-un tablou cu alții. De exemplu:
const people = ["Tom", "Sam", "Bob", "Alice", "Kate"];
const deleted = people.splice(1, 3, "Alex", "Mike");
console.log(deleted); // ["Sam", "Bob", "Alice"]
console.log(people); // ["Tom", "Alex", "Mike", "Kate"]În acest caz, eliminăm de la indexul 1 (primul parametru al lui splice) 3 elemente (al doilea parametru al lui splice) și, în locul lor, inserăm două elemente - "Alex" și "Mike".
Copierea unui tablou
Metoda slice()
Copierea unui tablou poate fi superficială (shallow copy) sau adâncă (deep copy).
În cazul copierii superficiale, este suficient să atribuim variabilei valoarea altei variabile care stochează tabloul:
const users = ["Tom", "Sam", "Bill"];
console.log(users); // ["Tom", "Sam", "Bill"]
const people = users; // copiere superficială
people[1] = "Mike"; // modificăm al doilea element
console.log(users); // ["Tom", "Mike", "Bill"]În acest caz, variabila "people", după copiere, va face referire la același tablou ca și variabila "users". Prin urmare, atunci când modificăm elementele în "people", se vor modifica și elementele în "users", deoarece acestea sunt, de fapt, același tablou.
Un astfel de comportament nu este întotdeauna dorit. De exemplu, putem dori ca, după copiere, variabilele să facă referire la tablouri separate. În acest caz, putem utiliza o copie profundă folosind metoda slice().
const users = ["Tom", "Sam", "Bill"];
console.log(users); // ["Tom", "Sam", "Bill"]
const people = users.slice(); // copiere adâncă
people[1] = "Mike"; // modificăm al doilea element
console.log(users); // ["Tom", "Sam", "Bill"]
console.log(people); // ["Tom", "Mike", "Bill"]În acest caz, după copiere, variabilele vor face referire la tablouri diferite, și vom putea să le modificăm separat.
Totuși, merită de menționat că aceeași copiere se poate realiza, de fapt, și cu ajutorul operatorului spread ...:
const users = ["Tom", "Sam", "Bill"];
console.log(users); // ["Tom", "Sam", "Bill"]
const people = [...users];
people[1] = "Mike"; // modificăm al doilea element
console.log(users); // ["Tom", "Sam", "Bill"]
console.log(people); // ["Tom", "Mike", "Bill"]De asemenea, metoda slice() permite copierea unei părți a unui array. Pentru aceasta, acceptă doi parametri:
slice(începutul_indexului, sfârșitul_indexului)Primul parametru indică indexul de început al elementului de la care se începe extragerea valorilor din array. Al doilea parametru reprezintă indexul final, până la care se face copierea.
Dacă este specificat doar începutul indexului și acesta este un număr pozitiv, atunci copierea se face de la acest index până la sfârșitul array-ului:
const users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const people = users.slice(2); // de la al 2-lea index până la sfîrșit
console.log(people); // ["Bill", "Alice", "Kate"]Dacă este specificat doar începutul indexului și acesta este un număr negativ, indexul este numărat de la sfârșitul array-ului, iar copierea se face de la sfârșitul array-ului până la acest index:
const users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const people = users.slice(-2); // până la al 2-lea index de la sfîrșit
console.log(people); // ["Alice", "Kate"]Al doilea parametru permite să restricționați selecția elementelor copiate. De exemplu, să alegem într-un nou array elementele începând cu indexul 1 până la indexul 4, fără a-l include:
const users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const people = users.slice(1, 4);
console.log(people); // ["Sam", "Bill", "Alice"]Și deoarece indexarea array-urilor începe de la zero, atunci în noul array vor fi incluse al doilea, al treilea și al patrulea element.
De asemenea, al doilea parametru poate fi negativ. În acest caz, al doilea index este numărat de la sfârșit:
const users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const people = users.slice(2, -1); // De la indexul 2 până la indexul 1 de la sfârșit:
console.log(people); // ["Bill", "Alice"]copyWithin()
Metoda copyWithin() permite copierea elementelor în interiorul unui array. Aceasta acceptă trei parametri:
copyWithin(index1, // poziția la care sunt copiate elementele
index2, // poziția de start de la care vor fi copiate elementele
index3 // poziția finală până la care vor fi copiate elementele
)Exemplu de utilizare:
const users = ["Tom", "Sam", "Bob", "Alice", "Kate"];
const people = users.copyWithin(1, 3, 5); // elementele de la indexul 3 la indexul 4 (două elemente)
// sunt copiate la indexul 1
console.log(people); // ["Tom", "Alice", "Kate", "Alice", "Kate"]Obținerea elementelor în afara intervalului. toSpliced()
Dar, poate că dorim doar să obținem elementele în afara unui anumit interval fără a modifica array-ul curent. În acest caz, putem utiliza metoda toSpliced(). Această metodă returnează un array format din elementele care se află în afara intervalului specificat:
const people = ["Tom", "Sam", "Bill", "Alice", "Kate"];
const range = people.toSpliced(1, 3);
console.log(range); // ["Tom", "Kate"]
console.log(people); // ["Tom", "Sam", "Bill", "Alice", "Kate"]concat()
Metoda concat() este folosită pentru a uni array-uri. Ca rezultat, returnează array-ul unit:
const men = ["Tom", "Sam", "Bob"];
const women = ["Alice", "Kate"];
const people = men.concat(women);
console.log(people); // ["Tom", "Sam", "Bob", "Alice", "Kate"]join()
Metoda join() concatenează toate elementele unui array într-un singur șir, folosind un separator specificat, care este transmis prin parametru:
const people = ["Tom", "Sam", "Bob"];
const peopleToString = people.join("; ");
console.log(peopleToString); // Tom; Sam; BobÎn metoda join(), se furnizează un separator între elementele array-ului. În acest caz, ca separator va fi utilizată virgula și spațiul ("; ").
sort() și toSorted.
Metoda sort() sortează array-ul în ordine crescătoare:
const people = ["Tom", "Sam", "Bob"];
people.sort();
console.log(people); // ["Bob", "Sam", "Tom"]Merită de menționat că, în mod implicit, metoda sort() tratează elementele array-ului ca șiruri și le sortează în ordine alfabetică. Acest lucru poate duce la rezultate neașteptate, de exemplu:
const numbers = [200, 15, 5, 35];
numbers.sort();
console.log(numbers); // [15, 200, 35, 5]Aici vrem să sortăm un array de numere, dar rezultatul poate fi dezamăgitor: [15, 200, 35, 5]. În acest caz, putem personaliza metoda, transmițându-i o funcție de sortare. Logica funcției de sortare este definită de noi înșine:
const numbers = [200, 15, 5, 35];
numbers.sort( (a, b) => a - b);
console.log(numbers); // [5, 15, 35, 200]Funcția de sortare primește două elemente consecutive ale array-ului. Aceasta returnează un număr negativ dacă primul element trebuie să fie înaintea celui de-al doilea element. Dacă primul element trebuie să fie după cel de-al doilea, atunci se returnează un număr pozitiv. Dacă elementele sunt egale, se returnează 0.
JavaScript oferă, de asemenea, metoda toSorted(), care returnează elementele sortate sub forma unui nou array, fără a modifica array-ul curent:
const numbers = [200, 15, 5, 35];
const sorted = numbers.toSorted();
console.log(sorted); // [15, 200, 35, 5]Implicit, metoda toSorted() sortează și ea în ordine alfabetică. Cu toate acestea, puteți furniza metodei o funcție de comparație pentru a personaliza modul în care elementele sunt sortate:
const numbers = [200, 15, 5, 35];
const sorted = numbers.toSorted( (a, b) => a - b);
console.log(sorted); // [5, 15, 35, 200]reverse() și toReversed().
Metoda reverse() inversează ordinea elementelor într-un array:
const people = ["Tom", "Sam", "Bob"];
people.reverse();
console.log(people); // ["Bob", "Sam", "Tom"]Metoda toReversed() face, de asemenea, inversarea ordinii elementelor, dar le returnează sub formă de un nou array, fără a modifica array-ul curent:
const people = ["Tom", "Sam", "Bob"];
const reversed = people.toReversed();
console.log(people); // ["Tom", "Sam", "Bob"]
console.log(reversed); // ["Bob", "Sam", "Tom"]Căutarea indexului unui element
Metodele indexOf() și lastIndexOf() returnează indexul primei și ultimei apariții a unui element într-un array. De exemplu:
const people = ["Tom", "Sam", "Bob", "Tom", "Alice", "Sam"];
const firstIndex = people.indexOf("Tom");
const lastIndex = people.lastIndexOf("Tom");
const otherIndex = people.indexOf("Mike");
console.log(firstIndex); // 0
console.log(lastIndex); // 3
console.log(otherIndex); // -1firstIndex are valoarea 0, deoarece prima apariție a șirului "Tom" în array are loc la indexul 0, iar ultima la indexul 3.
Dacă elementul lipsește din array, atunci în acest caz, metodele **indexOf()** și **lastIndexOf()** returnează valoarea -1.
Verificarea existenței unui element
Metoda includes() verifică dacă există o valoare în array, transmisă ca parametru. Dacă această valoare există, metoda returnează true, în caz contrar returnează false. De exemplu:
const people = ["Tom", "Sam", "Bob", "Tom", "Alice", "Sam"];
console.log(people.includes("Tom")); // true - "Tom" se află în array
console.log(people.includes("Kate")); // false - "Kate" nu se află în arrayCa al doilea parametru, metoda includes() primește un index de la care să înceapă căutarea:
const people = ["Tom", "Sam", "Bob", "Tom", "Alice", "Sam"];
console.log(people.includes("Bob", 2)); // true
console.log(people.includes("Bob", 4)) // falseÎn acest caz, observăm că la căutarea începând cu indexul 2, în array există șirul "Bob", în timp ce începând cu indexul 4, acest șir lipsește.
Dacă acest parametru nu este furnizat, căutarea are loc începând cu indexul 0 în mod implicit.
La furnizarea unei valori negative, căutarea are loc de la sfârșit.
const people = ["Tom", "Sam", "Bob", "Tom", "Alice", "Sam"];
console.log(people.includes("Tom", -2)); // false - al 2-lea index de la sfârșit
console.log(people.includes("Tom", -3)); // true - al 3-lea index de la sfârșitevery()
Metoda every() verifică dacă toate elementele corespund unei anumite condiții:
const numbers = [ 1, -12, 8, -4, 25, 42 ];
const passed = numbers.every(n => n > 0);
console.log(passed); // falseÎn metoda every(), se furnizează o funcție ca parametru, care reprezintă condiția. Această funcție primește un element ca parametru și returnează true (dacă elementul corespunde condiției) sau false (dacă nu corespunde).
Dacă cel puțin un element nu corespunde condiției, metoda every() returnează valoarea false.
În acest caz, condiția este definită folosind expresia lambda n => n > 0, care verifică dacă elementul este mai mare decât zero.
some()
Metoda some() este similară cu metoda every(), dar verifică dacă cel puțin un element corespunde condiției. În acest caz, metoda some() returnează true. Dacă nu există elemente care să corespundă condiției, se returnează valoarea false.
const numbers = [ 1, -12, 8, -4, 25, 42 ];
const passed = numbers.some(n => n > 0);
console.log(passed); // truefilter()
Metoda filter(), asemănătoare cu some() și every(), primește o funcție condițională.
filter(callbackFn)
filter(callbackFn, thisArg)În calitate de parametru pentru forEach, se furnizează o funcție de tip callback, care va fi apelată pentru fiecare element al array-ului în curs de traversare. Această funcție de callback poate avea până la trei parametri:
callback(element, index, array)În cadrul funcției de tip callback, sunt furnizate în mod consecutiv trei parametri: elementul curent (element), indexul elementului (index) și o referință la array-ul care este iterat (array).
Opțional, poți furniza un al doilea parametru pentru metoda forEach(), care este un obiect și poate fi accesat în interiorul funcției de callback prin intermediul cuvântului cheie this.
Metoda filter() returnează ca rezultat un array format din elementele care îndeplinesc condiția specificată.
const numbers = [ 1, -12, 8, -4, 25, 42 ];
const filteredNumbers = numbers.filter(n => n > 0);
console.log(filteredNumbers); // [1, 8, 25, 42]Iterarea prin elemente folosind forEach()
Metoda forEach() iterează prin elementele și aplică o acțiune specifică fiecăruia dintre ele.
forEach(callbackFn)
forEach(callbackFn, thisArg)Ca parametru pentru forEach, se furnizează o funcție de tip callback, care va fi apelată pentru fiecare element al array-ului în curs de iterare. Această funcție callback poate avea până la trei parametri:
callback(element, index, array)În funcția de tip callback, în mod consecutiv, sunt furnizate elementul curent (element), indexul elementului (index), și referința la array-ul iterat (array).
Opțional, ca al doilea parametru în metoda forEach(), poți furniza un obiect, pe care îl poți accesa în funcția de tip callback folosind cuvântul cheie this.
De exemplu, să folosim metoda forEach() pentru a calcula pătratele numerelor dintr-un array:
const numbers = [1, 2, 3, 4, 5, 6];
numbers.forEach(n =>
console.log("Pătraul numărului ", n, "este", n * n)
);Metoda forEach() primește ca parametru o funcție, care are un singur parametru - elementul curent al array-ului iterat. În corpul funcției, se pot efectua diverse operații asupra acestui element.
Iată rezultatul afișat în consolă al programului:
Pătratul numărului 1 este 1
Pătratul numărului 2 este 4
Pătratul numărului 3 este 9
Pătratul numărului 4 este 16
Pătratul numărului 5 este 25
Pătratul numărului 6 este 36Transformarea array-ului cu map()
Metoda map() este similară cu metoda forEach, ea primește aceiași parametri:
map(callbackFn)
map(callbackFn, thisArg)Primul parametru - de asemenea, o funcție de tip callback, căreia i se furnizează elementul curent, indexul acestuia și referința la array. Cel de-al doilea parametru - valoarea pentru cuvântul cheie this în interiorul funcției de tip callback. Cu toate acestea, metoda map() returnează un nou array cu rezultatele operațiilor asupra elementelor array-ului.
De exemplu, să aplicăm metoda map() pentru a calcula pătratele numerelor din array:
const numbers = [ 1, 2, 3, 4, 5, 6];
const squares = numbers.map(n => n * n);
console.log(squares); // [1, 4, 9, 16, 25, 36]Funcția furnizată metodei map() primește elementul curent al array-ului, efectuează operațiile asupra acestuia și returnează o anumită valoare. Această valoare este apoi adăugată în noul array rezultat, numit squares.
Căutare în array
Metoda find() returnează primul element al array-ului care îndeplinește o anumită condiție. În calitate de parametru, metoda find() primește o funcție condiție:
const numbers = [1, 2, 3, 5, 8, 13, 21, 34];
// obținem primul element care este mai mare de 10
let found = numbers.find(n => n > 10 );
console.log(found); // 13În acest caz, obținem primul element care este mai mare de 10. Dacă nu se găsește niciun element care să îndeplinească condiția, atunci este returnat undefined.
Similar, metoda findLast() returnează ultimul element care îndeplinește condiția:
const numbers = [1, 2, 3, 5, 8, 13, 21, 34];
// obținem ultimul element care este mai mic ca 10
let found = numbers.find(n => n < 10 );
console.log(found); // 8Metoda findIndex() primește, de asemenea, o funcție condiție și returnează indexul primului element din array care îndeplinește această condiție:
const numbers = [1, 2, 3, 5, 8, 13, 21, 34];
// obținem indexul primului element care este mai mare de 10
let foundIndex = numbers.findIndex(n => n > 10 );
console.log(foundIndex); // 5Dacă elementul nu este găsit, este returnat numărul -1.
Similar, metoda findLastIndex() returnează indexul ultimului element care îndeplinește condiția:
const numbers = [1, 2, 3, 5, 8, 13, 21, 34];
// obținem indexul ultimului element care este mai mic de 10
let foundIndex = numbers.findLastIndex(n => n < 10 );
console.log(foundIndex); // 4Metoda flat() și transformarea array-ului
Metoda flat() simplifică array-ul, având în vedere nivelul specificat de înțelegere a înglobării elementelor:
const people = ["Tom", "Bob", ["Alice", "Kate", ["Sam", "Ann"]]];
const flattenPeople = people.flat();
console.log(flattenPeople); // ["Tom", "Bob", "Alice", "Kate", ["Sam", "Ann"]]Adică, metoda flat() efectuează o conversie a elementelor din array-urile înglobate în array-ul de pe cel mai înalt nivel. Cu toate acestea, observăm că elementele array-ului de pe cel de-al doilea nivel de înțelegere au fost mutate în array-ul de pe primul nivel de înțelegere, dar rămân în continuare înglobate într-un array. Motivul este că metoda flat() este aplicată implicit doar asupra array-urilor înglobate la primul nivel. Cu toate acestea, putem furniza metodei un nivel specific de înțelegere:
const people = ["Tom", "Bob", ["Alice", "Kate", ["Sam", "Ann"]]];
const flattenPeople = people.flat(2);
console.log(flattenPeople); // ["Tom", "Bob", "Alice", "Kate", "Sam", "Ann"]with()
Uneori este necesar să modifici un element dintr-un array, dar totuși să păstrezi starea veche a array-ului. Metoda with() creează automat o copie a vechiului array, schimbă elementul în această copie și returnează un nou array cu elementul modificat:
const people = ["Tom", "Bob", "Sam"];
const modified = people.with(0, "Tomas"); // modificăm "Tom" în "Tomas"
console.log(people); // ["Tom", "Bob", "Sam"] - array-ul inițial nu a fost modificat
console.log(modified); // ["Tomas", "Bob", "Sam"] - copia a fost modificatăMetoda reduce
Metoda reduce permite reducerea tuturor valorilor unui array la o singură valoare, care este returnată de către metoda. Ca parametru, metoda primește o funcție cu 4 parametri:
function (prev,current, curIndex, array){ .... }Parametri:
- prev: elementul anterior (în mod inițial, primul element)
- current: elementul curent (în mod inițial, al doilea element)
- curIndex: indexul elementului curent
- array: array-ul pentru care este apelată funcția
Aplicați metoda reduce() pentru a găsi suma unui array de numere:
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((prev,current) => prev +=current);
console.log(sum); // 15În acest caz, în metoda reduce() este transmisă funcția (prev, current) => prev += current, care adună elementul anterior cu cel curent și returnează suma lor.
O altă formă a metodei reduce() primește doi parametri. Al doilea parametru este valoarea inițială de la care începe calculul:
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((prev,current) => prev +current, 10);
console.log(sum); // 25În acest caz, valoarea inițială a lui prev va fi 10.
Dacă metoda reduce parcurge elementele array-ului de la început (de la stânga la dreapta), atunci metoda reduceRight() face acest lucru în ordine inversă - de la dreapta la stânga:
const numbers = [1, 2, 3, 4, 5];
const reduced1 = numbers.reduce((prev,current) => prev +=current.toString());
console.log(reduced1); // 12345
const reduced2 = numbers.reduceRight((prev,current) => prev +=current.toString());
console.log(reduced2); // 54321Combinația de metode
La nevoie, putem să combinăm mai multe operații într-un lanț de metode. De exemplu, avem un array de utilizatori:
function Person(name, age){
this.name = name;
this.age = age;
}
const people = [
new Person("Tom", 38), new Person("Kate", 31),
new Person("Bob", 42), new Person("Alice", 34),
new Person("Sam", 25)
];Vom afișa din array-ul people numele tuturor utilizatorilor care au vârsta mai mare de 33 de ani:
const isAgeMoreThan33 = (p)=>p.age > 33;
const getPersonName = (p)=>p.name;
const printPersonName = (p)=>console.log(p);
// Obținem din obiectul Person un șir de caractere cu numele
const view = people
.filter(isAgeMoreThan33)
.map(getPersonName)
.forEach(printPersonName);