A javascript globális változója nem változik. JavaScript: Változó hatókör. Lokális és globális változók

Utolsó frissítés: 05.04.2018

A JavaScript minden változójának van egy meghatározott hatóköre, amelyen belül működhet.

Globális változók

Minden függvényen kívül deklarált változó globális:

var x = 5; legyen d=8; függvény displaySquare())( var z = x * x; console.log(z); )

Itt az x és d változók globálisak. A programban bárhonnan elérhetők.

De a z változó nem globális, mivel a függvényen belül van definiálva.

Lokális változók

A függvényen belül meghatározott változó lokális:

Függvény displaySquare())( var z = 10; console.log(z); legyen b = 8; console.log(b); )

A z és b változók lokálisak, csak a függvényen belül léteznek. Nem használhatók függvényen kívül:

függvény displaySquare())( var z = 10; console.log(z); ) console.log(z); //hiba, mert z nincs definiálva

Amikor egy függvény befejezi munkáját, a függvényben meghatározott összes változó megsemmisül.

Változók elrejtése

Mi van akkor, ha két változónk van - az egyik globális és a másik helyi -, amelyeknek ugyanaz a neve:

Var z = 89; függvény displaySquare())( var z = 10; console.log(z); // 10 ) displaySquare(); // 10

Ebben az esetben a függvény a közvetlenül a függvényben definiált z változót fogja használni. Vagyis a lokális változó elrejti a globálist.

var vagy let

A let utasítás használatakor minden kódblokk egy új hatókört határoz meg, amelyben a változó létezik. Például definiálhatunk egy változót blokkszinten és függvényszinten egyszerre:

Legyen z = 10; függvény displayZ())( legyen z = 20; ( legyen z = 30; console.log("Block:", z); ) console.log("Funkció:", z); ) displayZ(); console.log("Globális:", z);

Itt a displayZ függvényen belül van egy kódblokk definiálva, amelyben a z változó definiálva van. Elrejti a függvényszinten definiált globális változót és z változót. BAN BEN igazi program block jelenthet beágyazott függvényt, blokkot hurokhoz vagy ha épít. De mindenesetre egy ilyen blokk egy új hatókört határoz meg, amelyen kívül a változó nem létezik.

És ebben az esetben a következő konzol kimenetet kapjuk:

Blokk: 30 Funkció: 20 Globális: 10

A var operátorral nem definiálhatunk azonos nevű változót a függvényben és a függvényen belüli kódblokkban is:

Funkció displaySquare())( var z = 20; ( var z = 30; // Hiba! A z változó már definiálva van console.log("Block:", z); ) console.log("Function:", z) ;)

Ez azt jelenti, hogy a var segítségével egyetlen névvel definiálhatunk változót akár függvényszinten, akár kódblokk szintjén.

Állandók

Minden, ami a let operátorra vonatkozik, vonatkozik a const operátorra is, amely lehetővé teszi állandók definiálását. A kódblokkok határozzák meg az állandók hatókörét, a beágyazott kódblokkon definiált konstansok pedig elrejtik az azonos nevű külső konstansokat:

Állandó z = 10; függvény displayZ())( const z = 20; ( const z = 30; console.log("Block:", z); // 30 ) console.log("Function:", z); // 20 ) displayZ ( ); console.log("Globális:", z); // 10

Nem deklarált változók

Ha nem használjuk ezt a kulcsszót változó definiálásakor egy függvényben, akkor az ilyen változó globális lesz. Például:

Funkció bar())( foo = "25"; ) bar(); console.log(foo); 25

Annak ellenére, hogy a foo változó sehol nincs definiálva a bar függvényen kívül, mégis elérhető a függvényen kívül, külső környezetben.

Más lenne a helyzet, ha nem csak értéket rendelnénk egy változóhoz, hanem definiálnánk is:

Funkció bar())( var foo = "25"; ) bar(); console.log(foo); // hiba

szigorú mód

Globális változók meghatározása a függvényekben ahhoz vezethet, hogy lehetséges hibákat. Ezek elkerülése érdekében használjon szigorú módot:

"szigorúan használd"; függvény bar())( foo = "25"; ) bar(); console.log(foo);

Ebben az esetben a SyntaxError: Unexpected identifier hibaüzenetet kapjuk, ami azt jelzi, hogy a foo változó nincs definiálva.

