Az Önhöz hasonló olvasók támogatják a MUO-t. Amikor a webhelyünkön található linkek használatával vásárol, társult jutalékot kaphatunk.

Az emelés egy JavaScript-mechanizmus, amely lehetővé teszi a változók és funkciók elérését, mielőtt inicializálná őket. Egy ilyen nyilatkozat felemelése hatékonyan a hatókörének csúcsára helyezi azt.

Tudjon meg mindent arról, hogyan működik az emelés a JavaScriptben, és hogyan kezelheti a legjobban, hogy elkerülje a hibákat a kódban.

Emelési változók Var, let és const

Az emelés azért lehetséges, mert a JavaScript a JIT (Just-in-Time) fordítási rendszert használja, amely átvizsgálja a kódot, hogy azonosítsa az összes változót a megfelelő hatókörükben.

A JIT fordító ezután a változódeklarációk összes példányát a hatókörük tetejére emeli fordításkor. A JavaScript csak a változók deklarációit emeli ki, inicializálásukat nem.

A változók viselkedése felhúzáskor attól függ, hogy melyik kulcsszóval deklaráltad őket, mivel minden kulcsszó eltérően viselkedik.

var

Hozzáférés egy inicializálatlan változóhoz, amelyet a var kulcsszó visszatér határozatlan. Például:

konzol.log (foo); // határozatlan
var foo = 2;

A fenti kód naplózza határozatlan mert hív console.log mielőtt inicializálná a változót.

A JavaScript fordító az előző kódblokkot így nézi meg:

var foo;
konzol.log (foo); // határozatlan
foo = 2;

Az emelés során a változók engedelmeskednek a a JavaScript hatókörének szabályai. A Javascript csak a hatókör tetejére emeli a változót, amelyben deklarálta. Ha megpróbálja naplózni egy változó értékét a deklarált hatókörén kívül, az a ReferenceError. Például, ha egy változót deklarál egy függvényen belül, az nem lesz látható azon a hatókörön kívül:

funkciómyFunction() {
konzol.log (foo); // határozatlan
var foo = 10;
}
myFunction();
konzol.log (foo); // ReferenceError: a foo nincs megadva

Ha megpróbál hozzáférni egy változóhoz a hatókörén kívül, az a ReferenceError.

let és const

Szerint a MDN dokumentációt hagyja és const emelés, A JavaScript a következővel deklarált változókat is felemeli hagyja és const kulcsszavakat. Azonban ellentétben a változókkal deklarált var kulcsszó, nem inicializálják őket határozatlan érték.

Például:

funkciómyFunction() {
konzol.log (foo); // határozatlan
konzol.log (sáv); // ReferenceError: Nem lehet elérni a 'sávot' inicializálás előtt
konzol.log (baz); // ReferenceError: Nem lehet elérni a „baz” fájlt inicializálás előtt
var foo = 5;
hagyja bár = 10;
const baz = 15;
}
myFunction();

Nem érheti el a let és const kulcsszavakkal deklarált változókat, mielőtt értékkel inicializálná őket.

Emelési funkciók

A JavaScript emelők a változókhoz hasonlóan működnek. A változókhoz hasonlóan ez is attól függ, hogyan deklarálja őket. Például a JavaScript a függvénydeklarációkat a függvénykifejezésektől eltérően emeli ki.

A függvénydeklaráció névvel deklarált függvény, míg a függvénykifejezés olyan függvény, amelynek nevét elhagyhatja. Például:

funkciófoo() {
// függvény deklaráció
}
const bár = () => {
// függvény kifejezés
}

A JavaScript funkciódeklarációkat emel, de nem függvénykifejezéseket. Például:

foo(); // 5
rúd(); // TypeError: a bar() nem függvény
// Funkciónyilatkozat
funkciófoo() {
konzol.log(5);
}
// Funkciókifejezés
var bár = funkciókifejezés() {
konzol.log(10);
};

