Továbbra is tanulmányozzuk a JavaScript függvények témakörét. Itt érintjük a változók hatókörének 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 - hogy a változók globálisak és lokálisak.

Mik azok a globális változók? Vegyü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ük még egyszer a 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 a local helyi változó létrehozását mutatja be. Helyi, mert a . És csak belül használható.

Ha ezt a változót a függvényen kívül próbáljuk megjeleníteni, akkor 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); /* Próbáld meg megjeleníteni a helyi változót a függvényen kívül */

Ezekkel az egyszerű példákkal megvizsgáltuk a JavaScript változó hatókörének fogalmát. Még egyszer elmondjuk 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.

A JavaScriptben három hatókör létezik: globális, függvényhatókör és blokkhatókör. Egy változó hatóköre a terület forráskód program, amelyben a változók és függvények láthatók és használhatók. A globális hatókört felső szintű kódnak is nevezik.

Globális változók

A függvényen vagy blokkon kívül deklarált változót globális változónak nevezzük. A globális változó bárhol elérhető a forráskódban:

varnum = 5; függvény foo() ( console.log(num); ) foo(); // 5 console.log(num); // 5 ( konzol. log(szám); // 5 )

Lokális változók

A függvényen belül deklarált változót lokális változónak nevezzük. A lokális változó bárhol elérhető annak a függvénynek a törzsében, amelyben deklarálták. Egy lokális változó minden alkalommal jön létre, amikor egy új függvényt hívnak, és megsemmisül, amikor kilép (amikor a függvény véget ér):

függvény foo() ( var num = 5; console.log(num); ) foo(); // 5 console.log(typeof num); // határozatlan

A lokális változó elsőbbséget élvez az azonos nevű globális változóval szemben, ami azt jelenti, hogy a lokális változót használják a függvényen belül a globális helyett:

var x = "globális"; // Globális változó függvény checkscope() ( var x = "local"; // A globális document.write(x) névvel megegyező helyi változó; // Helyi változót használunk, nem globális ) checkscope(); // => "helyi" Próbálja »

Változók blokkolása

A blokkon belül deklarált változó a kulcsszó let , az úgynevezett blokk . A blokkváltozó bárhol elérhető a blokkon belül, amelyben deklarálták:

