Primjeri pogrešaka js globalnih varijabli. JavaScript. Varijable (globalne, lokalne, konstante). Značajke globalnih objekata

Globalne varijable u javascriptu

Što su globalne varijable: varijable koje su "vidljive" u bilo kojem trenutku izvođenja programa i mogu se čitati i prebrisati posvuda.
Obično su globalne varijable definirane na samom početku programa, izvan svih blokova (())
u slučaju Js, postavljaju se nakon skripte ili svih vrsta funkcija

hello = "Zdravo"; //postavite globalnu varijablu i provjerite je
document.writeln("->1 "+ zdravo +" svaki
");//->1 Pozdrav svima

Ako (istina)
//ako(false)
{
var hello = "Zdravo Dolly i "; //ovo je također globalno
svijet = "svijet"; //globalno
var cont = "nastavljamo" //globalno
document.writeln("->1.2 " + hello + world + cont+"
");
//1.
}
document.writeln("->2 " + hello + world + cont+"
");
//->2 Pozdrav Dolly i svijete, nastavljamo

Ako je istina, dobivamo odgovor

->1 Pozdrav svima
->1.2 Pozdrav Dolly i svijete, nastavljamo
->2 Pozdrav Dolly i svijete, nastavljamo

Izvršenje se prekida

Dakle, ispada da upotreba var nema utjecaja na globalni opseg. Varijabla spomenuta u skripti izvan procedura smatra se globalnom čak i ako je zatvorena u zagradama () u if dok za blok i druga područja ostat će globalna čak i unutar petlji

Zaključci, ukratko

* za varijable koje se koriste u zoni globalne vidljivosti, prisutnost var nije važna.
* Blokovi nakon if while for ne stvaraju lokalni opseg (kao što se događa u drugim jezicima)

Lokalne varijable su varijable definirane unutar izvršnog bloka (funkcije) i ne utječu na druge funkcije. i vanjskom okruženju, tj. globalno područje.

Dječak = "Jhone";
did = "ubija Kennyja"; //pa imamo 2 globalne varijable
funkcija doit()
{
//ispis je već prošao --1, a mi mijenjamo podatke mijenjamo podatke
var dječak = "Gary"; //stvori lokalizaciju
did = "pomaže Anny"; //promjena globalnog
;
document.writeln("--2 " + dječak + " " + učinio + "
");
//--2 Gary pomaže Anny
;
//sada ćemo unutar funkcije postaviti lokalne i globalne varijable
var good = "bio je dobar dječak
";//lokalno!
loše = "on voli loše djevojke
";//globalno
}
;
document.writeln("--1 " + dječak + " " + učinio + "
");
//--1 Jhone ubija Kennyja
učini to();
//--2 Gary pomaže Anny
document.writeln("--3 " + dječak + " " + učinio + "
");
//--3 Jhone pomaže Anny
;
ako (!istinito)
//if(!false)
{
document.writeln("--4 " + dobar);
//izvršavanje ovog bloka uzrokovat će pogrešku.
//sada smo izvan lokalnog opsega
//doit() funkcija, stoga nam je dana preko var
//varijabla good jednostavno ne postoji
}
document.writeln("--5 " + loše);
//--5 on voli loše djevojke

Proizlaziti:

1 Jhone ubija Kennyja
--2 Gary pomaže Anny
--3 Jhone pomaže Anny
--5 voli zločestu djevojku

Lokalne varijable u javascriptu

* var radi unutar funkcije, deklarirajući lokalnu varijablu. To je njegova glavna zadaća

* Javascript se jako razlikuje od C-a po tome što su samo(?) lokalne varijable moguće unutar funkcije.
* hoćete li ili ne koristiti var u globalnom opsegu ovisi samo o vašem osobnom iskustvu. Ali za mene je bolje ne biti lijen. u Perlu se to zove use strict

>>>za varijable koje se koriste u zoni globalne vidljivosti, prisutnost var nije važna

Važno. Prvo, “vars” se ne mogu izbrisati (pomoću delete). Drugo, njihova instancija se događa na “nultom redu” (prije početka rada “linija po linija”), gdje im se odmah dodjeljuje nedefinirana vrijednost, a tek tada varijabla može (ili ne mora) dobiti novu vrijednost:

Var glb_1 = 1;
if (false) (var glb_2 = 2; glb_3 = 3;)

Alert(glb_1) // instancira i daje mu se vrijednost 1
upozorenje(glb_2) // navedeno i primljena vrijednost 'undefined'
alert(glb_3) // uopće nije varijabla (nema var), greška prilikom pristupa

JavaScript ima tri opsega: globalni, funkcijski i blok. Opseg varijable je područje izvornog koda programa u kojem su varijable i funkcije vidljive i mogu se koristiti. Globalni opseg naziva se i kod najviše razine.

Globalne varijable

Varijabla deklarirana izvan funkcije ili bloka naziva se globalna. Globalna varijabla dostupna je bilo gdje u izvornom kodu:

Var num = 5; funkcija foo() ( console.log(num); ) foo(); // 5 console.log(num); // 5 (console.log(num); // 5)

Lokalne varijable

Varijabla deklarirana unutar funkcije naziva se lokalna. Lokalna varijabla je dostupna bilo gdje unutar tijela funkcije u kojoj je deklarirana. Lokalna varijabla se stvara iznova svaki put kada se funkcija pozove i uništava se prilikom izlaska iz nje (kada funkcija završi):

Funkcija foo() ( var num = 5; console.log(num); ) foo(); // 5 console.log(typeof num); //nedefiniran

Lokalna varijabla ima prednost nad globalnom varijablom istog imena, što znači da će se unutar funkcije koristiti lokalna varijabla umjesto globalne:

Var x = "globalno"; // Funkcija globalne varijable checkscope() ( var x = "local"; // Lokalna varijabla s istim imenom kao globalna one document.write(x); // Koristite lokalnu varijablu, a ne globalnu) checkscope() ; // => "local" Pokušajte »

Varijable bloka

Varijabla deklarirana unutar bloka pomoću ključne riječi let naziva se blok varijabla. Varijabla bloka je dostupna bilo gdje unutar bloka u kojem je deklarirana:

Neka je num = 0; ( neka num = 5; console.log(num); // 5 ( neka num = 10; console.log(num); // 10 ) console.log(num); // 5 ) console.log(num) ; // 0

Ponovna najava

Ako koristite ključnu riječ var za ponovno deklariranje varijable s istim imenom (u istom opsegu), tada se ništa neće dogoditi:

Var a = 10; var a; konzola.log(a); // 10

Ako je ponovna deklaracija popraćena inicijalizacijom, tada takva izjava djeluje kao normalna dodjela nove vrijednosti:

Var a = 10; var a = 5; // Isto kao a = 5; konzola.log(a); // 5

Ako koristite ključnu riječ let za ponovno deklariranje varijable s istim imenom (u istom opsegu), pojavit će se pogreška:

Var a = 10; neka; // Pogreška.

Lanac opsega

Razmotrite sljedeći primjer:

Var num = 5; funkcija foo() ( var num2 = 10; funkcija bar() ( var num3 = 15; ) )

Ovaj kod ima tri opsega: globalni, opseg funkcije foo() i opseg funkcije bar(). Globalni opseg definira varijablu num i funkciju foo() . Opseg funkcije foo() definira varijablu num2 i funkciju bar() , a u njoj je dostupna i varijabla num iz globalnog opsega. Opseg funkcije bar() sadrži jednu varijablu, num3, kojoj se može pristupiti samo unutar funkcije bar(). Opseg funkcije bar() također ima pristup varijablama iz druga dva opsega jer su one njegovi roditelji. Lanac opsega za ovaj primjer prikazan je na donjoj slici:

Na slici su različita područja vidljivosti prikazana pravokutnicima različitih boja. Unutarnji opseg u lancu opsega ima pristup svemu iz vanjskih opsega, ali vanjski opseg nema pristup ničemu iz unutarnjih opsega.

Lanac opsega je naručen. Tumač traži identifikatore u lancu opsega prema van, a ne prema unutra. To znači da pretraživanje imena počinje od opsega gdje se pristupilo identifikatoru. Ako se ID ime pronađe, traženje se zaustavlja. Ako se ime ne može pronaći u trenutnom opsegu, traži se u sljedećem (vanjskom) opsegu, itd. Stoga će se koristiti identifikator iz opsega u kojem je pronađen. Ako identifikator nije pronađen ni u jednom opsegu, JavaScript će generirati pogrešku:

Var str = "globalno"; var num = 5; funkcija foo() ( var str = "local"; // Korištenje lokalne varijable str num = 10; // Korištenje globalne varijable num // upozorenje(x); // Pogreška. Varijabla x nije ni u jednom opsegu) foo( ) ; upozorenje(str); // "globalno" upozorenje(broj); // 10

Ako dodijelite vrijednost nedeklarisanoj varijabli u tijelu funkcije, tada će se u trenutku poziva funkcije, ako ne postoji varijabla s istim imenom u globalnom opsegu, stvoriti nova globalna varijabla:

Funkcija foo() ( num = 2; ) foo(); // Stvorena nova globalna varijabla num alert(num); // 2

Porast reklama

U JavaScriptu su deklarirane varijable dostupne bilo gdje u odnosu na njihov opseg, što znači da su varijable vidljive čak i prije nego što su deklarirane u kodu. Ova značajka JavaScripta neformalno se naziva dizanje: programski kod ponaša se kao da su deklaracije varijabli implicitno podignute (bez inicijalizacije) na sam vrh svog opsega.

Razmotrite sljedeći isječak koda:

Var str = "globalno"; funkcija foo() ( alert(str); // nedefinirano var str = "local"; alert(str); // "local" ) foo();

Gledajući kod, pomislili biste da bi prvo upozorenje trebalo ispisati niz "global" jer deklaracija lokalne varijable str još nije učinjena. Međutim, zapravo ispisuje vrijednost undefined. Podizanjem deklaracija, gornja funkcija je ekvivalentna implementaciji ispod, u kojoj se deklaracija varijable podiže na početak funkcije:

Funkcija foo() ( var str; // Deklaracija lokalne varijable na početku funkcije alert(str); // Ovdje je dostupna, ali nije inicijalizirana str = "local"; // Ovdje je inicijalizirana alert( str); // I ovdje ima očekivanu vrijednost - "lokalno")

Isto se odnosi i na globalni opseg, varijabla deklarirana na dnu dostupna je na vrhu:

Upozorenje(broj); // nedefinirano var num = 10; upozorenje(broj); // 10

Varijable i konstante u JavaScriptu. Deklariranje varijabli i dodjeljivanje vrijednosti njima. Globalne i lokalne varijable. Korištenje konstanti

Deklariranje varijabli u JavaScriptu

Nazivi varijabli u JavaScriptu mogu se sastojati od slova, brojeva, znaka $ i znaka _, a naziv varijable ne može započeti brojem. Imajte na umu da je JavaScript osjetljiv na velika i mala slova i da su varijable a1 i A1 različite varijable. Nije preporučljivo koristiti ćirilicu, iako je moguće.
Varijable u JavaScriptu deklarirane su ključnom riječi var:

Var Peremennaya_1 var Peremennaya_2

Ne preporučuje se korištenje varijabli u JavaScriptu bez deklaracije. To je moguće, ali može dovesti do pogrešaka.

Dodjeljivanje vrijednosti varijablama

Dodjeljivanje vrijednosti deklariranim varijablama u JavaScriptu:

Peremennaya_1 = 25 Peremennaya_2 = "Dodijeljeni tekst je u ravnim navodnicima"

Varijablama možete dodijeliti vrijednost odmah nakon deklaracije:

Var Peremennaya_1 = 25 var Peremennaya_2 = "Dodijeljeni tekst je u ravnim navodnicima"

Vrijednost varijable u JavaScriptu može se promijeniti tijekom izvođenja programa. Kada pišete tekst u varijablu, ona mora biti unutar ravnih navodnika.

Lokalne i globalne varijable

Ako je varijabla deklarirana unutar funkcije, onda je lokalna i bit će dostupna (vidljiva) samo unutar ove funkcije. Kada funkcija izađe, lokalne varijable u JavaScriptu se uništavaju, tako da možete koristiti varijable s istim imenom u različitim funkcijama.

Ako je varijabla deklarirana izvan funkcija, onda je globalna i bit će dostupna (vidljiva) u svim funkcijama unutar stranice. Globalne varijable se uništavaju u JavaScriptu kada se stranica zatvori.

Konstante u JavaScriptu

Konstante su osmišljene kako bi olakšale rad s vašim kodom kada trebate koristiti ponovljene vrijednosti ili izraze. Dovoljno je jednom postaviti vrijednost konstante i možete je koristiti koliko god želite umetanjem u kod svojih programa. JavaScript nema ključnu riječ za deklariranje konstanti; umjesto konstanti koriste se regularne varijable. Kako bismo razlikovali konstante od varijabli, one se obično označavaju velikim slovima, koristeći podvlaku ako je potrebno:

Varijanta DRUG_CHELOVEKA = "Pas"

Navedeni primjer konstante nije posve potpun, budući da je riječ “Pas” već lako zapamtiti i umetnuti gdje je potrebno. Konstante u JavaScriptu možete koristiti za snimanje i umetanje složenijih vrijednosti, kao što su teško pamtljivi kodovi, skupovi znakova, dugački tekst, web adrese, adrese e-pošte, telefonski brojevi i razni izgledi.

U JavaScriptu se konstante mogu prepisati kao varijable, ali ako to učinite, tada se gubi značenje konstanti.

Zadnja izmjena: 05.04.2018

Sve varijable u JavaScriptu imaju određeni opseg unutar kojeg mogu djelovati.

Globalne varijable

Sve varijable koje su deklarirane izvan funkcija su globalne:

var x = 5; neka je d = 8; funkcija displaySquare())( var z = x * x; console.log(z); )

Ovdje su varijable x i d globalne. Dostupni su s bilo kojeg mjesta u programu.

Ali varijabla z nije globalna, jer je definirana unutar funkcije.

Lokalne varijable

Varijabla definirana unutar funkcije je lokalna:

Funkcija displaySquare())( var z = 10; console.log(z); neka je b = 8; console.log(b); )

Varijable z i b su lokalne, postoje samo unutar funkcije. Ne mogu se koristiti izvan funkcije:

Funkcija displaySquare())( var z = 10; console.log(z); ) console.log(z); //greška jer z nije definiran

Kada funkcija završi svoj rad, sve varijable definirane u funkciji se uništavaju.

Skrivanje varijabli

Što ako imamo dvije varijable - jednu globalnu i drugu lokalnu - koje imaju isti naziv:

Var z = 89; funkcija displaySquare())( var z = 10; console.log(z); // 10 ) displaySquare(); // 10

U ovom slučaju, funkcija će koristiti varijablu z koja je definirana izravno u funkciji. Odnosno, lokalna varijabla će sakriti globalnu.

var ili neka

Kada koristite naredbu let, svaki blok koda definira novi opseg u kojem postoji varijabla. Na primjer, možemo definirati varijablu na razini bloka i na razini funkcije u isto vrijeme:

Neka je z = 10; funkcija displayZ())( neka je z = 20; ( neka je z = 30; console.log("Blok:", z); ) console.log("Funkcija:", z); ) displayZ(); console.log("Globalno:", z);

Ovdje, unutar funkcije displayZ, postoji definiran blok koda u kojem je definirana varijabla z. Skriva globalnu varijablu i z varijablu definiranu na razini funkcije. U stvarnom programu, blok može predstavljati ugniježđenu funkciju, blok petlje for ili if konstrukciju. Ali u svakom slučaju, takav blok definira novi opseg, izvan kojeg varijabla ne postoji.

I u ovom slučaju dobit ćemo sljedeći izlaz konzole:

Blok: 30 Funkcija: 20 Globalno: 10

S var operatorom ne možemo definirati varijablu s istim imenom i u funkciji i u bloku koda unutar te funkcije:

Funkcija displaySquare())( var z = 20; ( var z = 30; // Greška! Varijabla z je već definirana console.log("Block:", z); ) console.log("Function:", z) ;)

To jest, pomoću var možemo definirati varijablu s jednim imenom bilo na razini funkcije ili na razini bloka koda.

Konstante

Sve što se odnosi na operator let također se odnosi na operator const, koji vam omogućuje definiranje konstanti. Blokovi koda definiraju opseg konstanti, a konstante definirane na ugniježđenim blokovima koda skrivaju vanjske konstante istog imena:

Konst z = 10; funkcija displayZ())( const z = 20; ( const z = 30; console.log("Blok:", z); // 30 ) console.log("Funkcija:", z); // 20 ) displayZ ( ); console.log("Globalno:", z); // 10

Nedeklarirane varijable

Ako ne koristimo ovu ključnu riječ kada definiramo varijablu u funkciji, tada će takva varijabla biti globalna. Na primjer:

Funkcija bar())( foo = "25"; ) bar(); konzola.log(foo); // 25

Iako varijabla foo nije definirana nigdje izvan funkcije trake, ipak je dostupna izvan funkcije u vanjskom kontekstu.

Bilo bi drugačije kada bismo ne samo dodijelili vrijednost varijabli, već je i definirali:

Funkcija bar())( var foo = "25"; ) bar(); konzola.log(foo); // pogreška

strogi režim

Definiranje globalnih varijabli u funkcijama može dovesti do mogućih pogrešaka. Da biste ih izbjegli, koristite strogi način rada:

"koristi strog"; funkcija bar())( foo = "25"; ) traka(); konzola.log(foo);

U tom slučaju dobit ćemo pogrešku SyntaxError: Unexpected identifier, koja označava da varijabla foo nije definirana.

Postoje dva načina za postavljanje strogog načina rada:

dodajte izraz "use strict" na početak JavaScript koda, tada će se strogi način primijeniti na sav kod

dodajte izraz "use strict" na početak tijela funkcije, tada će se strogi način primijeniti samo na ovu funkciju

Dobar dan, obožavatelji JavaScripta i moji vjerni pretplatnici. U današnjem postu, detaljno ću vam reći kako se globalne i lokalne varijable stvaraju u JavaScriptu. Svakako ću definirati važne pojmove, govoriti o značajkama deklaracije i inicijalizacije varijabli, opisati što je scope i kako kreirani elementi funkcioniraju u njemu.

Sve se to odnosi na najosnovnije, temeljno poznavanje jezika. Bez razumijevanja svega ovoga, nećete moći ići naprijed i razvijati svoje vještine js programiranja. Osim toga, ključni koncepti bit će vam korisni ne samo u ovoj specijalizaciji, već iu IT području općenito. Pa, počnimo!

Što je varijabla i kako nastaje?

Varijabla je element programskog jezika za koji je dodijeljeno memorijsko područje iu kojem su pohranjene određene vrijednosti.

Može postojati ogroman broj varijabli i sve moraju imati jedinstveno ime.

Postoje dvije vrste varijabli: globalne i lokalne. Njihova razlika je samo u različitom opsegu varijabli. Dakle, globalni elementi su vidljivi kroz cijeli kod, a lokalni su vidljivi samo u malom području gdje su deklarirani.

Usput, pokušajte od prvog dana, od svog prvog koda, elemente imenovati logičnim i razumljivim imenima. Jer kasnije, kada radite s teškim programima, nakon nekog vremena nećete se sjetiti što znači, na primjer, "aa1" ili "perem3".

A iz naslova baš ništa nije jasno! To i nije tako loše, uostalom, nije tako teško razumjeti vlastite tekstove. Što ćete učiniti ako dobijete zadatak da završite zadatke u nekom drugom programu za koji nikada prije niste ni čuli? S takvim imenima, analiza implementacije softvera će ubiti mnogo korisnog vremena.

Pročitao sam notaciju, a sad se vratimo deklaraciji varijabli.

Da biste kreirali varijablu, prvo morate napisati ključnu riječ var, a zatim i sam naziv. Ovako to izgleda:

var text = “Pozdrav, korisniče!”

Nakon toga, tekstu se pristupa bez "var":

text = “Novi tekst.”

U tom će slučaju vrijednost biti prepisana.

Za bolje razumijevanje, razmotrite primjer u kojem je stvorena jedna varijabla. Osvrnut ćemo se na njegovo značenje prije i nakon prepisivanja.

1 2 3 4

var text = “Pozdrav, korisniče!”; upozorenje (tekst); // ispisat će "Hello, user!" text= “Novi tekst!”; upozorenje (tekst); // ispisat će "Novi tekst!"

var text = “Pozdrav, korisniče!”; upozorenje (tekst); // ispisat će "Hello, user!" text= “Novi tekst!”; upozorenje (tekst); // ispisat će "Novi tekst!"

Značajke globalnih objekata

Svi stvoreni objekti u js kodu dijele se na globalne i lokalne. Gore sam objasnio koja je razlika između njih. Pogledajmo sada pobliže globalne objekte.

Sve su to funkcije i varijable koje su deklarirane u glavnom dijelu koda, tj. ne unutar bilo koje funkcije. Svi oni u js-u automatski postaju svojstva globalnog objekta, koji je u preglednicima jasno dostupan ispod riječi window. Pogledajmo primjer.

var cijena = 145; // kreiramo globalnu varijablu

upozorenje(prozor.cijena); // odgovor: 145

Za sada je sve jednostavno, ali budite spremni na zamke. Ponekad, bez poznavanja specifičnosti spremanja i prepisivanja vrijednosti varijabli, možete prebrisati vrlo važne parametre. Takvim je pogreškama prilično teško ući u trag i nemoguće ih je pronaći pomoću prevoditelja. Stoga pažljivo analizirajte sljedeći materijal.

Zamke i opseg

Za bolje razumijevanje problema, prvo ću pokazati mali program u kojem ću kreirati lokalnu varijablu u funkciji, a zatim izvan njenih granica - globalnu.

funkcija test() ( p = 2; vrati p; ) upozorenje(p); // nedefinirano p = “važan tekst”; upozorenje(p); // prikazat će “važan tekst” test(); // poziv funkcije alert(p); // ispisat će 2

U početku sam u testnoj funkciji inicijalizirao lokalnu varijablu s vrijednošću 2, a zatim stvorio globalnu tekstualnu varijablu koja pohranjuje neke važne podatke.

I tu se pojavljuje taj "podvodni blok".

Prvo, zbog činjenice da sam koristio stvaranje elemenata prema pravilima zastarjelog JavaScript standarda, sve "p" varijable su stvorene samo u trenutku dodjele (kada se koristi var direktiva, varijable se kreiraju odmah s vrijednošću nedefinirano, a tijekom inicijalizacije kroz “= » vrijednost se prepisuje).

Drugo, u ovom slučaju, za dodjeljivanje vrijednosti implicitno stvorenim elementima u js-u, koristi se postojeći ili se stvara nova globalna varijabla. Stoga je u gornjem primjeru, nakon poziva testne funkcije, izgubljena vrijednost globalnog "p".

Kako biste izbjegli padove, uvijek koristite ključnu riječ var. Tada će svi objekti biti eksplicitno deklarirani i novi će se kreirati.

Evo ispravljenog primjera:

funkcija test() ( var p = 2; upozorenje (p); vrati p; ) upozorenje(p); // nedefinirano var p = "važan tekst"; upozorenje(p); // prikazat će “važan tekst” test(); // pozivamo funkciju, u ovom slučaju prikazat će 2 alert(p); // prikazat će "važan tekst"

Sada kod radi ispravno. Kao što ste primijetili, opseg lokalnog "p" je unutar testne funkcije, a globalni je unutar ostatka koda.

Nekoliko riječi o konstantama

Kao i svi drugi programski jezici, JavaScript ima konstante. Za one koji ne znaju što je to, priložit ću definiciju.

Konstanta je vrsta varijable čija vrijednost ostaje nepromijenjena.

Prema pravilima sintakse u js-u, njihovo ime se uvijek piše malim (velikim) slovima. Na primjer,

var MAIN_COLOR = “#fff”

Ne postoje tehničke značajke u skriptnom jeziku koje bi konstantu učinile uistinu konstantom. Zapravo, to su obične varijable koje se mogu prebrisati. Međutim, prema pravilima, programeri koriste te elemente s velikim slovima u imenu kao konstante i ne mijenjaju njihovo značenje tijekom pisanja koda.

Glavna svrha konstanti je pohraniti složene nizove, važne brojeve ili druge vrijednosti u kojima je, kada se ponovno napišu, lako napraviti tipfeler ili se nikada ne bi smjele mijenjati, ili pojednostaviti kod. Na primjer, konstante se mogu koristiti za pohranjivanje često ponavljanih zahtjeva za