Ez a kód hív foo mielőtt deklarálja és függvényként inicializálja, de továbbra is naplózza 5 a konzolhoz. Azonban próbál hívni rúd eredménye a TypeError.

Emelés kezelése

Ha tisztában van az emeléssel és a helytelen kezelés esetén fellépő lehetséges hibákkal, hosszú órákig tartó hibakeresést takaríthat meg. Íme néhány módja az emelés kezelésének.

Változók deklarálása a függvényeken belül

Deklaráljon változókat a hozzájuk férő függvényeken belül. Ezt nem mindig tudja megtenni, mivel szükség lehet egy globális változóra, amelyet több függvényen belül is elérhet. Tehát győződjön meg arról, hogy csak akkor deklarálja a változókat globálisan, ha valóban szükséges.

Változók deklarálása let vagy const

Mindig használja az let és const kulcsszavak helyett a var kulcsszó a változók deklarálásakor. Ez a gyakorlat akkor hasznos, ha lokális változókat deklarál egy függvényen belül. A megfelelő módok ismerete változók deklarálása JavaScriptben csökkenti a kódban fellépő emelés okozta hibák esélyét.

A hatókörük tetején lévő változók deklarálása

Deklarálja az összes változót a megfelelő hatókörük tetején, minden más utasítás előtt. Ezzel biztosítható, hogy a JavaScript-fordítónak ne kelljen felemelnie ezeket a változókat, hogy elérje őket.

Szigorú mód használata

A szigorú mód JavaScript mód amely szabályozza a rossz szintaxist, optimalizálja a kód futási idejét, és megtiltja a JavaScript lazán beírt szintaxisával való visszaélést azáltal, hogy fordítási hibákat dob ​​fel.

Például „hanyag módban” az emelés miatt hozzáférhet egy változóhoz az inicializált függvényen kívül, még akkor is, ha nem volt deklarálva:

myFunction();
konzol.log (foo); // 20
funkciómyFunction() {
 foo = 20; 
}

A fenti kódblokkban a JavaScript automatikusan deklarálja foo és a globális hatókör tetejére emeli, figyelmen kívül hagyva azt a hatókört, amelyben inicializálta.

Szigorú móddal javíthatja ezt a viselkedést, és hibát jelezhet, ha a függvény hatókörén kívül próbálja elérni a változót.

A szigorú üzemmód nem hagyja abba az emelést. Ehelyett megakadályozza az emelés leginkább zavaró és hibás formáit. Továbbra is fontos megérteni az általános koncepciót és az emelés mögötti szabályokat, még a szigorú módú biztonsági háló használata esetén is.

A szigorú mód globális szintű bekapcsolásához deklarálja a szintaxist a szkriptfájl tetején:

"használatszigorú"; // vagy "használatszigorú'

A szigorú mód függvényszintű beállításához deklarálja a szintaxist a függvénytörzs tetején az utasítások előtt:

funkciómyStrictFunction() {
 "használatszigorú";
}

Ha egy függvényszinten szigorú módot deklarál, a beállítás csak az adott függvényen belüli utasításokra vonatkozik.

A szigorú mód globális szintű deklarálása megakadályozza a változókhoz való hozzáférést a megfelelő hatókörükön kívül:

"használatszigorú";
myFunction();
konzol.log (foo); // ReferenceError: a foo nincs megadva
funkciómyFunction() {
 foo = 20; 
}

Ha a szigorú mód be van kapcsolva, a JavaScript-fordító aktiválódik myFunction() hatókörének tetejére a nem deklarált változó nélkül.

Ismerje meg, mi befolyásolja az emelést

Az emelés meglehetősen egyedi a JavaScriptben, és nagyon zavaró viselkedés lehet, ha körbetekerné a fejét. Ez hatással lehet a változókra és a függvényekre, de van mód arra, hogy megakadályozzuk, ha szükséges.

Számos tényező befolyásolhatja az emelést, ezért a legjobb, ha elkerüli a változó vagy funkció emelését a kódban.