5 tipp a JavaScript-tömbök optimalizálásához

Számos módszer használható a JavaScript-tömbök optimalizálására a jobb teljesítmény és hatékonyság érdekében. A JavaScript egyik leggyakrabban használt adatszerkezete a tömb. Sok fejlesztő népszerű választása, mert annyira rugalmas és könnyen használható.

A tömbök azonban gyorsan a teljesítmény szűk keresztmetszetévé válhatnak, ha nem megfelelően használja őket. Íme öt módszer a JavaScript-tömbök optimalizálására és a kód általános teljesítményének növelésére.

1. Használja a Spread Operatort

Létrehozhat egy új tömböt, amely egy másik elemeit tartalmazza a spread operátorral, ami három pont (...).

A spread operátor két tömböt kombinálhat, így:

const tömb1 = [1, 2, 3];
const tömb2 = [4, 5, 6];
const concatenatedArray = [...tömb1, ...tömb2];
konzol.log (concatenatedArray); // Kimenet: [1, 2, 3, 4, 5, 6]

Ebben az esetben a spread operátor két tömböt – tömb1-et és tömb2-t – összefűz egy új tömbbe, az úgynevezett

concatenatedArray. Az eredményül kapott tömb tartalmazza a tömb1 összes elemét, majd a tömb2 összes elemét.

A spread operátor egy új tömböt is létrehozhat több elemmel. Például:

const originalArray = [1, 2, 3];
const newArray = [...originalArray, 4, 5];
konzol.log (newArray); // Kimenet: [1, 2, 3, 4, 5]

Létrehoz egy új tömböt, melynek neve newArray a spread operátor alkalmazásával. Tartalmazza az eredeti tömb összes elemét, majd a 4-es és 5-ös elemet. Ha nagy tömbökkel foglalkozunk, a spread operátor hatékonyabb lehet, mint a hasonló módszerek concat() vagy nyom(). Ezenkívül olvashatóbbá és tömörebbé teszi a kódot.

Hatékonyabban használhatja a JavaScript tömbjeit a spread operátorral, ami megkönnyíti a több elemet tartalmazó új tömb létrehozását is.

2. Kerülje a Delete operátor használatát

Az objektum tulajdonságait a delete operátorral törölheti. Bár a törlés segítségével eltávolíthat egy tömbelemet, ez nem ajánlott, mert üres vagy üres helyeket hagyhat a tömbben. Ez befolyásolhatja a tömb teljesítményét, amikor iterál rajta, vagy megpróbál hozzáférni bizonyos elemekhez.

Ahelyett, hogy a töröl operátort, fontolja meg a toldás módszer. Ez a módszer eltávolíthatja egy tömb elemeit, és egy új tömböt ad vissza üres szóközök nélkül.

Használhatja a toldás módszerrel a következő módon:

const originalArray = [1, 2, 3, 4, 5];
// Távolítsa el az elemet a 2. indexnél
const newArray = originalArray.splice(2, 1);

Ez a példa eltávolítja a 2. indexű elemet a eredetiArray splice módszerrel. Az újonnan létrehozott tömb (új tömb) tartalmazza azt az elemet, amelyet a toldás eltávolított. A 2. indexű elem már nincs jelen a eredetiArray, és nincs üres szóköz a tömbben.

3. Használjon beírt tömböket

A JavaScriptben bináris adatokkal dolgozhat gépelt tömbök használatával. Ezek a tömbök lehetővé teszik az alapul szolgáló memória közvetlen manipulálását, és rögzített hosszúságú elemeket használnak; hatékonyabbak, mint a szabványos tömbök.

Íme egy példa a gépelt tömb létrehozására:

const myArray = újInt16Array(4);
konzol.log (myArray); // Kimenet: Int16Array [0, 0, 0, 0]

Ez a példa egy teljesen újat hoz létre Int16Array négy nullára állított elemmel.

Int8Array, Int16Array, Int32Array, Uint8Array, Uint16Array, Uint32Array, Float32Array, és Float64Array mind példák a beírt tömbök típusaira. Minden osztályozás egy bizonyos típusú párosított információhoz kapcsolódik, és ennek megfelelő bájtmérettel rendelkezik.

Íme egy példa arra, hogyan kell használni a Float32Array.

