Otkrijte tajne efikasnog kodiranja! Postanite brži, produktivniji i zadovoljniji JavaScript programer uz pomoć ovih ključnih funkcija koje se često koriste u jeziku.
JavaScript je prisutan svuda, bilo da se radi o pozadinskom programiranju, frontend razvoju, pa čak i svemirskim brodovima. To je izuzetno fleksibilan jezik (podržava kako funkcionalne paradigme, tako i klasičan pristup zasnovan na klasama). Njegova sličnost sa jezicima iz porodice „C“ olakšava prelazak programera sa drugih platformi.
Ako želite da unapredite svoje JavaScript veštine, savetujem vam da naučite, vežbate i ovladate sledećim ključnim funkcijama koje su dostupne u samom jeziku. Iako nisu sve ove funkcije striktno „neophodne“ za rešavanje problema, u nekim situacijama mogu vam značajno olakšati rad, dok u drugim mogu smanjiti količinu koda koju morate da napišete.
map()
Bilo bi neoprostivo pisati članak o važnim JavaScript funkcijama, a ne pomenuti map()! Zajedno sa filter() i reduce(), map() čini sveto trojstvo. Ove funkcije ćete konstantno koristiti tokom svoje karijere, tako da zaslužuju posebnu pažnju. Krenimo redom, počevši od map().
map() je jedna od onih funkcija koje najviše zbunjuju ljude koji uče JavaScript. Zašto? Ne zato što je inherentno komplikovana, već zato što se način na koji ova funkcija radi zasniva na konceptima iz funkcionalnog programiranja. S obzirom na to da nismo u velikoj meri izloženi funkcionalnom programiranju – naše škole i industrija su preplavljene objektno orijentisanim jezicima – naš um ima tendenciju da ove koncepte interpretira na pogrešan način.
JavaScript je mnogo funkcionalniji nego što je objektno orijentisan, iako se u modernim verzijama ovog jezika ovaj aspekt često skriva. Ali, to je tema za neku drugu priliku. Dakle, da se vratimo na map().
map() je vrlo jednostavna funkcija. Ona se primenjuje na niz i omogućava nam da transformišemo svaki element niza u nešto drugo, stvarajući pritom novi niz. Način na koji se transformacija vrši definiše se pomoću druge funkcije, koja je po konvenciji anonimna.
To je sve! Možda će vam trebati malo vremena da se naviknete na sintaksu, ali to je u suštini ono što se dešava u map() funkciji. Zašto bismo mogli koristiti map()? To zavisi od toga šta pokušavamo da postignemo. Na primer, zamislimo da smo beležili temperaturu svakog dana prošle nedelje i sačuvali je u obliku niza. Međutim, sada smo saznali da instrumenti nisu bili baš precizni i da su prikazivali temperaturu koja je za 1,5 stepeni niža od prave.
Ovu ispravku možemo da uradimo pomoću map() funkcije na sledeći način:
const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23]; const correctedWeeklyReadings = weeklyReadings.map(reading => reading + 1.5); console.log(correctedWeeklyReadings); // daje [ 21.5, 23.5, 22, 20.5, 22.5, 23, 24.5 ]
Još jedan praktičan primer dolazi iz sveta React-a, gde je kreiranje liste DOM elemenata iz niza uobičajena praksa. Dakle, nešto poput sledećeg je vrlo često:
export default ({ products }) => {
return products.map(product => {
return (
<div className="product" key={product.id}>
<div className="p-name">{product.name}</div>
<div className="p-desc">{product.description}</div>
</div>
);
});
};
Ovde imamo funkcionalnu React komponentu koja prima listu proizvoda kao svoj prop. Iz te liste (niza), zatim kreira listu HTML div elemenata, pretvarajući praktično svaki objekat proizvoda u HTML. Originalni objekat proizvoda ostaje nepromenjen.
Možete da tvrdite da map() nije ništa drugo do unapređena for petlja i bili biste potpuno u pravu. Ali primetite da čim iznesete taj argument, vaš objektno orijentisani um preuzima kontrolu. Ove funkcije i njihovo obrazloženje potiču iz funkcionalnog programiranja, gde se uniformnost, kompaktnost i elegancija visoko cene.
filter()
filter() je veoma korisna funkcija koju ćete koristiti iznova i iznova u različitim situacijama. Kao što samo ime sugeriše, ova funkcija filtrira niz na osnovu pravila/logike koju definišete i vraća novi niz koji sadrži samo elemente koji zadovoljavaju ta pravila.
Hajde da ponovo upotrebimo naš primer sa vremenom. Pretpostavimo da imamo niz koji sadrži maksimalne temperature za svaki dan prošle nedelje. Sada želimo da saznamo koliko je dana bilo hladnije. „Hladnije“ je subjektivan pojam, pa recimo da tražimo one dane u kojima je temperatura bila ispod 20 stepeni. To možemo da uradimo pomoću filter() funkcije na sledeći način:
const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23];
const colderDays = weeklyReadings.filter(dayTemperature => {
return dayTemperature < 20;
});
console.log("Total colder days in week were: " + colderDays.length); // 1
Imajte na umu da anonimna funkcija koju prosleđujemo funkciji filter() mora da vrati Bulovu vrednost: true ili false. Na taj način filter() zna da li da uključi taj element u filtrirani niz. Slobodni ste da napišete bilo koju količinu kompleksne logike unutar ove anonimne funkcije. Možete da upućujete API pozive, da čitate korisničke unose, itd., sve dok osiguravate da na kraju vraćate Bulovu vrednost.
Ovo je važna napomena koju sam primoran da dodam na osnovu svog iskustva kao JavaScript programer. Bilo da je u pitanju nemar ili pogrešni temelji, mnogi programeri prave suptilne greške u svojim programima kada koriste filter(). Hajde da ponovo napišemo prethodni kod, dodajući grešku:
const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23];
const colderDays = weeklyReadings.filter(dayTemperature => {
return dayTemperature < 20;
});
if(colderDays) {
console.log("Yes, there were colder days last week");
} else {
console.log("No, there were no colder days");
}
Da li ste primetili nešto? Sjajno, ako jeste! Uslov if na kraju proverava colderDays, što je zapravo niz! Iznenadićete se koliko često ljudi prave ovu grešku kada se trude da ispoštuju rokove ili kad su loše raspoloženi. Problem sa ovim uslovom je u tome što je JavaScript u mnogo čemu čudan i nedosledan jezik, a „istinitost“ stvari je jedan od tih aspekata. Dok [] == true vraća false, što vas navodi na pomisao da gornji kod nije pokvaren, realnost je da unutar if uslova, [] se procenjuje kao true! Drugim rečima, kod koji smo napisali nikada neće reći da prošle nedelje nije bilo hladnijih dana.
Ispravka je vrlo jednostavna, kao što je dato u kodu pre gornjeg koda. Proveravamo colderDays.length, što nam garantuje ceo broj (nula ili više) i na taj način konzistentno radi u logičkim poređenjima. Imajte na umu da će filter() uvek vraćati niz, prazan ili neprazan, tako da se možemo osloniti na to i sa sigurnošću pisati svoja logička poređenja.
Ovo je bio duži obilazni put nego što sam planirao, ali greške poput ove vredi istaći u deset hiljada reči, velikim slovima ako je potrebno. Nadam se da vas ovo neće „ujesti“ i da će vam uštedeti stotine sati napornog rada u pronalaženju grešaka!
reduce()
Od svih funkcija u ovom članku, kao i u standardnoj JavaScript biblioteci, reduce() je među vodećima po tituli „zbunjujuće i čudne“. Iako je ova funkcija veoma važna i rezultira elegantnim kodom u mnogim situacijama, većina JavaScript programera je izbegava i umesto toga radije piše detaljniji kod.
Razlog je – i ovde ću biti iskren – reduce() je teško razumeti, kako u smislu koncepta, tako i u smislu izvršenja. Kada pročitate njegov opis, pročitali ste ga nekoliko puta, a ipak sumnjate da li ste ga dobro razumeli. A kada ga vidite u akciji i pokušate da zamislite kako funkcioniše, vaš mozak se uvija u hiljadu čvorova!
Ne plašite se. Funkcija reduce() nije ni blizu po složenosti, recimo, B+ stablima i njihovim algoritmima. Samo se ovakva logika retko sreće u svakodnevnom poslu prosečnog programera.
Dakle, pošto sam vas prvo zaplašio, a odmah zatim vam rekao da se ne brinete, želeo bih da vam konačno pokažem šta je ova funkcija i zašto bi nam tačno mogla biti potrebna.
Kao što i samo ime kaže, reduce() se koristi za smanjenje nečega. Ono što smanjuje je niz, a ono na šta smanjuje dati niz je jedna vrednost (broj, niz, funkcija, objekat, bilo šta). Jednostavnije rečeno, reduce() transformiše niz u jednu vrednost. Imajte na umu da povratna vrednost iz reduce() nije niz, kao što je slučaj sa map() i filter(). Razumevanje ovoga je već pola bitke.
Sada je nekako očigledno da ako želimo da transformišemo (smanjimo) niz, moramo da obezbedimo neophodnu logiku. Na osnovu vašeg dosadašnjeg iskustva kao JavaScript programera, najverovatnije ste već pretpostavili da to radimo pomoću funkcije. Ta funkcija se naziva reduktorska funkcija, i ona čini prvi argument funkcije reduce(). Drugi argument je početna vrednost, kao što je broj, string itd. (uskoro ću objasniti šta je, dođavola, ta „početna vrednost“).
Na osnovu našeg dosadašnjeg razumevanja, možemo da kažemo da poziv funkcije reduce() izgleda ovako: array.reduce(reducerFunction, startingValue). Hajde sada da se pozabavimo suštinom cele stvari: reduktorskom funkcijom. Kao što je već utvrđeno, reduktorska funkcija je ono što govori funkciji reduce() kako da konvertuje niz u jednu vrednost. Potrebna su joj dva argumenta: promenljiva koja se ponaša kao akumulator (ne brinite, objasniću i taj deo) i promenljiva za čuvanje trenutne vrednosti.
Znam, znam… bilo je previše terminologije za jednu funkciju koja nije ni obavezna u JavaScriptu! I zato ljudi beže od reduce(). Ali ako je naučite korak po korak, ne samo da ćete je razumeti, već ćete je i ceniti dok postajete bolji programer.
Vratimo se na temu. „Početna vrednost“ koja se prosleđuje funkciji reduce() je… pa, početna vrednost za proračun koji želite da koristite. Na primer, ako ćete da obavljate množenje u reduktorskoj funkciji, početna vrednost od 1 ima smisla. Za sabiranje, možete da počnete od 0 i tako dalje.
Sada pogledajmo potpis za reduktorsku funkciju. Reduktorska funkcija koja se prosleđuje reduce() ima sledeći oblik: reducerFunction(accumulator, currentValue). „Akumulator“ je samo fancy naziv za promenljivu koja prikuplja i čuva rezultat proračuna. To je isto kao da koristite promenljivu koja se zove total da sabirate sve elemente u nizu, koristeći nešto poput total += arr[i]. Evo kako se reduktorska funkcija primenjuje u reduce(): akumulator se inicijalno postavlja na početnu vrednost koju ste dali, a zatim se elementi niza posećuju jedan po jedan, vrši se proračun, a rezultat se čuva u akumulator, i tako dalje…
Dakle, šta je „trenutna vrednost“ u reduktorskoj funkciji? To je ista ideja koju biste zamislili ako bih od vas zatražio da prođete kroz niz: uzeli biste promenljivu da počne od indeksa nula i pomerali je korak po korak napred. Dok to radite, ako bih od vas zatražio da naglo stanete, našli biste se na jednom od elemenata niza, zar ne? To je ono što podrazumevamo pod trenutnom vrednošću: to je vrednost promenljive koja se koristi za predstavljanje elementa niza koji je trenutno u razmatranju (zamislite da prelazite preko niza ako vam to pomaže).
Uz sve ovo rečeno, vreme je da vidimo jednostavan primer i da vidimo kako se sav ovaj žargon spaja u stvarni poziv funkcije reduce(). Recimo da imamo niz koji sadrži prvih n prirodnih brojeva (1, 2, 3… n) i da nas zanima da pronađemo faktorijel od n. Znamo da da bismo pronašli n!, jednostavno moramo da pomnožimo sve brojeve, što nas dovodi do ove implementacije:
const numbers = [1, 2, 3, 4, 5]; const factorial = numbers.reduce((acc, item) => acc * item, 1); console.log(factorial); // 120
Puno toga se dešava u ova samo tri reda koda, pa hajde da to raščlanimo jedan po jedan u kontekstu (vrlo duge) rasprave koju smo vodili do sada. Kao što je očigledno, numbers je niz koji sadrži sve brojeve koje želimo da pomnožimo. Zatim pogledajte poziv numbers.reduce(), koji kaže da početna vrednost za acc treba da bude 1 (jer ne utiče niti uništava bilo koje množenje). Zatim proverite telo reduktorske funkcije, `(acc, item) => acc * item`, koje jednostavno kaže da povratna vrednost za svaku iteraciju preko niza treba da bude taj element pomnožen sa onim što je već u akumulatoru. Iteracija i stvarno čuvanje množenja eksplicitno u akumulatoru je ono što se dešava iza kulisa i jedan je od glavnih razloga zašto je reduce() takav kamen spoticanja za JavaScript programere.
Zašto koristiti reduce()?
To je zaista sjajno pitanje i, da budem iskren, nemam siguran odgovor. Sve što reduce() može da uradi, može se uraditi i kroz petlje, forEach() itd. Međutim, te tehnike rezultiraju sa mnogo više koda, što otežava čitanje, posebno ako ste u žurbi. Zatim postoji briga za nepromenljivost: sa reduce() i sličnim funkcijama, možete biti sigurni da vaši originalni podaci nisu izmenjeni. Ovo samo po sebi eliminiše čitave klase grešaka, posebno u distribuiranim aplikacijama.
Konačno, reduce() je daleko fleksibilnija, u smislu da akumulator može biti objekat, niz ili čak funkcija ako je potrebno. Isto važi i za početnu vrednost i druge delove poziva funkcije – skoro sve može da uđe i skoro sve može da izađe, tako da postoji izuzetna fleksibilnost u dizajniranju koda za višekratnu upotrebu.
Ako još uvek niste ubeđeni, i to je sasvim u redu. Sama JavaScript zajednica je oštro podeljena oko „kompaktnosti“, „elegancije“ i „moći“ reduce(), tako da je u redu ako je ne koristite. Ali, obavezno pogledajte neke primere pre nego što odlučite da je izbegavate.
some()
Recimo da imate niz objekata, gde svaki objekat predstavlja osobu. Želite da znate da li u nizu ima osoba starijih od 35 godina. Imajte na umu da nema potrebe da brojite koliko takvih osoba ima, a kamoli da preuzimate njihovu listu. Ono što je ovde bitno je ekvivalent „jedan ili više“ ili „najmanje jedan“.
Kako to uraditi?
Da, možete da kreirate promenljivu zastavicu i da pređete preko niza da biste rešili ovaj problem na sledeći način:
const persons = [
{
name: 'Person 1',
age: 32
},
{
name: 'Person 2',
age: 40
},
];
let foundOver35 = false;
for (let i = 0; i < persons.length; i ++) {
if(persons[i].age > 35) {
foundOver35 = true;
break;
}
}
if(foundOver35) {
console.log("Yup, there are a few people here!")
}
Problem? Po mom mišljenju, kod je previše sličan C ili Java. „Opširan“ je još jedna reč koja mi pada na pamet. Iskusni JS programeri bi možda pomislili „ružan“, „užasan“ itd. I s pravom, rekao bih. Jedan od načina da se ovaj kod poboljša je da se koristi nešto poput map(), ali čak i tada rešenje je pomalo nespretno.
Ispostavilo se da imamo prilično urednu funkciju pod nazivom some(), koja je već dostupna u samom jeziku. Ova funkcija radi na nizovima i prihvata prilagođenu funkciju „filtriranja“, vraćajući Bulovu vrednost true ili false. U suštini, ona radi ono što smo pokušavali da uradimo prethodnih nekoliko minuta, samo vrlo sažeto i elegantno. Evo kako možemo da je koristimo:
const persons = [
{
name: 'Person 1',
age: 32
},
{
name: 'Person 2',
age: 40
},
];
if(persons.some(person => {
return person.age > 35
})) {
console.log("Found some people!")
}
Isti unos, isti rezultat kao i ranije. Ali primetite ogromno smanjenje koda! Obratite pažnju i na to koliko je kognitivno opterećenje drastično smanjeno jer više nema potrebe da raščlanjujemo kod red po red, kao da smo sami interpretator! Kod se sada skoro čita kao prirodni jezik.
every()
Baš kao i some(), imamo još jednu korisnu funkciju pod nazivom every(). Kao što već možete da pretpostavite, i ova funkcija vraća Bulovu vrednost, u zavisnosti od toga da li svi elementi niza prolaze dati test. Naravno, test koji treba proći se u većini slučajeva isporučuje kao anonimna funkcija. Pošteduću vas bola oko toga kako bi naivna verzija koda mogla da izgleda, pa evo kako se koristi every():
const entries = [
{
id: 1
},
{
id: 2
},
{
id: 3
},
];
if(entries.every(entry => {
return Number.isInteger(entry.id) && entry.id > 0;
})) {
console.log("All the entries have a valid id")
}
Kao što je očigledno, kod proverava sve objekte u nizu da li imaju ispravno svojstvo ID-a. Definicija „važećeg“ zavisi od konteksta problema, ali kao što vidite, za ovaj kod sam uzeo u obzir nenegativne cele brojeve. Još jednom vidimo koliko je kod jednostavan i elegantan za čitanje, što je jedini cilj ove (i sličnih) funkcija.
includes()
Kako proveravate postojanje podstringova i elemenata niza? Pa, ako ste kao ja, brzo posežete za indexOf(), a zatim tražite dokumentaciju da biste saznali njegove moguće povratne vrednosti. To je velika neprijatnost, a povratne vrednosti je teško zapamtiti. Ali postoji lepa alternativa koju možemo iskoristiti: includes(). Upotreba je jednostavna kao i samo ime, a rezultatni kod je izuzetno efektivan. Imajte na umu da se poklapanje vrši pomoću includes() i da je osetljivo na velika i mala slova, ali pretpostavljam da je to ono što svi ionako intuitivno očekujemo. A sada, vreme je za malo koda!
const numbers = [1, 2, 3, 4, 5];
console.log(numbers.includes(4));
const name = "Ankush";
console.log(name.includes('ank')); // false, jer je prvo slovo malo
console.log(name.includes('Ank')); // true, kao što se očekivalo
Međutim, nemojte previše očekivati od ove skromne metode:
const user = {a: 10, b: 20};
console.log(user.includes('a')); // greška, jer objekti nemaju "includes" metod
Ne može da „zaviri“ unutar objekata jer jednostavno nije definisan za objekte. Ali hej, znamo da radi na nizovima, pa možda možemo da napravimo neke trikove ovde… 🤔
const persons = [{name: 'Phil'}, {name: 'Jane'}];
persons.includes({name: 'Phil'});
Dakle, šta se dešava kada pokrenete ovaj kod? Ne „eksplodira“, ali rezultat je takođe razočaravajući: false. Ovo zapravo ima veze sa objektima, pokazivačima i načinom na koji JavaScript vidi i upravlja memorijom, što je tema za sebe. Ako želite da zaronite dublje, slobodno se upustite (možda počnite ovde), ali ja ću se zaustaviti ovde.
Gornji kod možemo naterati da se ponaša ako ga prepišemo na sledeći način, ali u ovom trenutku, po mom mišljenju, to već pomalo postaje šala:
const phil = {name: 'Phil'};
const persons = [phil, {name: 'Jane'}];
persons.includes(phil); // true
Ipak, pokazuje da možemo da napravimo da includes() radi na objektima, tako da pretpostavljam da to nije potpuna katastrofa.
slice()
Pretpostavimo da imamo string i da vas zamolim da vratite njegov deo koji počinje sa „r“ i završava se sa „z“ (stvarni karakteri nisu važni). Kako biste to uradili? Možda biste kreirali novi string i koristili ga za čuvanje svih potrebnih znakova i vraćanje istih. Ili, ako ste kao većina programera, dali biste mi dva indeksa niza: jedan koji označava početak podniza, drugi koji označava kraj.
Oba ova pristupa su dobra, ali postoji koncept koji se zove sečenje, a koji nudi zgodno rešenje u takvim situacijama. Srećom, ne postoji nikakva nejasna teorija koju treba slediti. Sečenje znači tačno ono što zvuči – kreiranje manjeg niza/stringa od datog, slično kao što kreiramo kriške voća. Da vidimo na šta mislim, uz pomoć jednostavnog primera:
const headline = "And in tonight's special, the guest we've all been waiting for!";
const startIndex = headline.indexOf('guest');
const endIndex = headline.indexOf('waiting');
const newHeadline = headline.slice(startIndex, endIndex);
console.log(newHeadline); // guest we've all been
Kada koristimo slice(), JavaScriptu dostavljamo dva indeksa – onaj gde želimo da započnemo sečenje i drugi gde želimo da stanemo. Kvačica sa slice() je u tome što završni indeks nije uključen u konačni rezultat, zbog čega vidimo da reč „waiting“ nedostaje u novom naslovu u gornjem kodu.
Koncepti poput sečenja su izraženiji u drugim jezicima, posebno u Python-u. Ako pitate te programere, oni će reći da ne mogu da zamisle život bez ove funkcionalnosti, i to s pravom, s obzirom na to da jezik pruža vrlo urednu sintaksu za sečenje.
Sečenje je uredno i izuzetno zgodno, i nema razloga da ga ne koristite. Takođe, to nije sintaktički „šećer“ koji donosi kaznu za performanse, jer stvara plitke kopije originalnog niza/stringa. Za JavaScript programere, toplo preporučujem da se upoznaju sa slice() i da ga dodaju u svoj arsenal!
splice()
Metoda splice() zvuči kao rođak slice(), i na neki način možemo tvrditi da jeste. Obe metode kreiraju nove nizove/stringove od originalnih, sa jednom malom, ali važnom razlikom – splice() uklanja, menja ili dodaje elemente, ali i modifikuje originalni niz. Ovo „uništenje“ originalnog niza može da stvori ogromne probleme ako niste pažljivi ili ne razumete duboke kopije i reference. Pitam se šta je sprečavalo programere da koriste isti pristup kao i za slice() i ostave originalni niz netaknutim, ali pretpostavljam da možemo biti blagonakloni prema jeziku koji je nastao za samo deset dana.
Bez obzira na moje žalbe, pogledajmo kako splice() funkcioniše. Pokazaću primer u kojem uklanjamo nekoliko elemenata iz niza, jer je ovo najčešća upotreba koju ćete naći za ovu metodu. Takođe ću se uzdržati od davanja primera sa dodavanjem i umetanjem, jer se oni lako mogu pronaći i takođe su jednostavni.
const items = ['eggs', 'milk', 'cheese', 'bread', 'butter']; items.splice(2, 1); console.log(items); // [ 'eggs', 'milk', 'bread', 'butter' ]
Poziv splice() iznad kaže: počnite od indeksa 2 (tj. trećeg mesta) niza i uklonite jedan element. U datom nizu, „cheese“ je treći element, tako da se uklanja iz niza i niz elemenata se skraćuje, kao što se očekivalo. Usput, uklonjeni elementi se vraćaju pomoću splice() u obliku ili niza, tako da smo, da smo hteli, mogli da uhvatimo „cheese“ u promenljivu.
Po mom iskustvu, indexOf() i splice() imaju veliku sinergiju – pronađemo indeks elementa i zatim ga uklonimo iz datog niza. Međutim, imajte na umu da to nije uvek najelegantnija metoda i da je često korišćenje ključeva za objekat (ekvivalent heš mape) mnogo brže.
shift()
shift() je zgodna metoda i koristi se za uklanjanje prvog elementa niza. Imajte na umu da se ista stvar može uraditi sa splice(), ali shift() je malo lakši za pamćenje i intuitivan kada sve što treba da uradite je da „odsečete“ prvi element.
const items = ['eggs', 'milk', 'cheese', 'bread', 'butter']; items.shift() console.log(items); // [ 'milk', 'cheese', 'bread', 'butter' ]
unshift()
Baš kao što shift() uklanja prvi element iz niza, unshift() dodaje novi element na početak niza. Njegova upotreba je isto tako jednostavna i kompaktna:
const items = ['eggs', 'milk'];
items.unshift('bread')
console.log(items); // [ 'bread', 'eggs', 'milk' ]
Uz to, ne mogu da se suzdržim i da ne upozorim one koji su novi u „igri“: za razliku od popularnih metoda push() i pop(), shift() i unshift() su izuzetno neefikasni (zbog načina na koji funkcionišu osnovni algoritmi). Dakle, ako radite na velikim nizovima (recimo, 2000+ elemenata), previše ovih poziva funkcija može da zaustavi vašu aplikaciju.
fill()
Ponekad morate da promenite nekoliko elemenata u jednu vrednost ili čak da „resetujete“ ceo niz. U takvim situacijama, fill() vas štedi od korišćenja petlji i grešaka koje mogu proizaći iz toga. Može se koristiti za zamenu nekih ili svih elemenata niza datom vrednošću. Pogledajmo par primera:
const heights = [1, 2, 4, 5, 6, 7, 1, 1]; heights.fill(0); console.log(heights); // [0, 0, 0, 0, 0, 0, 0, 0] const heights2 = [1, 2, 4, 5, 6, 7, 1, 1]; heights2.fill(0, 4); console.log(heights2); // [1, 2, 4, 5, 0, 0, 0, 0]
Ostale funkcije vredne pomena
Iako je gornja lista ono sa čime se većina JavaScript programera sreće i koristi u svojoj karijeri, ona nikako nije potpuna. Postoji mnogo više manjih, ali korisnih funkcija (metoda) u JavaScriptu, da ih nije moguće sve pokriti u jednom članku. Uz to, nekoliko koji mi padaju na pamet su sledeći:
- reverse()
- sort()
- entries()
- flat()
- find()
Ohrabrujem vas da bar bacite pogled na ove funkcije, kako biste imali ideju da ovakve alatke postoje.
Zaključak
JavaScript je veliki jezik, uprkos malom broju osnovnih koncepata koje treba naučiti. Mnoge funkcije (metode) koje su nam dostupne čine većinu te veličine. Međutim, pošto je JavaScript sekundarni jezik za većinu programera, ne zalazimo dovoljno duboko, propuštajući mnoge lepe i korisne funkcije koje nudi. U stvari, isto va