Funkcijas mainīgo tvērums JavaScript — globālie un lokālie mainīgie. Javascript mainīgo loks Vietējie un globālie mainīgie

Visi globālie mainīgie un funkcijas faktiski ir īpaša objekta, ko sauc par globālo objektu, īpašības un metodes.

Globālais objekts ir parasts objekts, kas tiek izveidots automātiski, kad tiek palaists tulks.

Programmā JavaScript globālā objekta lomu spēlē loga objekts. Šim objektam ir loga rekvizīts, kas attiecas uz pašu loga objektu. Logu objekts ir gan globāls objekts, gan arī satur vairākus savus rekvizītus un metodes darbam ar pārlūkprogrammas logu.

IN programmas kods Uz augstākā līmeņa globālo objektu var atsaukties arī, izmantojot šo atslēgvārdu:

Brīdinājums (šis === logs); // taisnība

Tā kā globālie mainīgie ir globāla objekta īpašības, strādājot ar globālo mainīgo, mēs faktiski strādājam ar loga īpašībām:

Var skaitlis = 10; brīdinājums(loga.numurs); // 10

Tā vietā, lai deklarētu mainīgo, izmantojot atslēgvārdu var, varat izveidot mainīgo, skaidri norādot jaunu rekvizītu objektam Window:

Window.num = 10; brīdinājums(numurs); // 10

Ņemiet vērā: lai gan globālie mainīgie faktiski ir loga objekta īpašības, mainīgā nosaukuma prefikss nav nepieciešams:

Var skaitlis = 10; brīdinājums(numurs); // 10 brīdinājums(window.num); // 10. Tas pats, kas alert(num);

Ja globālais mainīgais tiek deklarēts, izmantojot atslēgvārdu var vai let, tiek izveidots nekonfigurējams rekvizīts, tas ir, rekvizīts, kuru nevar izdzēst, izmantojot dzēšanas operatoru:

Var skaitlis = 10; brīdinājums(dzēst num); // false, mainīgais netiek dzēsts

Ja piešķirat vērtību nedeklarētam mainīgajam, JavaScript tulks automātiski izveidos globālo mainīgo. Šādā veidā izveidotie mainīgie kļūst par globālā objekta regulāriem, pielāgotiem rekvizītiem, t.i., tos var izdzēst, izmantojot dzēšanas operatoru:

Skaits = 10; brīdinājums(dzēst num); // patiess, mainīgais dzēsts

Labdien, JavaScript fani un mani lojālie abonenti. Šodienas ierakstā es jums detalizēti pastāstīšu par to, kā JavaScript tiek izveidoti globālie un lokālie mainīgie. Noteikti definēšu svarīgus terminus, runāšu par mainīgo deklarēšanas un inicializācijas iezīmēm, aprakstīšu, kas ir joma un kā tajā funkcionē izveidotie elementi.

Tas viss attiecas uz visvienkāršākajām, pamata valodas zināšanām. To visu nesaprotot, jūs nevarēsiet virzīties uz priekšu un attīstīt savas js programmēšanas prasmes. Turklāt galvenie jēdzieni jums noderēs ne tikai šajā specialitātē, bet arī IT jomā kopumā. Nu ko, sāksim!

Mainīgais ir programmēšanas valodas elements, kuram ir piešķirts atmiņas apgabals un kurā tiek saglabātas noteiktas vērtības.

Var būt ļoti daudz mainīgo, un tiem visiem ir jābūt unikālam nosaukumam.

Ir divu veidu mainīgie: globālie un lokālie. To atšķirība ir tikai atšķirīgajā mainīgo lielumu diapazonā. Tādējādi globālie elementi ir redzami visā kodā, un lokālie ir redzami tikai mazajā apgabalā, kurā tie tika deklarēti.

Starp citu, mēģiniet no pirmās dienas, no sava pirmā koda, izsaukt elementus loģiskos un saprotamos nosaukumos. Jo vēlāk, strādājot ar smagām programmām, pēc kāda laika vairs neatcerēsies, ko nozīmē, piemēram, “aa1” vai “perem3”.