A szigorú mód beállításának két módja van:

a JavaScript kód elejéhez adja hozzá a "use strict" kifejezést, akkor a szigorú mód minden kódra érvényes lesz

add hozzá a "use strict" kifejezést a függvénytörzs elejéhez, akkor a szigorú mód csak erre a függvényre vonatkozik

Továbbra is tanulmányozzuk a JavaScript függvények témakörét. Itt érintjük a változó hatókör fogalmát. Szorosan kapcsolódik a funkciókhoz, ezért fontos megérteni.

Tanulni kellene (és megkülönböztetni ezeket a fogalmakat) csak egy dolog az, hogy a változók globálisak és lokálisak.

Mik azok a globális változók? Nézzünk egy példát...

var global = 21 ; /* Globális változó létrehozása */

function myFun () /* Hozzon létre egy függvényt, amely egy változót jelenít meg */
{
document.write(global);
}

myFun(); /* A függvény meghívása */

Ebben a példában egy globális változót hoztunk létre, amely globális - most már használhatjuk - például egy függvényen belül, amint ezt maga is láthatja.

Ez a globális változók lényege – egyszer jönnek létre (mondjuk a forgatókönyv elején, ahogy a példában is láttad) majd szükség esetén használjuk a programkódban (tömbökben, függvényekben stb.).

Mik azok a lokális változók? Nézzünk még egyszer egy példát...

function myFun _2 () /* Függvény létrehozása */
{

var local = 42 ;
document.write(local);
}

myFun_2(); /* A függvény meghívása */

Ez a példa egy helyi változó létrehozását szemlélteti: local. Lokális, mert a függvényen belül jön létre. És csak belül használható.

Ha ezt a változót a függvényen kívül próbáljuk megjeleníteni, nem fogunk látni semmit a böngészőablakban.

function myFun _2 () /* Függvény létrehozása */
{

var local = 42 ; /* Helyi változó létrehozása */
document.write(local);
}

document.write(local); /* Megpróbál megjeleníteni egy helyi változót a függvényen kívül */

Ezeken egyszerű példák Megvizsgáltuk a változó hatókör fogalmát a JavaScriptben. Mondjuk el még egyszer a lényegét: ha egy függvényen belül létrehozunk egy változót, akkor az lokális, és csak ezen a függvényen belül tudunk vele dolgozni.

A függvényen kívül létrehozott változókat pedig globálisnak nevezzük, és bárhol használhatók, a függvényen belül is.

Változók

Változók deklarálása

Mielőtt egy változót használhatna a JavaScriptben, deklarálnia kell. A változók deklarálása a használatával történik kulcsszó var így:

Var i; var sum;

A var kulcsszó egyszeri használatával több változót is deklarálhat:

A változók deklarálása kombinálható inicializálásukkal:

Var message = "hello"; var i = 0, j = 0, k = 0;

Ha a var utasításban nincs megadva kezdeti érték, akkor a változó deklarálva van, de a kezdeti értéke definiálatlan marad mindaddig, amíg a program meg nem változtatja.

Ha van tapasztalata statikus adattípusokkal, például C# vagy Java programozási nyelvekkel, észreveheti, hogy a változódeklarációk JavaScript típus deklaráció hiányzik. A JavaScript változói bármilyen típusú értéket tárolhatnak. Például a JavaScriptben lehetséges néhány hozzárendelése változó szám, majd rendelje hozzá a sort ugyanahhoz a változóhoz:

Var i = 10; i = "helló";

A var utasítással ugyanazt a változót többször is deklarálhatjuk. Ha az ismételt deklaráció inicializálót tartalmaz, akkor úgy működik, mint egy normál hozzárendelési utasítás.

Ha egy nem deklarált változó értékét próbálja beolvasni, a JavaScript hibát generál. Az ECMAScript 5 szabvány által biztosított szigorú módban hiba lép fel akkor is, ha egy nem deklarált változóhoz próbálunk értéket rendelni. Azonban történelmileg, és ha nem szigorú módban hajtják végre, ha olyan változóhoz adsz értéket, amely nincs deklarálva var utasítással, a JavaScript létrehozza ezt a változót a globális objektum tulajdonságaként, és nagyjából ugyanúgy fog működni, mint helyesen deklarált változó. Ez azt jelenti, hogy a globális változókat nem kell deklarálni. Ez azonban rossz szokásnak számít, és hibák forrása lehet, ezért mindig próbálja meg deklarálni a változóit a var használatával.