letnum = 0; ( let num = 5; console.log(num); // 5 ( let num = 10; console.log(num); // 10 ) console.log(num); // 5 ) console.log(num) ; // 0

Újrahirdetés

Ha újra deklarál egy változót azonos névvel (ugyanabban a hatókörben) a var kulcsszóval, akkor semmi sem fog történni:

Vara = 10; var a; konzolnapló(a); // 10

Ha az újradeklarációt inicializálás követi, akkor az ilyen utasítás úgy működik, mint egy új érték normál hozzárendelése:

Vara = 10; var a = 5; // Ugyanaz, mint a = 5; konzolnapló(a); 5

Ha újra deklarál egy változót azonos néven (ugyanabban a hatókörben) a let kulcsszóval, hiba lép fel:

Vara = 10; legyen a; // Hiba.

Táblázatok lánca

Tekintsük a következő példát:

varnum = 5; function foo() ( var num2 = 10; function bar() ( var num3 = 15; ) )

Ebben a kódban három hatókör található: globális hatókör, foo() függvény hatóköre és bar() függvény hatóköre. A num változó és a foo() függvény a globális hatókörben van definiálva. A foo() függvény hatókörében van definiálva a num2 változó és a bar() függvény, és elérhető benne a globális hatókörből származó num változó is. A bar() függvény hatóköre egy num3 változót tartalmaz, amely csak a bar() függvényen belül érhető el. A bar() függvény hatókörében a másik két hatókör változói is elérhetők, mert azok a szülőjei. A példa hatóköre az alábbi ábrán látható:

Az ábrán a különböző szkópok különböző színű téglalapokkal láthatók. A hatóköri lánc belső hatóköre mindenhez hozzáférhet a külső hatóköröktől, de a külső hatókörök nem férhetnek hozzá semmihez a belső hatókörökből.

A távcső lánc megrendelve. Az értelmező a hatóköri láncban kifelé keres azonosítókat, nem befelé. Ez azt jelenti, hogy a névkeresés azon a hatókörön kezdődik, ahol az azonosítóhoz hozzáfértek. Ha megtalálja az azonosító nevét, a keresés leáll. Ha a név nem található az aktuális hatókörben, akkor a keresés a következő (külső) hatókörben történik, és így tovább, így annak hatókörének az azonosítója kerül felhasználásra, amelyben megtalálták. Ha az azonosító egyik hatókörben sem található, a JavaScript hibát generál:

var str = "globális"; varnum = 5; function foo() ( var str = "local"; // A str num = 10 lokális változó használata; // A num globális változó használata // alert(x); // Hiba. Az x változó nem tartozik semmilyen hatókörbe ) foo( ) ; alert(str); // "globális" alert(num); // 10

Ha a függvénytörzsben egy nem deklarált változóhoz rendelünk értéket, akkor a függvényhíváskor, ha nincs azonos nevű változó a globális hatókörben, akkor egy új globális változó jön létre:

függvény foo() ( szám = 2; ) foo(); // Létrehozott egy új globális változót num alert(num); 2

Emelje fel a hirdetéseket

A JavaScriptben a deklarált változók bárhol elérhetők a hatókörükhöz képest, ami azt jelenti, hogy a változók még a kódban való deklarálásuk előtt láthatók. A JavaScript ezen tulajdonságát informálisan emelésnek nevezik: a kód úgy viselkedik, mintha a változódeklarációkat implicit módon (inicializálás nélkül) a hatókörük legtetejére emelnék.

Vegye figyelembe a következő kódrészletet:

var str = "globális"; function foo() ( alert(str); // undefined var str = "local"; alert(str); // "local" ) foo();

A kódot nézve azt gondolhatnánk, hogy az első riasztásnak a "global" karakterláncot kell kiadnia, mert az str helyi változó deklarációja még nem került végrehajtásra. A tényleges kimenet azonban nem definiált. A deklaráció emelésnek köszönhetően a fenti funkció egyenértékű az alábbi megvalósítással, amelyben a változó deklaráció a függvény tetejére kerül:

Függvény foo() ( var str; // Egy helyi változó deklarációja az alert(str) függvény elején; // Itt elérhető, de nincs inicializálva str = "local"; // Itt inicializálódik alert( str); // És itt van a várt értéke - "helyi")

Ugyanez vonatkozik a globális hatókörre is, az alul deklarált változó felül érhető el:

Alert(szám); // undefined var num = 10; figyelmeztetés(szám); // 10

Jó napot JavaScript rajongók és hűséges előfizetőim. A mai bejegyzésben részletesen elmondom, hogyan jönnek létre a globális és lokális változók JavaScriptben. Mindenképpen definíciókat adok a fontosabb kifejezésekre, beszélek a változók deklarálásának és inicializálásának jellemzőiről, leírom, mi az a hatókör, és hogyan működnek benne a létrehozott elemek.

Mindez a legalapvetőbb, alapvető nyelvtudásra vonatkozik. Anélkül, hogy mindezt megértené, nem fog tudni továbblépni és fejleszteni programozási készségeit js-ben. Ezenkívül a kulcsfogalmak nem csak ezen a specializáción, hanem általában az IT területen is hasznosak lesznek. Nos, kezdjük!

Mi a változó és hogyan jön létre?

A változó a programozási nyelv olyan eleme, amely alatt egy memóriaterületet foglalnak le, és amelyben bizonyos értékeket tárolnak.

Nagyon sok változó lehet, és mindegyiknek egyedi névvel kell rendelkeznie.

Kétféle változó létezik: globális és lokális. Különbségük csak a változók eltérő hatókörében van. Tehát a globális elemek a teljes kódban láthatók, és a helyi elemek csak egy kis területen láthatók, ahol deklarálták őket.

Egyébként próbáld már az első naptól kezdve, az első kódodtól kezdve logikus és érthető néven elnevezni az elemeket. Mert ha súlyos programokkal dolgozik, bizonyos idő elteltével nem fog emlékezni arra, hogy mit jelent például az „aa1” vagy a „perem3”.

És a címnek semmi értelme! Még mindig fél a baj, elvégre nem is olyan nehéz megérteni az írásaidat. És mit fog tenni, ha azt a feladatot kapja, hogy egy másik programban olyan feladatokat fejezzen be, amelyekről korábban nem is hallott? Ilyen nevekkel a szoftver implementáció elemzése sok hasznos időt vesz igénybe.

Elolvastam a jelölést, most térjünk vissza a változók deklarációjához.

Változó létrehozásához először meg kell írnia a var kulcsszót, majd magát a nevet. Így néz ki:

var text = "Üdv, felhasználó!"

Ezt követően a szöveg "var" nélkül érhető el:

text = "új szöveg."

Ebben az esetben az érték felülíródik.

A jobb megértés érdekében vegyünk egy példát, amely egyetlen változót hoz létre. Értékére utalni fogunk az újraírás előtt és után.

1 2 3 4

var text = "Üdv, felhasználó!"; figyelmeztetés(szöveg); // kiírja a "Hello, user!" text="Új szöveg!"; figyelmeztetés(szöveg); // kiírja az "Új szöveget!"

var text = "Üdv, felhasználó!"; figyelmeztetés(szöveg); // kiírja a "Hello, user!" text="Új szöveg!"; figyelmeztetés(szöveg); // kiírja az "Új szöveget!"

A globális objektumok jellemzői

A js kódban minden létrehozott objektum globális és lokálisra van osztva. Fentebb elmagyaráztam, mi a különbség köztük. Most nézzük meg közelebbről a globális objektumokat.

Ezek mind olyan függvények és változók, amelyek a kód fő vásznában vannak deklarálva, pl. nem egyes funkciókon belül. A js-ben mindegyik automatikusan a globális objektum tulajdonságaivá válik, amely kifejezetten elérhető a böngészőkben az ablak szó alatt. Vegyünk egy példát.

var ár = 145; // globális változó létrehozása

figyelmeztetés(ablak.ár); // válasz: 145

Eddig minden egyszerű, de készülj fel a buktatókra. Néha, ha nem ismeri a változóértékek mentésének és felülírásának sajátosságait, nagyon fontos paramétereket is felülírhat. Az ilyen hibákat meglehetősen nehéz nyomon követni, és fordítóprogramok segítségével lehetetlen megtalálni. Szóval jól nézd meg következő anyag.

Buktatók és terjedelem

A probléma jobb megértése érdekében először bemutatok egy kis programot, ahol létrehozok egy lokális változót a függvényben, majd a határain kívül - egy globálist.

függvényteszt() ( p = 2; return p; ) alert(p); // undefined p = "fontos szöveg"; figyelmeztetés(p); // kiírja a "fontos szöveget" teszt(); // az alert(p) függvény meghívása; // nyomtat 2

Kezdetben a tesztfüggvényben inicializáltam egy lokális változót 2-es értékkel, majd létrehoztam egy globális szöveges változót, amely néhány fontos adatot tárol.

És itt felbukkan az a „víz alatti blokk”.

Először is, mivel az elemek létrehozását az elavult JavaScript szabvány szabályai szerint használtam, minden „p” változó csak a hozzárendeléskor jött létre (a var direktíva használatakor a változók azonnal létrejönnek az értékkel undefined, és az inicializálás során a „= » értékkel felülíródik).

Másodszor, ebben az esetben a js egy létező globális változót használ, vagy új globális változót hoz létre, hogy értéket rendeljen az implicit módon létrehozott elemekhez. Ezért a fenti példában a tesztfüggvény meghívása után a globális "p" értéke felül lett írva.

Mindig használja a var kulcsszót az összeomlás elkerülése érdekében. Ezután minden objektum kifejezetten deklarálva lesz, és újak jönnek létre.

Íme a javított példa:

függvényteszt() ( var p = 2; alert (p); return p; ) alert(p); // undefined var p = "fontos szöveg"; figyelmeztetés(p); // kiírja a "fontos szöveget" teszt(); // meghívja a függvényt, ebben az esetben 2 alert(p)-t fog kiírni; // "fontos szöveg" nyomtatása

Most a kód megfelelően működik. Amint láthatja, a helyi "p" hatóköre a tesztfüggvény hatókörén belül van, míg a globálisé a kód többi részében.

Néhány szó az állandókról

Mint minden más programozási nyelvnek, a JavaScriptnek is vannak konstansai. Azok számára, akik nem tudják, mi ez, mellékelek egy definíciót.

A konstans olyan változótípus, amelynek értéke nem változik.

A js szintaktikai szabályai szerint a nevüket mindig kisbetűvel (nagybetűvel) írják. Például,

var MAIN_COLOR = "#fff"

Nem script nyelven technikai eszközökkel, ami az állandót valóban állandóvá tenné. Valójában ezek közönséges változók, amelyek felülírhatók. A szabályok szerint azonban a fejlesztők ezeket az elemeket használják nagybetűvel a névben konstansként és a kód írása során nem változtatja meg az értéküket.

A konstansok fő célja összetett karakterláncok tárolása, fontos számok vagy más értékek, amelyekben az újraíráskor könnyen elgépelhető, vagy semmi esetre sem szabad megváltoztatni, vagy egyszerűsíteni a kódot. Például az állandók tárolhatják a gyakran ismétlődő kéréseket

A változók "tárolóként" szolgálnak az információ tárolására.

Emlékszel az iskolai algebrára?

Emlékszel az iskolai algebrára? x=5, y=6, z=x+y

Emlékszel arra, hogy egy betűt (például x) fel lehet használni egy érték tárolására (például 5), és hogy a fenti információk alapján kiszámíthatod, hogy z értéke 11?

Ezeket a betűket változóknak nevezzük, és a változók értékek (x=5) vagy kifejezések (z=x+y) tárolására használhatók.

JavaScript változók

Csakúgy, mint az algebrában, a JavaScript-változókat értékek vagy kifejezések tárolására használják.

A változónak lehet rövid neve, például x, vagy leíróbb neve, például carname (autónév).

A JavaScript-változónevekre vonatkozó szabályok:

• A változónevek megkülönböztetik a kis- és nagybetűket (y és Y két különböző változó)
• A változóneveknek betűvel vagy aláhúzásjellel kell kezdődniük

Megjegyzés: Mivel a JavaScript megkülönbözteti a kis- és nagybetűket, a változónevek is megkülönböztetik a kis- és nagybetűket.

Példa

Egy változó értéke változhat a szkript végrehajtása során. Egy változóra a nevével hivatkozhat, hogy megjelenítse vagy módosítsa az értékét.

JavaScript-változók deklarálása (létrehozása).

A JavaScriptben a változók létrehozását gyakrabban nevezik változók deklarálásának.

A JavaScript változókat a var kulcsszóval deklarálja:

A fenti javaslatok végrehajtása után x az 5 értéket, a carname pedig a Mercedes értéket fogja tartalmazni.

Megjegyzés: Ha szöveges értéket rendel egy változóhoz, tegye idézőjelek közé.

Megjegyzés: Ha újra deklarál egy változót, nem veszíti el értékét.

JavaScript helyi változók

Belül deklarált változó JavaScript funkciók LOCAL lesz, és csak ezen a funkción belül lesz elérhető. (a változónak helyi hatóköre van).

Az azonos nevű helyi változókat különböző függvényekben deklarálhatja, mert a helyi változókat a rendszer felismeri abban a függvényben, amelyben deklarálták őket.

A lokális változók megsemmisülnek, amikor a függvény kilép.

A funkciókról a későbbi JavaScript leckékben tudhat meg többet.

JavaScript globális változók

A függvényen kívül deklarált változók GLOBÁLISSÁ válnak, és az oldalon található összes szkript és függvény hozzáférhet hozzájuk.

Az oldal bezárásakor a globális változók megsemmisülnek.

Ha egy változót a "var" használata nélkül deklarál, a változó mindig GLOBÁLIS lesz.

Értékek hozzárendelése nem deklarált JavaScript-változókhoz

Ha értékeket rendel olyan változókhoz, amelyeket még nem deklarált, akkor a változók automatikusan globális változóként lesznek deklarálva.

Ezek a javaslatok:

Az operátorokról a következő JavaScript leckében tudhat meg többet.

A JavaScriptben két hatókör létezik: helyi és globális. Attól függ, hogy a változó hol van deklarálva, a függvényen belül vagy a függvényen kívül.

Ha a változót a függvényen belül deklaráljuk, akkor lokálisnak, ha a függvényen kívül, akkor globálisnak nevezzük.

A modern programozási koncepció azt ajánlja, hogy a szkriptekben (programokban) minden változó lokális legyen, maga a program pedig csak függvényekből álljon, ahol minden függvény csak egy feladatot látna el. Például egy másik webprogramozási nyelvben, a PHP-ben általában felhagytak a globális változók használatával.

Globális változók a JavaScriptben

A globális változókat a függvényeken kívül deklarálják, és bármely függvényből vagy programsorból elérhetők (elérhetők).

Var Oroszország; russia = "Oroszország"; függvény getValueRussia() ( alert(oroszország); ) getValueRussia();

Itt a russia egy globális változó, mert a függvényen kívül van deklarálva. Annak bizonyítására, hogy a változó globális, a getValueRussia() egyéni függvényen belülről fértünk hozzá az alert() függvény használatával, amely megjeleníti a russia változó értékét.

Helyi változók JavaScriptben

A JavaScript helyi változói a függvényeken belül vannak deklarálva. A helyi változókhoz csak azon függvényen belül lehet hozzáférni, amelyben deklarálva vannak.

Függvény getValueRussia() ( var russia; russia = "Oroszország"; ) alert(oroszország);

BAN BEN ezt a példát, semmi sem fog történni (az "Oroszország" feliratú ablak nem jelenik meg), és ha a konzolon keresztül nézi a szkriptet, akkor azt fogja mondani, hogy a russia változó nincs definiálva (undefined), ami azt jelenti, hogy a figyelmeztetés () függvény (a függvényen kívülre helyezve) , nem látja a függvényen belül létrehozott russia változót.

Függvény getValueRussia() ( var russia; russia = "Oroszország"; alert(oroszország); ) getValueRussia();

Ha az alert() függvényt egy függvénybe helyezzük, majd meghívjuk a getValueRussia() függvényt, akkor egy "Oroszország" feliratú dobozt fogunk látni. Ezek a példák azt mutatják, hogy a helyi változók csak azon a függvényen belül érhetők el, amelyben létrejöttek.