Un no virsraksta pilnīgi nekas nav skaidrs! Tas nav tik slikti, galu galā nav tik grūti saprast savus rakstus. Ko jūs darīsiet, ja jums tiks dots uzdevums pabeigt uzdevumus citā programmā, par kuru jūs nekad iepriekš neesat pat dzirdējis? Izmantojot šādus nosaukumus, programmatūras ieviešanas analīze prasīs daudz noderīga laika.

Esmu izlasījis apzīmējumu, tagad atgriezīsimies pie mainīgo deklarēšanas.

Lai izveidotu mainīgo, vispirms jāieraksta atslēgvārds var un pēc tam pats nosaukums. Tas izskatās šādi:

var text = "Sveiks, lietotāj!"

Pēc tam tekstam tiek piekļūts bez “var”:

text = "Jauns teksts."

Šajā gadījumā vērtība tiks pārrakstīta.

Lai labāk izprastu, apsveriet piemēru, kurā tiek izveidots viens mainīgais. Mēs pievērsīsimies tā nozīmei pirms un pēc pārrakstīšanas.

var text = "Sveiks, lietotāj!"; brīdinājums(teksts); // izdrukās "Sveiks, lietotāj!" text= “Jauns teksts!”; brīdinājums(teksts); // izdrukās “Jauns teksts!”

Visi izveidotie objekti js kodā ir sadalīti globālajos un lokālajos. Iepriekš es paskaidroju, kāda ir atšķirība starp tiem. Tagad apskatīsim tuvāk globālos objektus.

Tās visas ir funkcijas un mainīgie, kas ir deklarēti koda galvenajā daļā, t.i. nav nevienas funkcijas iekšienē. Tie visi js failā automātiski kļūst par globāla objekta rekvizītiem, kas pārlūkprogrammās ir skaidri pieejams zem vārda loga. Apskatīsim piemēru.

var cena = 145; // izveidot globālu mainīgo

brīdinājums(logs.cena); // atbilde: 145

Pagaidām viss ir vienkārši, taču esiet gatavi kļūmēm. Dažreiz, nezinot mainīgo vērtību saglabāšanas un pārrakstīšanas specifiku, jūs varat pārrakstīt ļoti svarīgus parametrus. Šādas kļūdas ir diezgan grūti izsekot, un tās nav iespējams atrast, izmantojot kompilatorus. Tāpēc rūpīgi analizējiet tālāk minēto materiālu.

Lai labāk izprastu problēmu, es vispirms parādīšu maza programma, kur funkcijā es izveidošu lokālu mainīgo, un pēc tam ārpus tā robežām - globālo.

funkciju tests() ( p = 2; return p; ) alert(p); // undefined p = "svarīgs teksts"; brīdinājums(p); // parādīs "svarīgo tekstu" testu (); // izsaukt funkciju alert(p); // izdrukās 2

Sākotnēji testa funkcijā es inicializēju lokālo mainīgo ar vērtību 2 un pēc tam izveidoju globālu teksta mainīgo, kurā tiek glabāti daži svarīgi dati.

Un šeit parādās tas “zemūdens bloks”.

Pirmkārt, sakarā ar to, ka es izmantoju elementu izveidi pēc novecojušā JavaScript standarta noteikumiem, visi “p” mainīgie tika izveidoti tikai piešķiršanas brīdī (izmantojot direktīvu var, mainīgie tiek izveidoti uzreiz ar vērtību nav definēts, un inicializācijas laikā ar “= » vērtība tiek pārrakstīta).

Otrkārt, šajā gadījumā, lai piešķirtu vērtību netieši izveidotajiem elementiem js, tiek izmantots esošs vai tiek izveidots jauns globālais mainīgais. Tāpēc iepriekš minētajā piemērā pēc testa funkcijas izsaukšanas tika zaudēta globālā “p” vērtība.

Lai izvairītos no avārijām, vienmēr izmantojiet atslēgvārdu var. Tad visi objekti tiks skaidri deklarēti un tiks izveidoti jauni.

Šeit ir izlabots piemērs:

funkciju tests() ( var p = 2; alert (p); return p; ) alert(p); // undefined var p = "svarīgs teksts"; brīdinājums(p); // parādīs "svarīgo tekstu" testu (); // izsaukt funkciju, šajā gadījumā tā parādīs 2 alert(p); // parādīs "svarīgu tekstu"