Változó hatókör

A változó hatóköre a program azon része, amelyhez a változó definiálva van. A globális változónak globális hatóköre van – a teljes JavaScript programra van definiálva. Ugyanakkor a függvényen belül deklarált változók csak a függvény törzsében vannak definiálva. Ezeket helyinek nevezik, és helyi hatályuk van. A függvényparamétereket is helyi változóknak tekintjük, amelyek csak az adott függvény törzsében vannak definiálva.

A függvénytörzsön belül a lokális változó elsőbbséget élvez az azonos nevű globális változóval szemben. Ha egy helyi változót vagy függvényparamétert deklarál ugyanazzal a névvel, mint egy globális változót, akkor a globális változó valójában el lesz rejtve:

Var eredmény = "globális"; function getResult() ( var result = "local"; eredményt ad vissza; ); console.log(getResult()); // "helyi" megjelenítése

Globális hatókörű változók deklarálásakor a var utasítás elhagyható, de lokális változók deklarálásakor mindig a var utasítást kell használni.

Változók és állandók a JavaScriptben. Változók deklarálása és értékek hozzárendelése. Globális és lokális változók. Állandók használata

Változók deklarálása JavaScriptben

A JavaScriptben a változónevek állhatnak betűkből, számokból, $ és _ jelből, és a változó neve nem kezdődhet számmal. Ne feledje, hogy a JavaScript megkülönbözteti a kis- és nagybetűket, és az a1 és az A1 változók különbözőek. A cirill betű használata nem javasolt, bár lehetséges.
A JavaScript változói a var kulcsszóval vannak deklarálva:

Var Peremennaya_1 var Peremennaya_2

Deklaráció nélkül nem ajánlott változókat használni JavaScriptben. Ez lehetséges, de hibákhoz vezethet.

Értékek hozzárendelése a változókhoz

Érték hozzárendelése a deklarált változókhoz JavaScriptben:

Peremennaya_1 = 25 Peremennaya_2 = "A hozzárendelt szöveg egyenes idézőjelek között van"

A deklaráció után azonnal értéket rendelhet a változókhoz:

Var Peremennaya_1 = 25 var Peremennaya_2 = "A hozzárendelt szöveg egyenes idézőjelek között van"

A JavaScriptben lévő változó értéke a program végrehajtása során változhat. Amikor szöveget írunk egy változóba, azt egyenes idézőjelbe kell tenni.

Lokális és globális változók

Ha egy változó egy függvényen belül van deklarálva, akkor az lokális, és csak ezen a függvényen belül lesz elérhető (látható). Amikor egy függvény kilép, a JavaScript helyi változói megsemmisülnek, így az azonos nevű változókat különböző függvényekben használhatja.

Ha egy változó a függvényeken kívül van deklarálva, akkor az globális és elérhető (látható) az oldalon belüli összes függvényben. Az oldal bezárásakor a globális változók megsemmisülnek a JavaScriptben.

Konstansok a JavaScriptben

A konstansok célja, hogy megkönnyítsék a kóddal való munkát, amikor ismétlődő értékeket vagy kifejezéseket kell használnia. A konstans értékét elég egyszer beállítani, és a programjaink kódjába beillesztve tetszés szerint használhatjuk. A JavaScript nem rendelkezik kulcsszóval a konstansok deklarálására, a konstansok helyett a rendszeres változókat használnak. Az állandók és a változók megkülönböztetésére általában jelölik nagybetűvel, szükség esetén aláhúzással:

Var DRUG_CHELOVEKA = "Kutya"

A konstansra adott példa nem teljesen teljes, mivel a „kutya” szót már könnyű megjegyezni, és beilleszteni a kívánt helyre. A JavaScriptben konstansokat használhat összetettebb értékek rögzítésére és beillesztésére, például nehezen megjegyezhető kódok, karakterkészletek, hosszú szöveg, webcímek, címek Email, telefonszámok, különféle együtthatók.

A JavaScriptben az állandók átírhatók változókká, de ha ezt megteszi, akkor az állandók jelentése elveszik.

