Variabila globală în javascript nu se modifică. JavaScript: domeniu variabil. Variabile locale și globale

Ultima actualizare: 05.04.2018

Toate variabilele din JavaScript au un domeniu specific în care pot acționa.

Variabile globale

Toate variabilele care sunt declarate în afara funcțiilor sunt globale:

var x = 5; fie d = 8; funcția displaySquare())( var z = x * x; console.log(z); )

Aici variabilele x și d sunt globale. Sunt accesibile de oriunde în program.

Dar variabila z nu este globală, deoarece este definită în interiorul funcției.

Variabile locale

O variabilă definită în interiorul unei funcții este locală:

Funcția displaySquare())( var z = 10; console.log(z); fie b = 8; console.log(b); )

Variabilele z și b sunt locale, ele există doar în cadrul funcției. Ele nu pot fi utilizate în afara unei funcții:

Funcția displaySquare())( var z = 10; console.log(z); ) console.log(z); //eroare deoarece z nu este definit

Când o funcție își termină activitatea, toate variabilele definite în funcție sunt distruse.

Ascunderea variabilelor

Ce se întâmplă dacă avem două variabile - una globală și cealaltă locală - care au același nume:

Var z = 89; funcția displaySquare())( var z = 10; console.log(z); // 10 ) displaySquare(); // 10

În acest caz, funcția va folosi variabila z care este definită direct în funcție. Adică variabila locală o va ascunde pe cea globală.

var sau let

Când se utilizează instrucțiunea let, fiecare bloc de cod definește un nou domeniu în care există variabila. De exemplu, putem defini o variabilă la nivel de bloc și la nivel de funcție în același timp:

Fie z = 10; function displayZ())( lat z = 20; ( lat z = 30; console.log("Block:", z); ) console.log("Function:", z); ) displayZ(); console.log("Global:", z);

Aici, în interiorul funcției displayZ, există un bloc de cod definit în care este definită variabila z. Ascunde variabila globală și variabila z definită la nivel de funcție. ÎN program real bloc ar putea reprezenta o funcție imbricată, bloc pentru buclă sau dacă constructe. Dar, în orice caz, un astfel de bloc definește un nou domeniu, în afara căruia variabila nu există.

Și în acest caz vom obține următoarea ieșire din consolă:

Bloc: 30 Funcție: 20 Global: 10

Cu operatorul var, nu putem defini o variabilă cu același nume atât într-o funcție, cât și într-un bloc de cod din acea funcție:

Funcția displaySquare())( var z = 20; ( var z = 30; // Eroare! Variabila z este deja definită console.log("Block:", z); ) console.log("Function:", z) ;)

Adică, cu var putem defini o variabilă cu un singur nume fie la nivel de funcție, fie la nivel de bloc de cod.

constante

Tot ceea ce se aplică operatorului let se aplică și operatorului const, care vă permite să definiți constante. Blocurile de cod definesc domeniul de aplicare al constantelor, iar constantele definite pe blocurile de cod imbricate ascund constantele externe cu același nume:

Const z = 10; function displayZ())( const z = 20; ( const z = 30; console.log("Block:", z); // 30 ) console.log("Function:", z); // 20 ) displayZ ( ); console.log("Global:", z); // 10

Variabile nedeclarate

Dacă nu folosim acest cuvânt cheie atunci când definim o variabilă într-o funcție, atunci o astfel de variabilă va fi globală. De exemplu:

Funcția bar())( foo = "25"; ) bar(); console.log(foo); // 25

Chiar dacă variabila foo nu este definită nicăieri în afara funcției bar, ea este totuși disponibilă în afara funcției în context extern.

Ar fi diferit dacă nu numai că am atribui o valoare unei variabile, ci și dacă am defini-o:

Funcția bar())( var foo = "25"; ) bar(); console.log(foo); // eroare

modul strict

Definirea variabilelor globale în funcții poate duce la erori potentiale. Pentru a le evita, utilizați modul strict:

„utilizați strict”; function bar())( foo = "25"; ) bar(); console.log(foo);

În acest caz, vom primi eroarea SyntaxError: Unexpected identifier, care indică faptul că variabila foo nu este definită.

Există două moduri de a seta modul strict:

adăugați expresia „utilizați strict” la începutul codului JavaScript, apoi modul strict va fi aplicat întregului cod

adăugați expresia „utilizați strict” la începutul corpului funcției, apoi modul strict va fi aplicat numai acestei funcții

Continuăm să studiem subiectul funcțiilor în JavaScript. Aici vom atinge conceptul de sferă variabilă. Este strâns legat de funcții, așa că este important să îl înțelegem.

Ar trebui invatat (și distinge între aceste concepte) un singur lucru este că variabilele sunt globale și locale.

Ce sunt variabilele globale? Să ne uităm la un exemplu...

var global = 21 ; /* Creați o variabilă globală */

function myFun () /* Creați o funcție care afișează o variabilă */
{
document.write(global);
}

myFun(); /* Apelați funcția */

În acest exemplu, am creat o variabilă globală, care este globală - acum o putem folosi - de exemplu, în interiorul unei funcții, după cum puteți vedea singur.

Aceasta este esența variabilelor globale - sunt create o singură dată (să spunem la începutul scenariului, așa cum ați văzut în exemplu)și apoi folosit în codul programului acolo unde este necesar (în matrice, funcții etc.).

Ce sunt variabilele locale? Să ne uităm din nou la un exemplu...

function myFun _2 () /* Creați o funcție */
{

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

myFun_2(); /* Apelați funcția */

Acest exemplu ilustrează crearea unei variabile locale: local. Este local deoarece este creat în interiorul funcției. Și poate fi folosit doar în interiorul acestuia.

Dacă încercăm să afișăm această variabilă în afara funcției, nu vom vedea nimic în fereastra browserului.

function myFun _2 () /* Creați o funcție */
{

var local = 42 ; /* Creați o variabilă locală */
document.write(local);
}

document.write(local); /* Încercarea de a afișa o variabilă locală în afara funcției */

Pe acestea exemple simple Ne-am uitat la conceptul de sferă variabilă în JavaScript. Să spunem încă o dată esența acesteia: dacă creăm o variabilă în interiorul unei funcții, atunci aceasta este locală și putem lucra cu ea doar în interiorul acestei funcții.

Iar variabilele create în afara funcției sunt numite globale și pot fi folosite oriunde, inclusiv în interiorul funcției.

Variabile

Declararea variabilelor

Înainte de a putea folosi o variabilă în JavaScript, aceasta trebuie să fie declarată. Variabilele sunt declarate folosind cuvânt cheie var asa:

Var i; var sum;

Folosind cuvântul cheie var o dată, puteți declara mai multe variabile:

Declararea variabilelor poate fi combinată cu inițializarea lor:

Var mesaj = „bună ziua”; var i = 0, j = 0, k = 0;

Dacă nu este specificată nicio valoare inițială în instrucțiunea var, atunci variabila este declarată, dar valoarea sa inițială rămâne nedefinită până când este modificată de program.

Dacă aveți experiență în utilizarea limbajelor de programare cu tipuri de date statice, cum ar fi C# sau Java, este posibil să observați că declarațiile de variabile în JavaScript lipsește declarația de tip. Variabilele din JavaScript pot stoca valori de orice tip. De exemplu, în JavaScript este posibil să atribuiți unele număr variabilși apoi atribuiți linia aceleiași variabile:

Var i = 10; i = „bună ziua”;

Cu instrucțiunea var, puteți declara aceeași variabilă de mai multe ori. Dacă declarația repetată conține un inițializator, atunci acționează ca o instrucțiune obișnuită de atribuire.

Dacă încercați să citiți valoarea unei variabile nedeclarate, JavaScript va genera o eroare. În modul strict furnizat de standardul ECMAScript 5, apare și o eroare atunci când se încearcă atribuirea unei valori unei variabile nedeclarate. Cu toate acestea, din punct de vedere istoric, și atunci când nu este executat în modul strict, dacă atribuiți o valoare unei variabile care nu este declarată cu o instrucțiune var, JavaScript va crea acea variabilă ca proprietate a obiectului global și va acționa la fel ca o variabilă declarată corect. Aceasta înseamnă că variabilele globale nu trebuie declarate. Cu toate acestea, acesta este considerat un obicei prost și poate fi o sursă de erori, așa că încercați întotdeauna să vă declarați variabilele folosind var.

Domeniu variabil

Sfera de aplicare a unei variabile este partea din program pentru care este definită variabila. O variabilă globală are un domeniu de aplicare global - este definită pentru întregul program JavaScript. În același timp, variabilele declarate în interiorul unei funcții sunt definite doar în corpul acesteia. Ele sunt numite locale și au sferă locală. Parametrii funcției sunt, de asemenea, considerați variabile locale, definite numai în corpul acelei funcții.

În cadrul unui corp de funcție, o variabilă locală are prioritate față de o variabilă globală cu același nume. Dacă declarați o variabilă locală sau un parametru de funcție cu același nume ca o variabilă globală, variabila globală va fi de fapt ascunsă:

Var rezultat = "global"; funcția getResult() (var rezultat = "local"; returnează rezultat; ); console.log(getResult()); // Afișează „local”

Când declarați variabile cu domeniu global, instrucțiunea var poate fi omisă, dar atunci când declarați variabile locale, ar trebui să utilizați întotdeauna instrucțiunea var.

Variabile și constante în JavaScript. Declararea variabilelor și atribuirea de valori acestora. Variabile globale și locale. Folosind constante

Declararea variabilelor în JavaScript

Numele de variabile în JavaScript pot consta din litere, cifre, semnul $ și semnul _, iar numele variabilei nu poate începe cu un număr. Rețineți că JavaScript este sensibil la majuscule și minuscule, iar variabilele a1 și A1 sunt variabile diferite. Nu este recomandat să utilizați chirilic, deși este posibil.
Variabilele în JavaScript sunt declarate cu cuvântul cheie var:

Var Peremennaya_1 var Peremennaya_2

Nu este recomandat să folosiți variabile în JavaScript fără declarație. Acest lucru este posibil, dar poate duce la erori.

Atribuirea de valori variabilelor

Atribuirea unei valori variabilelor declarate în JavaScript:

Peremennaya_1 = 25 Peremennaya_2 = „Textul atribuit este inclus între ghilimele drepte”

Puteți atribui o valoare variabilelor imediat după declarare:

Var Peremennaya_1 = 25 var Peremennaya_2 = "Textul atribuit este inclus între ghilimele drepte"

Valoarea unei variabile în JavaScript se poate modifica în timpul execuției programului. Când scrieți text într-o variabilă, aceasta trebuie inclusă între ghilimele drepte.

Variabile locale și globale

Dacă o variabilă este declarată în interiorul unei funcții, atunci este locală și va fi accesibilă (vizibilă) numai în cadrul acestei funcții. Când o funcție iese, variabilele locale din JavaScript sunt distruse, astfel încât să puteți utiliza variabile cu același nume în diferite funcții.

Dacă o variabilă este declarată în afara funcțiilor, atunci este globală și va fi disponibilă (vizibilă) în toate funcțiile din pagină. Variabilele globale sunt distruse în JavaScript atunci când pagina este închisă.

Constante în JavaScript

Constantele sunt concepute pentru a face mai ușor să lucrați cu codul atunci când trebuie să utilizați valori sau expresii repetate. Este suficient să setați valoarea constantei o dată și o puteți folosi cât doriți, inserând-o în codul programelor dumneavoastră. JavaScript nu are un cuvânt cheie pentru a declara constante; variabilele obișnuite sunt folosite în loc de constante. Pentru a distinge constantele de variabile, acestea sunt de obicei notate cu litere mari, folosind un caracter de subliniere dacă este necesar:

Var DRUG_CHELOVEKA = "Câine"

Exemplul dat de constantă nu este complet complet, deoarece cuvântul „câine” este deja ușor de reținut și de inserat acolo unde este necesar. Puteți utiliza constante în JavaScript pentru a înregistra și a insera valori mai complexe, de exemplu, coduri greu de reținut, seturi de caractere, text lung, adrese web, adrese E-mail, numere de telefon, diverși coeficienți.

În JavaScript, constantele pot fi rescrise ca variabile, dar dacă faceți acest lucru, atunci sensul constantelor se pierde.

Acest tutorial din patru părți acoperă scrierea de cod JavaScript de calitate, care este ușor de întreținut și dezvoltat, chiar dacă trebuie să reveniți la proiect după o lungă perioadă de timp.

Scrieți codul cu așteptarea că va trebui să fie acceptat

Erori software au propriul lor cost. Costul lor este exprimat în timpul necesar pentru a le repara. Greșelile din proiectele lansate public sunt deosebit de costisitoare. Este foarte bine dacă puteți remedia erorile imediat, când structura codului este încă proaspătă în memoria dvs. și puteți găsi rapid zona cu probleme. Dar dacă ați trecut la alte sarcini și ați uitat deja caracteristicile unui anumit cod, atunci revenirea la proiect va necesita:

E timpul să studiezi și să înțelegi problema.
Este timpul să înțelegeți codul care cauzează problema.

O altă problemă care afectează proiectele mari sau companiile este aceea că persoana care remediază erorile nu este persoana care le creează (și adesea nu este persoana care le găsește în proiect). Prin urmare, reducerea timpului necesar pentru înțelegerea codului devine o problemă critică, indiferent dacă ați scris singur codul cu ceva timp în urmă sau a fost scris de un alt dezvoltator din echipa dvs. Răspunsul la întrebare va afecta semnificativ atât rezultatul financiar al proiectului, cât și nivelul de satisfacție al dezvoltatorilor, deoarece uneori este mai bine să faceți totul într-un mod nou decât să petreceți ore și zile întreținând cod vechi, de neînțeles.

Un alt fapt despre dezvoltarea de software este că de obicei durează mai mult citind cod, nu crearea lui. Când problema este enunțată inițial, dezvoltatorul se concentrează și se cufundă în întrebare, apoi se așează și poate crea cod semnificativ într-o seară. Atunci codul probabil funcționează, dar, firește produse software, apar situații care necesită revizuiri repetate ale codului. De exemplu:

Sunt detectate erori.
Noi caracteristici sunt adăugate la proiect.
Aplicația trebuie lansată într-un mediu nou (de exemplu, a apărut un nou browser).
Scopul codului se schimbă.
Codul trebuie să fie complet rescris sau portat într-o altă arhitectură sau limbaj de programare.

Ca urmare, se vor cheltui câteva ore de lucru pentru a scrie cod și câteva zile de lucru pentru citire. Prin urmare, crearea unui cod ușor de întreținut este esențială pentru succesul unei aplicații.

Codul ușor de întreținut are următoarele caracteristici:

Este ușor de citit.
Este bine structurat, iar părțile sunt consistente între ele.
El este previzibil.
Se pare că a fost scris de o singură persoană.
Documentat.

Minimizarea utilizării variabilelor globale

JavaScript folosește funcții pentru a gestiona contextul. Variabilele declarate în interiorul funcțiilor sunt locale pentru acestea și nu sunt accesibile în afara funcțiilor. Variabilele globale sunt declarate în afara funcțiilor sau pur și simplu utilizate fără declarație.

Fiecare mediu JavaScript are un obiect global care este utilizat în afara funcțiilor. Fiecare variabilă globală pe care o creați devine o proprietate a obiectului global. În browsere, pentru comoditate, există o proprietate suplimentară pe obiectul global numită fereastră care (de obicei) indică către obiectul global în sine. Următorul cod arată un exemplu de creare și accesare a variabilelor globale în mediul browser:

Var myglobal = „bună ziua”; console.log(myglobal); // „bună ziua” console.log(window.myglobal); // "bună ziua" console.log(fereastră["myglobal"]); // „bună ziua” console.log(this.myglobal); // "Buna ziua"

Probleme cu variabilele globale

Problema cu variabilele globale este că acestea vor fi disponibile în întregul cod JavaScript al aplicației sau paginii dvs. Ele sunt în spațiul de nume global și există întotdeauna o șansă pentru coliziunile de denumire, în care două părți diferite ale aplicației definesc variabile globale cu același nume, dar în scopuri diferite.

De asemenea, pagina web include de obicei cod scris de alți dezvoltatori. De exemplu:

Alte biblioteci JavaScript.
Scripturi de la partenerii de publicitate.
Cod pentru urmărirea și analiza utilizatorilor.
Diverse widget-uri, butoane și plugin-uri.

Să presupunem că într-unul dintre scripturile terță parte este definită o variabilă globală, care se numește, de exemplu, rezultat . Apoi definiți o altă variabilă globală într-una dintre funcțiile dvs. și o numiți rezultat. Ca rezultat, ultima declarație a variabilei rezultat o va înlocui pe prima și scriptul terță parte poate înceta să funcționeze.

Prin urmare, pentru a combina cu succes diferite coduri pe o singură pagină, este important să folosiți cât mai puține variabile globale. În această problemă, utilizarea directivei var la declararea variabilelor joacă un rol semnificativ.

Din păcate, este foarte ușor să creezi neintenționat o variabilă globală în JavaScript datorită a două caracteristici ale acesteia. În primul rând, puteți utiliza o variabilă fără a o declara. În al doilea rând, JavaScript are o definiție globală implicită, ceea ce înseamnă că orice variabilă nedeclarată devine o proprietate a obiectului global (și va fi accesibilă ca o variabilă globală declarată corect). De exemplu:

Funcția sum(x, y) ( // rău: rezultat global implicit = x + y; rezultat returnat; )

În acest cod, variabila rezultat este utilizată fără declarație. Codul funcționează bine, dar după apelarea funcției veți ajunge cu o altă variabilă rezultat în spațiul de nume global, ceea ce poate duce la probleme.

Regula de minimizare este definirea variabilelor folosind directiva var. Mai jos este o versiune îmbunătățită a funcției sum():

Funcția sum(x, y) ( var rezultat = x + y; returnează rezultat; )

O altă opțiune proastă pentru crearea globale implicite este înlănțuirea unei atribuiri de valoare într-o declarație var. În exemplul următor, variabila a va fi locală, iar variabila b va fi globală, ceea ce probabil nu este intenția creatorului de cod:

// rău, nu folosiți funcția foo() ( var a = b = 0; // ... )

Dacă ești surprins de ceea ce se întâmplă, este o chestiune de calcule de la dreapta la stânga. Expresia b = 0 este executată mai întâi și, prin urmare, variabila b nu va fi declarată. Valoarea returnată a expresiei va fi 0 și este atribuită unei noi variabile locale a, care este declarată de directiva var. Această definiție a variabilelor este echivalentă cu următoarea notație:

Var a = (b = 0);

Dacă ați declarat deja variabilele, atunci reprezentarea înlănțuită va funcționa bine și nu va crea variabile globale nedorite:

Funcția foo() (var a, b; a = b = 0; // ambele variabile sunt locale)

Un alt motiv pentru a evita utilizarea variabilelor globale este portabilitatea codului. Dacă intenționați să rulați codul într-un mediu diferit, atunci variabilele globale pot suprascrie obiecte care nu se află în mediul original (deci poate părea că numele pe care îl utilizați este sigur).

Efectul secundar al declarației var uitate

Există o mică diferență între variabilele globale definite explicit și implicite. Este capacitatea de a șterge o variabilă folosind operatorul de ștergere:

O variabilă globală declarată printr-o declarație var (creată într-un program în afara funcțiilor) nu poate fi ștearsă.
O variabilă globală implicită creată fără declarație (indiferent de locul în care a fost creată) poate fi ștearsă.

Din punct de vedere tehnic, o variabilă globală implicită este o proprietate a obiectului global, nu o variabilă. Proprietățile pot fi șterse folosind operatorul de ștergere, dar variabilele nu pot:

// definim trei variabile globale var global_var = 1; global_novar = 2; // rău (funcție () ( global_fromfunc = 3; // rău )()); // Încercarea de a șterge șterge global_var; // false delete global_novar; // adevărat delete global_fromfunc; // true // Verificarea tipului de ștergere a global_var; // tipul „număr” global_novar; // tip „nedefinit” de global_fromfunc; // "nedefinit"

Accesarea unui obiect global

În browsere, obiectul global este accesibil oriunde în codul tău prin proprietatea ferestrei (cu excepția cazului în care faci ceva special sau neașteptat, cum ar fi declararea unei variabile locale numite fereastră). Dar în alte medii, această proprietate de confort poate fi disponibilă într-un mod diferit (sau chiar să nu fie disponibilă deloc pentru programator). Dacă aveți nevoie de acces la obiectul global fără a utiliza identificatorul de fereastră, atunci puteți utiliza următoarea metodă la orice nivel al unui spațiu de nume al funcției imbricate:

Var global = (funcție () ( return this; )());

Astfel, este întotdeauna posibil să accesați obiectul global, deoarece în interiorul unei funcții care este apelată ca funcție (și nu ca constructor cu o nouă declarație), aceasta indică întotdeauna obiectul global.

Șablon de declarație unică var

Utilizarea unei singure declarații var în partea de sus a funcției este o practică foarte utilă. Această metodă are următoarele avantaje:

Oferă un singur loc pentru a declara toate variabilele locale ale unei funcții.
Previne erorile logice atunci când o variabilă este utilizată înainte de a fi declarată.
Ajută să vă amintiți să declarați variabilele locale și, prin urmare, reduce numărul de variabile globale.

Un șablon cu o declarație var arată astfel:

Funcția func() ( var a = 1, b = 2, sum = a + b, myobject = (), i, j; // Codul funcției... )

Utilizați o singură declarație var pentru a declara mai multe variabile, separate prin virgule. O completare excelentă ar fi inițializarea variabilelor cu date sursă atunci când le declarați. Acest lucru previne erorile logice (toate variabilele neinițializate sunt setate implicit la nedefinite) și îmbunătățește lizibilitatea codului. Când revizuiți codul mai târziu, cum puteți determina scopul unei variabile după ea valoarea initiala(de exemplu, va fi imediat evident că acesta este un obiect sau un număr întreg).

De asemenea, puteți efectua o operație asupra declarației de variabile, cum ar fi sum = a + b din exemplul de cod anterior. Un alt exemplu de lucru este manipularea DOM. Puteți atribui referințe la elemente DOM variabilelor locale atunci când declarați:

Funcția updateElement() ( var el = document.getElementById("rezultat"), style = el.style; // efectuează operații cu el și stil... )

Lifting: problemă cu declarațiile var împrăștiate

JavaScript permite mai multe declarații var oriunde într-o funcție și acestea acționează la fel, indiferent de plasare. Această caracteristică cunoscut sub numele de „rise”. Acest comportament poate duce la erori logice atunci când utilizați o variabilă și apoi o declarați pentru codul funcției ulterioare. Pentru JavaScript, deoarece o variabilă se află în același spațiu de nume (în aceeași funcție), se presupune că este declarată, chiar dacă este folosită înaintea directivei var. De exemplu

// bad myname = "global"; // funcția variabilă globală func() ( alert(numele meu); // „nedefinit” var numele meu = „local”; alert(numele meu); // „local” ) func();

ÎN în acest exemplu Primul apel la alert() este de așteptat să producă mesajul „global”, iar al doilea apel la „local”. O așteptare rezonabilă deoarece la primul apel variabila locală myname nu este declarată și funcția trebuie să utilizeze variabila globală myname . Dar, în realitate, lucrurile funcționează diferit. Primul apel la alert() va returna „nedefinit” deoarece numele meu este tratat ca o variabilă locală declarată în funcție (deși declarația va veni mai târziu). Toate declarațiile de variabile sunt ridicate în partea de sus a funcției. Prin urmare, pentru a evita acest tip de eroare, trebuie să declarați toate variabilele în partea de sus a funcției.

Exemplul anterior se va comporta ca și cum ar fi implementat astfel:

Numele meu = "global"; // funcția variabilă globală func() (var numele meu; // la fel ca -> var numele meu = nedefinit; alert(numele meu); // "nedefinit" numele meu = "local"; alertă (numele meu); // "local" ) func();

Merită menționat faptul că implementarea efectivă a codului este mai complexă. Există două etape de procesare a codului. Prima etapă creează variabile, declarații de funcții și parametri formali și definește contextul. A doua etapă execută codul, evaluează funcțiile și creează identificatori necalificați (variabile nedeclarate). Dar pentru utilizare practică, puteți folosi conceptul de ridicare, care descrie bine comportamentul codului.