Tagad kods darbojas pareizi. Kā jūs pamanījāt, vietējā “p” darbības joma atrodas testa funkcijā, bet globālā – pārējā koda daļā.

Tāpat kā visas citas programmēšanas valodas, arī JavaScript ir konstantes. Tiem, kas nezina, kas tas ir, pievienošu definīciju.

Konstante ir mainīgā veids, kura vērtība paliek nemainīga.

Saskaņā ar js sintakses noteikumiem to nosaukums vienmēr tiek rakstīts ar mazajiem (lielajiem) burtiem. Piemēram,

var MAIN_COLOR = "#fff"

Ne skriptu valodā tehniskajiem līdzekļiem, kas padarītu konstanti patiesi nemainīgu. Faktiski tie ir parastie mainīgie, kurus var pārrakstīt. Tomēr saskaņā ar noteikumiem izstrādātāji izmanto šos elementus ar lielajiem burtiem nosaukumā kā konstantes un nemaina to nozīmi, rakstot kodu.

Galvenais konstantu mērķis ir saglabāt sarežģītas virknes, svarīgus skaitļus vai citas vērtības, kurās, pārrakstot, ir viegli izdarīt drukas kļūdu vai tās nekad nevajadzētu mainīt, vai vienkāršot kodu. Piemēram, konstantes var izmantot, lai saglabātu bieži atkārtotus pieprasījumus

Mainīgie kalpo kā "konteineri" informācijas glabāšanai.

Vai atceries skolas algebru? x=5, y=6, z=x+y

Vai atceraties, ka burtu (piemēram, x) var izmantot, lai saglabātu vērtību (piemēram, 5), un ka jūs varētu izmantot iepriekš minēto informāciju, lai aprēķinātu, ka z vērtība ir 11?

Šos burtus sauc par mainīgajiem, un mainīgos var izmantot, lai saglabātu vērtības (x=5) vai izteiksmes (z=x+y).

Tāpat kā algebrā, JavaScript mainīgie tiek izmantoti vērtību vai izteiksmju glabāšanai.

Mainīgajam var būt īss nosaukums, piemēram, x, vai aprakstošāks nosaukums, piemēram, carname.

Noteikumi JavaScript mainīgo nosaukumiem:

• Mainīgo nosaukumi ir reģistrjutīgi (y un Y ir divi dažādi mainīgie)
• Mainīgo nosaukumiem jāsākas ar burtu vai pasvītrojumu

Piezīme. Tā kā JavaScript ir reģistrjutīgs, arī mainīgo nosaukumi ir reģistrjutīgi.

Skripta darbības laikā mainīgā vērtība var mainīties.

JavaScript mainīgo deklarēšana (izveidošana).

Mainīgo izveidošana JavaScript tiek biežāk saukta par mainīgo "deklarēšanu".

Jūs deklarējat JavaScript mainīgos, izmantojot atslēgvārdu var:

Pēc iepriekš minēto paziņojumu izpildes mainīgais x saturēs vērtību 5 un carname satur vērtību Mercedes. Piezīme. Kad piešķirat teksta vērtība

mainīgo, ievietojiet to pēdiņās.

JavaScript vietējie mainīgie Iekšpusē deklarēts mainīgais JavaScript funkcijas

kļūst LOCAL un būs pieejams tikai šajā funkcijā.

(mainīgajam ir lokāls apjoms).

Varat deklarēt lokālos mainīgos ar vienādu nosaukumu dažādās funkcijās, jo lokālie mainīgie tiek atpazīti funkcijā, kurā tie ir deklarēti.

Vairāk par funkcijām uzzināsiet nākamajās JavaScript nodarbībās.

JavaScript globālie mainīgie

Ārpus funkcijas deklarētie mainīgie kļūst GLOBĀLI, un tiem var piekļūt visi lapas skripti un funkcijas.

Ja deklarējat mainīgo, neizmantojot "var", mainīgais vienmēr kļūst par GLOBĀLU.

Vērtību piešķiršana nedeklarētiem JavaScript mainīgajiem