Ez a négy részből álló oktatóanyag minőségi JavaScript kód írásával foglalkozik, amely könnyen karbantartható és fejleszthető, még akkor is, ha hosszú idő után vissza kell térnie a projekthez.

Írjon kódot azzal a várakozással, hogy támogatni kell

Hibák szoftver saját költségük van. Költségüket a javításukhoz szükséges időben fejezik ki. A nyilvánosan indított projektek hibái különösen költségesek. Nagyon jó, ha azonnal ki tudja javítani a hibákat, amikor a kódszerkezet még friss a memóriájában, és gyorsan megtalálja a problémás területet. De ha más feladatokra váltott, és már elfelejtette egy bizonyos kód funkcióit, akkor a projekthez való visszatéréshez:

• Ideje tanulmányozni és megérteni a problémát.
• Ideje megérteni a problémát okozó kódot.

Egy másik probléma, amely a nagy projekteket vagy vállalatokat érinti, hogy a hibákat nem az a személy javítja ki, aki létrehozza azokat (és gyakran nem is az a személy, aki a projektben megtalálja). Ezért a kód megértéséhez szükséges idő csökkentése kritikus kérdéssé válik, függetlenül attól, hogy Ön írta-e a kódot egy ideje, vagy egy másik fejlesztő írta a csapatában. A kérdésre adott válasz jelentősen befolyásolja mind a projekt pénzügyi eredményét, mind a fejlesztők elégedettségi szintjét, mert néha jobb mindent új módon csinálni, mint órákat, napokat tölteni a régi, érthetetlen kód karbantartásával.

Egy másik tény a szoftverfejlesztéssel kapcsolatban, hogy általában tovább tart olvasás kódot, nem annak létrehozását. A probléma kezdeti megfogalmazásakor a fejlesztő koncentrál és elmerül a kérdésben, majd leül, és egyetlen este alatt jelentős kódot tud létrehozni. Akkor a kód valószínűleg működik, de természetesen szoftver termékek, olyan helyzetek merülnek fel, amelyek a kód ismételt átdolgozását teszik szükségessé. Például:

• A hibákat észleli.
• Új funkciókkal bővül a projekt.
• Az alkalmazást új környezetben kell elindítani (például új böngésző jelent meg).
• A kód célja megváltozik.
• A kódot teljesen át kell írni vagy át kell vinni egy másik architektúrára vagy programozási nyelvre.

Ennek eredményeként több munkaórát kódírással, több munkanapot pedig olvasással kell tölteni. Ezért a könnyen karbantartható kód létrehozása kritikus fontosságú egy alkalmazás sikeréhez.

A könnyen karbantartható kód a következő jellemzőkkel rendelkezik:

• Könnyen olvasható.
• Jól felépített, és a részek összhangban vannak egymással.
• Kiszámítható.
• Úgy tűnik, egy ember írta.
• Dokumentált.

A globális változók használatának minimalizálása

A JavaScript függvényeket használ a kontextus kezelésére. A függvényeken belül deklarált változók lokálisak, és nem érhetők el a függvényeken kívül. A globális változókat a függvényeken kívül deklarálják, vagy egyszerűen deklaráció nélkül használják.

Minden JavaScript-környezet rendelkezik egy globális objektummal, amelyet a függvényeken kívül használnak. Minden létrehozott globális változó a globális objektum tulajdonságává válik. A böngészőkben a kényelem kedvéért a globális objektumon van egy ablak nevű további tulajdonság, amely (általában) magára a globális objektumra mutat. A következő kód példát mutat globális változók létrehozására és elérésére a böngésző környezetben:

Var myglobal = "helló"; console.log(myglobal); // "hello" console.log(window.myglobal); // "hello" console.log(window["myglobal"]); // "hello" console.log(this.myglobal); // "Helló"

Problémák a globális változókkal

A globális változókkal az a probléma, hogy az alkalmazás vagy az oldal JavaScript-kódjában végig elérhetők lesznek. A globális névtérben vannak, és mindig van esély az elnevezési ütközésekre, ahol az alkalmazás két különböző része azonos nevű, de eltérő célú globális változókat határoz meg.

Ezenkívül a weboldal általában más fejlesztők által írt kódot tartalmaz. Például:

• Egyéb JavaScript-könyvtárak.
• Reklámpartnerek forgatókönyvei.
• Kód a felhasználók követéséhez és elemzéséhez.
• Különféle widgetek, gombok és bővítmények.