const myArray = újFloat32Array([1.0, 2.0, 3.0, 4.0]);
konzol.log (myArray); // Kimenet: Float32Array [1, 2, 3, 4]

Ez a példa egy újat hoz létre Float32Array négy elem 1.0, 2.0, 3.0 és 4.0 értékre állítva.

A gépelt tömbök különösen hasznosak nagy adathalmazokkal végzett munka vagy matematikai számítások végrehajtása során. Sokkal gyorsabbak lehetnek, mint a szabványos tömbök, mivel lehetővé teszik a memória közvetlen kezelését.

A gépelt tömbök használata megkönnyíti a bináris adatokkal való munkát és a matematikai számításokat, így optimalizálhatja JavaScript-kódját.

4. Minimalizálja az iterációkat

Gyakori, hogy JavaScript ciklust használjon tömbön keresztül ismételni. Mindenesetre a nagy tömbökön történő iteráció a teljesítmény szűk keresztmetszetét jelentheti. Csökkentse az iterálások számát a JavaScript tömbökön, hogy optimalizálja azokat.

Ennek egyik módja a használata szűrő, térkép, és csökkenteni hagyományos hurkok helyett. Ezek a stratégiák javítják a kódvégrehajtást, és gyakran gyorsabbak, mint egy tömbön keresztüli manuális iteráció.

A térképmódszert a következő módon használhatja:

const originalArray = [1, 2, 3, 4, 5];
// Minden elemet megszoroz 2-vel
const newArray = originalArray.map((elem) => elem * 2)

Ebben az esetben a kód létrehoz egy új nevű tömböt newArray térképes módszerrel. A leképezési módszer az egyes összetevőkre egy függvényt alkalmaz eredetiArray és az eredményeket egy új tömbben adja vissza.

5. Használja a strukturáló szintaxist

A JavaScript strukturáló funkciója a JavaScript egy hatékony funkciója, amely lehetővé teszi értékek tömbökből és objektumokból történő kinyerését. Ez a módszer hatékonyabbá teszi a kódot, mivel kevesebb változó-hozzárendelést és kevesebb tömbhozzáférést hajt végre. A strukturálás használatának előnyei kiterjednek az olvashatóságra és a csökkentett írási erőfeszítésekre.

A következő szemlélteti, hogyan lehet értékeket kivonni egy tömbből destrukturálás segítségével:

const myArray = [1, 2, 3, 4, 5];
// Az első és a harmadik elem strukturálása
const [első,, harmadik] = myArray;
konzol.log (első); // Kimenet: 1
konzol.log (harmadik); // Kimenet: 3

Ez a példa destrukciót használ az első és a harmadik elem kinyerésére myArray. A tömb első elemének értékét rendeli hozzá a első változót, és a harmadik elem értékét a harmadik változó. Ha üres helyet hagy a destrukciós mintában, kihagyja a második elemet.

A függvény argumentumokkal történő destrukturálást is használhatja az értékek tömbökből való kinyerésére:

funkciómyFunction([első perc]) {
konzol.log (első);
konzol.log (második);
}
const myArray = [1, 2, 3, 4, 5];
myFunction (myArray); // Kimenet: 1\n2

Ez a példa egy ún. függvényt határoz meg myFunction amely egy tömböt vesz paraméternek. Ezután destrukturálást használ a tömb első és második elemének naplózására a konzolra.

Optimalizálja a JavaScript-tömböket a gyorsabb alkalmazásokhoz

A JavaScript-tömbök egyszerűsítése elengedhetetlen a kód teljesítményének javításához. Ezzel jelentősen megnövelheti alkalmazásai válaszkészségét és sebességét.

Ahhoz, hogy a legtöbbet hozza ki a tömbökből, ne felejtse el használni a spread operátort, kerülje a delete operátort, használjon gépelt tömböket, csökkentse az iterációk számát, és használjon destructuring. Ezenkívül próbálja meg felmérni a kód teljesítményét, és alapvető fejlesztéseket hajtson végre, hogy garantálja az alkalmazás zökkenőmentes működését.

A tömbök optimalizálásával gyorsabb és megbízhatóbb alkalmazásokat hozhat létre, és jobb felhasználói élményt biztosít.