Ja piešķirat vērtības mainīgajiem, kas vēl nav deklarēti, mainīgie tiks automātiski deklarēti kā globālie mainīgie.

Šie piedāvājumi:

Vairāk par operatoriem uzzināsiet nākamajā JavaScript nodarbībā.

Visiem JavaScript mainīgajiem ir noteikta darbības joma, kurā tie var darboties.

Globālie mainīgie

Visi mainīgie, kas ir deklarēti ārpus funkcijām, ir globāli:

var x = 5; pieņemsim, ka d = 8; funkcija displaySquare())( var z = x * x; console.log(z); )

Funkcijā definētais mainīgais ir lokāls:

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

Mainīgie lielumi z un b ir lokāli, tie pastāv tikai funkcijas ietvaros. Tos nevar izmantot ārpus funkcijas:

Funkcija displaySquare())( var z = 10; console.log(z); ) console.log(z); //kļūda, jo z nav definēts

Kad funkcija pabeidz savu darbu, visi funkcijā definētie mainīgie tiek iznīcināti.

Kā rīkoties, ja mums ir divi mainīgie — viens globāls un otrs lokāls — kuriem ir vienāds nosaukums:

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

Šajā gadījumā funkcija izmantos mainīgo z, kas ir definēts tieši funkcijā. Tas nozīmē, ka lokālais mainīgais paslēps globālo.

Lietojot let paziņojumu, katrs koda bloks definē jaunu tvērumu, kurā pastāv mainīgais. Piemēram, mēs varam vienlaicīgi definēt mainīgo bloka līmenī un funkcijas līmenī:

pieņemsim, ka z = 10; funkcija displayZ())( lai z = 20; ( lai z = 30; console.log("Block:", z); ) console.log("Funkcija:", z); ) displayZ(); console.log("Globālais:", z);

Šeit funkcijā displayZ ir definēts koda bloks, kurā ir definēts mainīgais z. Tas slēpj globālo mainīgo un z mainīgo, kas definēts funkcijas līmenī. IN reāla programma bloks varētu attēlot ligzdotu funkciju, bloku cilpai vai ja konstrukcijas. Bet jebkurā gadījumā šāds bloks definē jaunu darbības jomu, ārpus kuras mainīgais nepastāv.

Un iekšā šajā gadījumā mēs iegūsim šādu konsoles izvadi:

Bloks: 30 Funkcija: 20 Globālais: 10

Izmantojot operatoru var, mēs nevaram definēt mainīgo ar tādu pašu nosaukumu gan funkcijā, gan koda blokā šīs funkcijas ietvaros:

Funkcija displaySquare())( var z = 20; ( var z = 30; // Kļūda! Mainīgais z jau ir definēts console.log("Block:", z); ) console.log("Funkcija:", z) ;)

Tas ir, ar var mēs varam definēt mainīgo ar vienu nosaukumu vai nu funkcijas līmenī, vai koda bloka līmenī.

Viss, kas attiecas uz operatoru let, attiecas arī uz operatoru const, kas ļauj definēt konstantes. Kodu bloki nosaka konstantu apjomu, un konstantes, kas definētas ligzdotajos koda blokos, slēpj ārējās konstantes ar tādu pašu nosaukumu:

Const z = 10; funkcija displayZ())( const z = 20; ( const z = 30; console.log("Block:", z); // 30 ) console.log("Function:", z); // 20 ) displayZ ( ); console.log("Globālais:", z); // 10

Ja mēs neizmantojam šo atslēgvārdu, definējot mainīgo funkcijā, tad šāds mainīgais būs globāls. Piemēram:

Funkciju josla())( foo = "25"; ) bar(); konsole.log(foo); // 25

Pat ja mainīgais foo nav definēts nekur ārpus joslas funkcijas, tas tomēr ir pieejams ārpus funkcijas ārējā kontekstā.

Tas būtu savādāk, ja mēs ne tikai piešķirtu vērtību mainīgajam, bet arī to definētu:

Funkciju josla())( var foo = "25"; ) bar(); konsole.log(foo); // kļūda

Globālo mainīgo definēšana funkcijās var novest pie iespējamās kļūdas. Lai no tiem izvairītos, izmantojiet stingro režīmu:

"izmantojiet stingri"; funkcija bar())( foo = "25"; ) bar(); konsole.log(foo);