Tegyük fel, hogy az egyik harmadik féltől származó szkriptben egy globális változó van definiálva, amelyet például eredménynek neveznek. Ezután egy másik globális változót definiál az egyik függvényében, és eredménynek nevezi. Ennek eredményeként az eredményváltozó utolsó deklarációja felülírja az elsőt, és előfordulhat, hogy a harmadik féltől származó szkript leáll.

Ezért a különböző kódok egyetlen oldalon történő sikeres kombinálásához fontos, hogy a lehető legkevesebb globális változót használjunk. Ebben a kérdésben a var direktíva használata a változók deklarálásakor jelentős szerepet játszik.

Sajnos nagyon könnyű akaratlanul is létrehozni egy globális változót a JavaScriptben annak két jellemzője miatt. Először is használhat egy változót anélkül, hogy deklarálná. Másodszor, a JavaScript rendelkezik az implikált globális definícióval, ami azt jelenti, hogy minden nem deklarált változó a globális objektum tulajdonságává válik (és megfelelően deklarált globális változóként lesz elérhető). Például:

Sum(x, y) függvény ( // rossz: implikált globális eredmény = x + y; eredményt ad vissza; )

Ebben a kódban az eredményváltozót deklaráció nélkül használjuk. A kód jól működik, de a függvény meghívása után egy másik eredményváltozót kapunk a globális névtérben, ami problémákhoz vezethet.

A minimalizálási szabály a változók meghatározása a var direktívával. Az alábbiakban a sum() függvény továbbfejlesztett változata látható:

Sum(x, y) függvény ( var eredmény = x + y; visszatérési eredmény; )

Egy másik rossz lehetőség az implikált globálisok létrehozására az érték-hozzárendelés láncolása a var deklaráción belül. A következő példában az a változó lokális, a b változó pedig globális lesz, ami valószínűleg nem a kódkészítő szándéka:

// rossz, ne használja a foo() függvényt ( var a = b = 0; // ... )

Ha meglep, hogy mi történik, akkor ez jobbról balra történő számítások kérdése. Először a b = 0 kifejezés kerül végrehajtásra, ezért a b változó nem kerül deklarálásra. A kifejezés visszatérési értéke 0 lesz, és hozzá van rendelve egy új a helyi változóhoz, amelyet a var direktíva deklarál. A változók e definíciója egyenértékű a következő jelöléssel:

Var a = (b = 0);

Ha már deklarálta a változókat, akkor a láncolt ábrázolás jól működik, és nem hoz létre nem kívánt globális változókat:

foo() függvény ( var a, b; a = b = 0; // mindkét változó lokális )

Egy másik ok a globális változók használatának elkerülésére a kódhordozhatóság. Ha a kódot egy másik környezetben tervezi futtatni, akkor a globális változók felülírhatják azokat az objektumokat, amelyek nem az eredeti környezetben találhatók (így úgy tűnhet, hogy a használt név biztonságos).

Az elfelejtett var deklaráció mellékhatása

Van egy kis különbség az explicit módon meghatározott és az implikált globális változók között. Lehetőség van egy változó törlésére a delete operátor használatával:

• A (függvényeken kívüli programban létrehozott) var deklarációval deklarált globális változó nem törölhető.
• A deklaráció nélkül létrehozott implikált globális változó (függetlenül attól, hogy hol készült) törölhető.

Technikailag az implikált globális változó a globális objektum tulajdonsága, nem pedig változó. A tulajdonságok törölhetők a delete operátorral, de a változók nem:

// három globális változó meghatározása var global_var = 1; global_novar = 2; // rossz (függvény () ( global_fromfunc = 3; // rossz )()); // Törölni próbáljuk a global_var; // hamis törlés global_novar; // igaz törlés global_fromfunc; // igaz // A global_var törlési típusának ellenőrzése; // global_novar "szám" típusa; // "undefined" typeof global_fromfunc; // "határozatlan"

Globális objektum elérése

A böngészőkben a globális objektum bárhol elérhető a kódban az ablak tulajdonságon keresztül (hacsak nem tesz valami különlegeset vagy váratlant, például egy ablak nevű helyi változót deklarál). De más környezetekben ez a kényelmi tulajdonság más módon is elérhető (vagy akár egyáltalán nem is elérhető a programozó számára). Ha az ablakazonosító használata nélkül kell hozzáférnie a globális objektumhoz, akkor a következő módszert használhatja a beágyazott függvénynévtér bármely szintjén:

Var global = (függvény () ( ezt adja vissza; )());

Így a globális objektumhoz mindig hozzá lehet férni, hiszen a függvényként (és nem új deklarációval rendelkező konstruktorként) meghívott függvényen belül ez mindig a globális objektumra mutat.

Egyetlen deklarációs sablon var

Egyetlen var deklaráció használata a függvény tetején nagyon hasznos gyakorlat. Ennek a módszernek a következő előnyei vannak:

• Egyetlen helyet biztosít a függvény összes helyi változójának deklarálásához.
• Megakadályozza a logikai hibákat, ha egy változót a deklarálás előtt használnak.
• Segít megjegyezni a lokális változók deklarálását, és ezáltal csökkenti a globális változók számát.

Egy var deklarációt tartalmazó sablon így néz ki:

Func() függvény ( var a = 1, b = 2, sum = a + b, myobject = (), i, j; // Függvénykód... )

Egyetlen var deklarációt használ több változó deklarálására, vesszővel elválasztva. Kiváló kiegészítés lenne, ha deklarálásakor a változókat forrásadatokkal inicializálnánk. Ez megakadályozza a logikai hibákat (alapértelmezés szerint minden inicializálatlan változó definiálatlanra van állítva), és javítja a kód olvashatóságát. Ha később áttekinti a kódot, hogyan határozhatja meg egy változó célját a alapján kezdő érték(például azonnal nyilvánvaló lesz, hogy ez egy objektum vagy egész szám).

Változódeklarációval is végrehajthat műveletet, például összeg = a + b az előző példakódból. Egy másik működő példa a DOM-manipuláció. A DOM-elemekre vonatkozó hivatkozásokat a helyi változókhoz rendelheti, amikor deklarálja:

Az updateElement() függvény ( var el = document.getElementById("eredmény"), style = el.style; // műveletek végrehajtása az el és a style függvényekkel... )

Emelés: probléma a szórt var deklarációkkal

A JavaScript lehetővé teszi több var deklarációt bárhol egy függvényben, és ezek ugyanúgy működnek, függetlenül az elhelyezéstől. Ez a funkció„emelkedésként” ismert. Ez a viselkedés logikai hibákhoz vezethet, ha változót használ, majd deklarálja azt későbbi függvénykódhoz. JavaScript esetén, mivel egy változó ugyanabban a névtérben van (ugyanabban a függvényben), feltételezhető, hogy deklarált, még akkor is, ha a var direktíva előtt használják őket. Például

// rossz myname = "global"; // globális változó függvény func() ( alert(myname); // "undefined" var myname = "local"; alert(myname); // "local" ) func();

BAN BEN ebben a példában Az alert() első hívása várhatóan „globális”, a második pedig a „local” üzenetet produkálja. Ésszerű elvárás, mert az első híváskor a myname helyi változó nincs deklarálva, és a függvénynek a myname globális változót kell használnia. De a valóságban a dolgok másként működnek. Az alert() első hívása „undefined”-et ad vissza, mert a myname deklarált helyi változóként kezeli a függvényben (bár a deklaráció később érkezik). Minden változódeklaráció a függvény tetejére kerül. Ezért az ilyen típusú hibák elkerülése érdekében minden változót deklarálnia kell a függvény tetején.

Az előző példa úgy fog működni, mintha a következőképpen lett volna megvalósítva:

Myname = "globális"; // globális változó függvény func() ( var myname; // ugyanaz, mint -> var myname = undefined; alert(myname); // "undefined" myname = "local"; alert(myname); // " local" ) func();

Érdemes megemlíteni, hogy a kód tényleges megvalósítása bonyolultabb. A kódfeldolgozásnak két szakasza van. Az első szakasz változókat, függvénydeklarációkat és formális paramétereket hoz létre, és meghatározza a kontextust. A második szakasz végrehajtja a kódot, kiértékeli a függvényeket, és minősíthetetlen azonosítókat (nem deklarált változókat) hoz létre. De gyakorlati használatra használhatja az emelés fogalmát, amely jól leírja a kód viselkedését.