Vi fortsätter att studera ämnet funktioner i JavaScript. Här kommer vi att beröra begreppet omfattning av variabler. Det är nära relaterat till funktioner, så det är viktigt att förstå det.
Bör läras (och särskilj dessa begrepp) bara en sak - att variablerna är globala och lokala.
Vad är globala variabler? Tänk på ett exempel...
var global = 21; /* Skapa en global variabel */
function myFun () /* Skapa en funktion som visar en variabel */
{
document.write(global);
}
myFun(); /* Anropa funktionen */
I det här exemplet har vi skapat en global variabel, som är global - nu kan vi använda den - till exempel inuti en funktion, som du själv kan se.
Detta är kärnan i globala variabler - de skapas en gång (låt oss säga i början av manuset, som du såg i exemplet) och används sedan i programkoden vid behov (i arrayer, funktioner etc.).
Vad är lokala variabler? Låt oss titta på exemplet igen...
function myFun _2 () /* Skapa en funktion */
{
var local = 42;
document.write(local);
}
myFun_2(); /* Anropa funktionen */
Det här exemplet illustrerar skapandet av den lokala variabeln local . Det är lokalt eftersom det skapades inuti . Och bara inuti kan den användas.
Om vi försöker visa denna variabel utanför funktionen kommer vi inte att se något i webbläsarfönstret.
function myFun _2 () /* Skapa en funktion */
{
var local = 42; /* Skapa lokal variabel */
document.write(local);
}
document.write(local); /* Försök att visa den lokala variabeln utanför funktionen */
Med dessa enkla exempel har vi utforskat konceptet med variabelt omfång i JavaScript. Än en gång kommer vi att uttrycka dess essens: om vi skapar en variabel inuti en funktion, så är den lokal, och vi kan bara arbeta med den i den här funktionen.
Och variabler som skapas utanför funktionen kallas globala och kan användas var som helst, inklusive inuti funktionen.
Det finns tre omfång i JavaScript: globalt, funktionsomfång och blockomfång. Omfattningen av en variabel är arean källkod program där variabler och funktioner är synliga och kan användas. Den globala räckvidden kallas även toppnivåkod.
Globala variablerEn variabel som deklareras utanför en funktion eller ett block kallas en global variabel. Den globala variabeln är tillgänglig var som helst i källkoden:
varnum = 5; function foo() ( console.log(num); ) foo(); // 5 console.log(num); // 5 ( console. log(num); // 5 )
Lokala variablerEn variabel som deklareras inom en funktion kallas en lokal variabel. En lokal variabel är tillgänglig var som helst i huvuddelen av funktionen där den deklarerades. En lokal variabel skapas varje gång en ny funktion anropas och förstörs när den avslutas (när funktionen slutar):
Funktion foo() ( var num = 5; console.log(num); ) foo(); // 5 console.log(typ av num); // odefinierat
En lokal variabel har företräde framför en global variabel med samma namn, vilket betyder att den lokala variabeln kommer att användas i funktionen snarare än den globala:
var x = "global"; // Global variabel funktion checkscope() ( var x = "local"; // Lokal variabel med samma namn som global document.write(x); // Lokal variabel används, inte global ) checkscope(); // => "lokal" Försök »
BlockvariablerEn variabel som deklareras inuti ett block med nyckelord låt , kallas block . En blockvariabel är tillgänglig var som helst inom blocket där den deklarerades:
letnum = 0; ( låt num = 5; console.log(num); // 5 ( låt num = 10; console.log(num); // 10 ) console.log(num); // 5 ) console.log(num) ; // 0
ÅterannonseringOm du deklarerar om en variabel med samma namn (i samma omfattning) med nyckelordet var, kommer ingenting att hända:
Vara = 10; var a; konsollogg(a); // 10
Om omdeklarationen följs av en initiering, fungerar en sådan instruktion som en normal tilldelning av ett nytt värde:
Vara = 10; var a = 5; // Samma som a = 5; konsollogg(a); // 5
Om du deklarerar om en variabel med samma namn (i samma omfattning) med hjälp av nyckelordet let, kommer ett fel att visas:
Vara = 10; låt a; // Fel.
Kedja av omfattningarTänk på följande exempel:
varnum = 5; function foo() ( var num2 = 10; function bar() ( var num3 = 15; ) )
Det finns tre scopes i den här koden: global scope, foo() function scope och bar() function scope. Variabeln num och funktionen foo() definieras i det globala omfånget. Variabeln num2 och bar()-funktionen definieras i omfattningen av foo()-funktionen, och variabeln num från det globala omfånget är också tillgänglig i den. Omfattningen av bar()-funktionen innehåller en variabel num3 , som endast är tillgänglig i bar()-funktionen. I omfattningen av bar()-funktionen är variabler från de andra två omfattningarna också tillgängliga, eftersom de är överordnade till den. Omfattningskedjan för detta exempel visas i figuren nedan:
I figuren visas olika omfattningar med rektanglar i olika färger. Det inre skopet i scopekedjan kan komma åt allt från de yttre scopen, men de yttre scopen kan inte komma åt något från de inre scopen.
Omfattningskedjan är beställd. Tolken söker i omfattningskedjan efter identifierare utåt, inte inåt. Det betyder att namnsökningen börjar i det omfång där identifieraren användes. Om identifieringsnamnet hittas avslutas sökningen. Om namnet inte kan hittas i det aktuella omfånget, görs sökningen i nästa (yttre) omfång osv. Därmed kommer identifieraren från det omfång som det hittades i att användas. Om identifieraren inte hittas i något av omfånget genererar JavaScript ett fel:
var str = "global"; varnum = 5; function foo() ( var str = "local"; // Använd lokal variabel str num = 10; // Använd global variabel num // alert(x); // Fel. Variabel x finns inte i något omfång ) foo( ) ; alert(str); // "global" alert(num); // 10
Om du tilldelar ett värde till en odeklarerad variabel i funktionskroppen, kommer en ny global variabel att skapas vid tidpunkten för funktionsanropet, om det inte finns någon variabel med samma namn i det globala omfånget:
Funktion foo() ( num = 2; ) foo(); // Skapat en ny global variabel num alert(num); // 2
Lyft annonserI JavaScript är deklarerade variabler tillgängliga var som helst i förhållande till deras omfattning, vilket innebär att variabler är synliga redan innan de deklareras i koden. Denna funktion i JavaScript kallas informellt hissning: kod beter sig som om variabeldeklarationer implicit hissas (utan initialisering) till toppen av deras omfattning.
Tänk på följande kodavsnitt:
var str = "global"; function foo() ( alert(str); // undefined var str = "local"; alert(str); // "local" ) foo();
Om man tittar på koden kan man tro att den första varningen borde mata ut strängen "global" eftersom deklarationen av den lokala variabeln str ännu inte har exekveras. Den faktiska utgången är dock odefinierad . Tack vare deklarationshissning är funktionen ovan likvärdig med implementeringen nedan, där variabeldeklarationen hissas till toppen av funktionen:
Funktion foo() ( var str; // Deklaration av en lokal variabel i början av funktionen alert(str); // Här är den tillgänglig, men inte initialiserad str = "local"; // Här är den initialiserad alert( str); // Och här har det det förväntade värdet - "lokal")
Detsamma gäller för det globala omfånget, variabeln som deklareras längst ner är tillgänglig överst:
Alert(antal); // odefinierat var num = 10; alert(antal); // 10
God dag, JavaScript-fans och mina trogna prenumeranter. I dagens inlägg kommer jag att berätta i detalj om hur globala och lokala variabler skapas i JavaScript. Jag kommer definitivt att ge definitioner på viktiga termer, prata om funktionerna i att deklarera och initiera variabler, beskriva vad ett scope är och hur de skapade elementen fungerar i det.
Allt detta gäller de mest grundläggande, grundläggande kunskaperna i språket. Utan att förstå allt detta kommer du inte att kunna gå vidare och utveckla dina programmeringskunskaper i js. Dessutom kommer nyckelbegrepp att vara användbara för dig inte bara inom denna specialisering, utan också generellt inom IT-området. Nåväl, låt oss börja!
Vad är en variabel och hur skapas den?En variabel är ett sådant element i programmeringsspråket, under vilket ett minnesområde är allokerat och i vilket vissa värden lagras.
Det kan finnas ett stort antal variabler, och de måste alla ha ett unikt namn.
Det finns två typer av variabler: globala och lokala. Deras skillnad ligger bara i variablernas olika omfattning. Så globala element är synliga genom hela koden, och lokala element är endast synliga i ett litet område där de deklarerades.
Försök förresten redan från första dagen, från din första kod, att namnge elementen med logiska och begripliga namn. För vidare, när du arbetar med tungt vägande program, kommer du efter en viss tid inte ihåg vad till exempel "aa1" eller "perem3" betyder.
Och titeln är absolut ingen mening! Det finns fortfarande halva besväret, trots allt är det inte så svårt att förstå dina skriverier. Och vad gör du om du får uppdraget att avsluta uppgifter i ett annat program som du inte ens har hört talas om tidigare? Med sådana namn kommer analys av mjukvaruimplementeringen att döda mycket användbar tid.
Jag läste notationen, låt oss nu återgå till deklarationen av variabler.
För att skapa en variabel måste du först skriva nyckelordet var och sedan själva namnet. Så här ser det ut:
var text = "Hej, användare!"
Efter det nås text utan "var":
text = "ny text."
I det här fallet kommer värdet att skrivas över.
För en bättre förståelse, överväg ett exempel som skapar en enda variabel. Vi kommer att hänvisa till dess värde före och efter omskrivning.
| 1 2 3 4 | var text = "Hej användare!"; alert(text); // skriver ut "Hej, användare!" text="Ny text!"; alert(text); // skriver ut "Ny text!" |
var text = "Hej användare!"; alert(text); // skriver ut "Hej, användare!" text="Ny text!"; alert(text); // skriver ut "Ny text!"
Funktioner av globala objektAlla skapade objekt i js-koden är uppdelade i globala och lokala. Ovan förklarade jag vad skillnaden mellan dem är. Låt oss nu titta närmare på globala objekt.
De är alla funktioner och variabler som deklareras i kodens huvudduk, d.v.s. inte inne i vissa funktioner. Alla i js blir automatiskt egenskaper för det globala objektet, som är explicit tillgängligt i webbläsare under wordfönstret. Tänk på ett exempel.
var pris = 145; // skapa en global variabel
alert(fönster.pris); // svar: 145
Än så länge är allt enkelt, men gör dig redo för fallgroparna. Ibland, utan att känna till detaljerna för att spara och skriva över variabelvärden, kan du skriva över mycket viktiga parametrar. Sådana fel är ganska svåra att spåra och omöjliga att hitta med hjälp av kompilatorer. Så ta en ordentlig titt nästa material.
Fallgropar och omfattningFör en bättre förståelse av problemet kommer jag först att visa ett litet program, där jag skapar en lokal variabel i funktionen, och sedan utanför dess gränser - en global.
function test() ( p = 2; return p; ) alert(p); // undefined p = "viktig text"; alert(p); // skriver ut "viktig text" test(); // anropa funktionen alert(p); // skriver ut 2
Till en början, i testfunktionen, initierade jag en lokal variabel med värdet 2 och skapade sedan en global textvariabel som lagrar en del viktig data.
Och här dyker det där "undervattensblocket" upp.
För det första, på grund av det faktum att jag använde skapandet av element enligt reglerna i den föråldrade JavaScript-standarden, skapades alla "p"-variabler endast vid tilldelningstillfället (när du använder var-direktivet skapas variabler omedelbart med värdet odefinierat, och under initiering genom “= » skrivs värdet över).
För det andra, i det här fallet, använder js en befintlig eller skapar en ny global variabel för att tilldela ett värde till implicit skapade element. I exemplet ovan skrevs därför värdet av det globala "p" över efter anrop av testfunktionen.
Använd alltid nyckelordet var för att undvika att krascha. Då kommer alla objekt att deklareras explicit och nya kommer att skapas.
Här är det korrigerade exemplet:
function test() ( var p = 2; alert (p); return p; ) alert(p); // undefined var p = "viktig text"; alert(p); // skriver ut "viktig text" test(); // anropa funktionen, i detta fall kommer den att skriva ut 2 alert(p); // skriv ut "viktig text"
Nu fungerar koden korrekt. Som du kan se är omfattningen av det lokala "p" inom testfunktionens omfattning, medan omfattningen av den globala finns i resten av koden.
Några ord om konstanterSom alla andra programmeringsspråk har JavaScript konstanter. För de som inte vet vad det är, bifogar jag en definition.
En konstant är en typ av variabel vars värde inte ändras.
Enligt syntaxreglerna i js skrivs deras namn alltid med gemener (versaler). Till exempel,
var MAIN_COLOR = "#fff"
Inte på ett skriptspråk tekniska medel, vilket skulle göra konstanten verkligt konstant. Faktum är att de är vanliga variabler som kan skrivas över. Men enligt reglerna använder utvecklare dessa element med stora bokstäver i namnet som konstanter och under skrivningen av koden ändrar inte deras värde.
Huvudsyftet med konstanter är att lagra komplexa strängar, viktiga siffror eller andra värden där det är lätt att göra ett stavfel vid omskrivning eller i vilket fall inte bör ändras, eller för att förenkla koden. Till exempel kan konstanter lagra ofta upprepade förfrågningar om
Variabler fungerar som "behållare" för att lagra information.
Kommer du ihåg skolalgebra?Kommer du ihåg skolalgebra? x=5, y=6, z=x+y
Kommer du ihåg att en bokstav (som x) kan användas för att lagra ett värde (som 5), och att du kan använda informationen ovan för att beräkna att värdet på z är 11?
Dessa bokstäver kallas variabler, och variabler kan användas för att lagra värden (x=5) eller uttryck (z=x+y).
JavaScript-variablerPrecis som i algebra används JavaScript-variabler för att lagra värden eller uttryck.
Variabeln kan ha ett kort namn som x, eller ett mer beskrivande namn som carname (bilnamn).
Regler för JavaScript-variabelnamn:
Obs: Eftersom JavaScript är skiftlägeskänsligt är variabelnamn också skiftlägeskänsliga.
ExempelVärdet på en variabel kan ändras under skriptkörning. Du kan referera till en variabel med dess namn för att visa eller ändra dess värde.
Deklarera (skapa) JavaScript-variablerAtt skapa variabler i JavaScript kallas oftare för att "deklarera" variabler.
Du deklarerar JavaScript-variabler med nyckelordet var:
Efter att ha utfört förslagen ovan kommer x att innehålla värdet 5 och carname kommer att innehålla värdet Mercedes .
Obs! När du tilldelar ett textvärde till en variabel, omslut det inom citattecken.
Obs: Om du omdeklarerar en variabel kommer den inte att förlora sitt värde.
JavaScript lokala variablerVariabel deklarerad inuti JavaScript-funktioner blir LOKAL och kommer endast att vara tillgänglig inom den funktionen. (variabeln har en lokal räckvidd).
Du kan deklarera lokala variabler med samma namn i olika funktioner eftersom lokala variabler känns igen i funktionen där de deklareras.
Lokala variabler förstörs när funktionen avslutas.
Du kommer att lära dig mer om funktioner i senare JavaScript-lektioner.
JavaScript globala variablerVariabler som deklareras utanför en funktion blir GLOBAL, och alla skript och funktioner på sidan kan komma åt dem.
Globala variabler förstörs när du stänger sidan.
Om du deklarerar en variabel utan att använda "var" blir variabeln alltid GLOBAL.
Tilldela värden till odeklarerade JavaScript-variablerOm du tilldelar värden till variabler som ännu inte har deklarerats, kommer variablerna automatiskt att deklareras som globala variabler.
Dessa förslag:
Du kommer att lära dig mer om operatorer i nästa JavaScript-lektion.
I JavaScript finns det två omfång: lokalt och globalt. Beror på var variabeln deklareras, inuti funktionen eller utanför funktionen.
Om variabeln deklareras inuti funktionen kallas den lokal, om variabeln deklareras utanför funktionen kallas den global.
Det moderna konceptet med programmering rekommenderar att alla variabler i skript (program) är lokala, och själva programmet bör endast bestå av funktioner, där varje funktion endast skulle utföra en uppgift. Till exempel, i ett annat webbprogrammeringsspråk PHP, övergav de i allmänhet användningen av globala variabler.
Globala variabler i JavaScriptGlobala variabler deklareras utanför funktioner och kan nås (åtkomst) från vilken funktions- eller programrad som helst.
Var Ryssland; ryssland = "Ryssland"; function getValueRussia() ( alert(ryssland); ) getValueRussia();
Här är Ryssland en global variabel eftersom den deklareras utanför funktionen. För att bevisa att variabeln är global fick vi åtkomst till den inifrån den anpassade funktionen getValueRussia() med funktionen alert() som visade värdet på russia-variabeln.
Lokala variabler i JavaScriptLokala variabler i JavaScript deklareras inuti funktioner. Lokala variabler kan endast nås inom funktionen där de deklareras.
Funktion getValueRussia() ( var russia; russia = "Russia"; ) alert(ryssland);
I detta exempel, ingenting kommer att hända (fönstret med inskriptionen "Russia" visas inte), och om du tittar på skriptet via konsolen kommer det att berätta för oss att russia-variabeln inte är definierad (odefinierad), vilket betyder att varningen () function (placerad utanför funktionen), ser inte russia-variabeln som skapades inuti funktionen.
Funktion getValueRussia() ( var russia; russia = "Russia"; alert(russia); ) getValueRussia();
Genom att placera funktionen alert() inuti en funktion och sedan anropa funktionen getValueRussia() kommer vi att se en ruta märkt "Russia". Dessa exempel visar oss att lokala variabler endast kan nås inom den funktion där de skapas.