Šajā gadījumā mēs saņemsim kļūdu SyntaxError: Unexpected identifier, kas norāda, ka mainīgais foo nav definēts.

Ir divi veidi, kā iestatīt stingro režīmu:

JavaScript koda sākumā pievienojiet izteicienu "izmantot stingru", tad stingrais režīms tiks piemērots visam kodam

funkcijas pamatteksta sākumā pievienojiet izteicienu "use range", tad stingrais režīms tiks piemērots tikai šai funkcijai

Mainīgie lielumi

Lai JavaScript varētu izmantot mainīgo, tas ir jādeklarē. Mainīgie tiek deklarēti, izmantojot atslēgvārdu var šādi:

Var i; var summa;

Vienreiz izmantojot atslēgvārdu var, varat deklarēt vairākus mainīgos:

Mainīgo deklarēšanu var apvienot ar to inicializēšanu:

Var ziņojums = "sveiki"; var i = 0, j = 0, k = 0;

Ja priekšrakstā var nav norādīta sākotnējā vērtība, mainīgais tiek deklarēts, bet tā sākotnējā vērtība paliek nedefinēta, līdz programma to maina.

Ja jums ir pieredze programmēšanas valodu izmantošanā ar statiskiem datu tipiem, piemēram, C# vai Java, varat pamanīt, ka JavaScript mainīgo deklarācijās trūkst tipa deklarācijas. JavaScript mainīgie var saglabāt jebkura veida vērtības. Piemēram, JavaScript variējam mainīgajam var piešķirt numuru un pēc tam tam pašam mainīgajam piešķirt virkni:

Var i = 10; i = "sveiki";

Izmantojot var paziņojumu, vienu un to pašu mainīgo var deklarēt vairāk nekā vienu reizi. Ja atkārtotajā deklarācijā ir inicializētājs, tā darbojas kā parasts piešķiršanas paziņojums.

Ja mēģināt nolasīt nedeklarēta mainīgā vērtību, JavaScript ģenerēs kļūdu. Stingrajā režīmā, ko nodrošina ECMAScript 5 standarts, kļūda tiek parādīta arī, mēģinot piešķirt vērtību nedeklarētam mainīgajam. Tomēr vēsturiski un, ja tas netiek izpildīts stingrā režīmā, ja piešķirat vērtību mainīgajam, kas nav deklarēts ar priekšrakstu var, JavaScript izveidos šo mainīgo kā globālā objekta īpašību, un tas darbosies tāpat kā pareizi deklarēts mainīgais. Tas nozīmē, ka globālie mainīgie nav jādeklarē. Tomēr tas tiek uzskatīts par sliktu ieradumu un var būt kļūdu avots, tāpēc vienmēr mēģiniet deklarēt savus mainīgos, izmantojot var.

Mainīgā lieluma apjoms ir tā programmas daļa, kurai mainīgais ir definēts. Globālajam mainīgajam ir globāls tvērums — tas ir definēts visai JavaScript programmai. Tajā pašā laikā mainīgie, kas deklarēti funkcijā, tiek definēti tikai tās pamattekstā. Tos sauc par vietējiem, un tiem ir lokāls darbības joma. Funkciju parametri tiek uzskatīti arī par vietējiem mainīgajiem, kas definēti tikai šīs funkcijas pamattekstā.

Funkcijas pamattekstā vietējam mainīgajam ir prioritāte pār globālo mainīgo ar tādu pašu nosaukumu. Ja deklarējat lokālo mainīgo vai funkcijas parametru ar tādu pašu nosaukumu kā globālajam mainīgajam, globālais mainīgais faktiski tiks paslēpts:

Var rezultāts = "globāls"; funkcija getResult() ( var rezultāts = "local"; atgriešanās rezultāts; ); konsole.log(getResult()); // Parādīt "vietējo"

Deklarējot mainīgos ar globālo tvērumu, var priekšrakstu var izlaist, bet, deklarējot lokālos mainīgos, vienmēr jāizmanto var priekšraksts.