Js tekevät muuttujan globaaliksi. JavaScript. Muuttujat (globaalit, paikalliset, vakiot). Unohdetun var-ilmoituksen sivuvaikutus

Jatkamme JavaScriptin funktioiden aiheen tutkimista. Tässä käsittelemme muuttuvan laajuuden käsitettä. Se liittyy läheisesti toimintoihin, joten on tärkeää ymmärtää se.

Pitäisi opetella (ja erottaa nämä käsitteet) vain yksi asia on, että muuttujat ovat globaaleja ja paikallisia.

Mitä ovat globaalit muuttujat? Katsotaanpa esimerkkiä...

var globaali = 21; /* Luo globaali muuttuja */

function myFun () /* Luo funktio, joka näyttää muuttujan */
{
document.write(global);
}

myFun(); /* Kutsu funktiota */

Tässä esimerkissä loimme globaalin muuttujan, joka on globaali - nyt voimme käyttää sitä - esimerkiksi funktion sisään, kuten näet itse.

Tämä on globaalien muuttujien ydin - ne luodaan kerran (Oletaanko käsikirjoituksen alussa, kuten näit esimerkissä) ja käytetään sitten ohjelmakoodissa tarvittaessa (taulukoissa, funktioissa jne.).

Mitä ovat paikalliset muuttujat? Katsotaanpa taas esimerkkiä...

funktio myFun _2 () /* Luo funktio */
{

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

myFun_2(); /* Kutsu funktiota */

Tämä esimerkki havainnollistaa paikallisen muuttujan local luomista. Se on paikallinen, koska se luodaan funktion sisällä. Ja sitä voi käyttää vain sen sisällä.

Jos yritämme näyttää tämän muuttujan funktion ulkopuolella, emme näe selainikkunassa mitään.

funktio myFun _2 () /* Luo funktio */
{

var paikallinen = 42 ; /* Luo paikallinen muuttuja */
document.write(local);
}

document.write(local); /* Yritetään näyttää paikallinen muuttuja funktion ulkopuolella */

Näillä yksinkertaisilla esimerkeillä tarkastelimme muuttujan laajuuden käsitettä JavaScriptissä. Todetaan sen olemus vielä kerran: jos luomme muuttujan funktion sisään, niin se on paikallinen ja voimme työskennellä sen kanssa vain tämän funktion sisällä.

Ja funktion ulkopuolella luotuja muuttujia kutsutaan globaaleiksi ja niitä voidaan käyttää missä tahansa, myös funktion sisällä.

Hyvää päivää JavaScript-fanit ja uskolliset tilaajani. Tämän päivän viestissä kerron sinulle yksityiskohtaisesti siitä, kuinka globaaleja ja paikallisia muuttujia luodaan JavaScriptissä. Ehdottomasti määrittelen tärkeitä termejä, puhun muuttujien ilmoittamisen ja alustamisen ominaisuuksista, kuvailen mikä on soveltamisala ja miten luodut elementit toimivat siinä.

Kaikki tämä koskee kielen alkeellista perustietoa. Ilman kaikkea tätä et voi siirtyä eteenpäin ja kehittää js-ohjelmointitaitojasi. Lisäksi avainkäsitteet ovat hyödyllisiä sinulle ei vain tällä erikoisalalla, vaan myös IT-alalla yleensä. No, aloitetaan!

Mikä on muuttuja ja miten se luodaan?

Muuttuja on ohjelmointikielen elementti, jolle on varattu muistialue ja johon on tallennettu tiettyjä arvoja.

Muuttujia voi olla valtava määrä, ja niillä kaikilla on oltava yksilöllinen nimi.

Muuttujia on kahdenlaisia: globaaleja ja paikallisia. Niiden ero on vain muuttujien erilaisessa laajuudessa. Globaalit elementit ovat siis näkyvissä koko koodissa ja paikalliset vain pienellä alueella, jossa ne on ilmoitettu.

Muuten, yritä kutsua elementtejä loogisilla ja ymmärrettävillä nimillä ensimmäisestä päivästä, ensimmäisestä koodistasi lähtien. Koska myöhemmin, kun työskentelet raskaiden ohjelmien kanssa, et jonkin ajan kuluttua muista, mitä esimerkiksi "aa1" tai "perem3" tarkoittaa.

Eikä otsikosta saa selvää yhtään mitään! Tämä ei ole niin paha, loppujen lopuksi ei ole niin vaikeaa ymmärtää kirjoituksiasi. Mitä teet, jos saat tehtäväksi suorittaa tehtäviä toisessa ohjelmassa, josta et ole koskaan ennen kuullutkaan? Tällaisilla nimillä ohjelmiston toteutuksen analysointi tappaa paljon hyödyllistä aikaa.

Olen lukenut merkinnän, nyt palataan muuttujien ilmoittamiseen.

Jos haluat luoda muuttujan, sinun on ensin kirjoitettava avainsana var ja sitten itse nimi. Tältä se näyttää:

var text = "Hei käyttäjä!"

Tämän jälkeen tekstiin päästään ilman "var":ta:

text = "Uusi teksti."

Tässä tapauksessa arvo korvataan.

Ymmärtääksesi paremmin, harkitse esimerkkiä, jossa luodaan yksi muuttuja. Käsittelemme sen merkitystä ennen uudelleenkirjoittamista ja sen jälkeen.

1 2 3 4

var text = "Hei käyttäjä!"; hälytys(teksti); // tulostaa "Hei, käyttäjä!" text= "Uusi teksti!"; hälytys(teksti); // tulostaa "Uusi teksti!"

var text = "Hei käyttäjä!"; hälytys(teksti); // tulostaa "Hei, käyttäjä!" text= "Uusi teksti!"; hälytys(teksti); // tulostaa "Uusi teksti!"

Globaalien objektien ominaisuudet

Kaikki js-koodissa luodut objektit on jaettu globaaleihin ja paikallisiin. Yllä selitin, mikä ero niillä on. Katsotaanpa nyt lähemmin globaaleja esineitä.

Ne ovat kaikki toimintoja ja muuttujia, jotka on ilmoitettu koodin pääosassa, ts. ei sisällä minkään toiminnon. Kaikista niistä tulee js:ssä automaattisesti globaalin objektin ominaisuuksia, joka on selaimissa selkeästi saatavilla sanaikkunan alla. Katsotaanpa esimerkkiä.

var hinta = 145; // luo globaali muuttuja

hälytys(ikkuna.hinta); // vastaus: 145

Toistaiseksi kaikki on yksinkertaista, mutta varaudu sudenkuoppiin. Joskus voit korvata erittäin tärkeitä parametreja tietämättä muuttujien arvojen tallennuksen ja päällekirjoituksen yksityiskohtia. Tällaisia ​​virheitä on melko vaikea jäljittää, ja niitä on mahdotonta löytää kääntäjien avulla. Siksi analysoi seuraava materiaali huolellisesti.

Sudenkuopat ja laajuus

Ymmärtääkseni ongelmaa paremmin esitän ensin pienen ohjelman, jossa luon funktioon paikallisen muuttujan ja sitten sen rajojen ulkopuolelle - globaalin.

funktio testi() ( p = 2; return p; ) hälytys(p); // undefined p = "tärkeää tekstiä"; hälytys(p); // näyttää "tärkeää tekstiä" testi(); // kutsua funktiota alert(p); // tulostaa 2

Aluksi testifunktiossa alustin paikallisen muuttujan arvolla 2 ja loin sitten globaalin tekstimuuttujan, joka tallentaa tärkeitä tietoja.

Ja tässä se "vedenalainen lohko" ponnahtaa esiin.

Ensinnäkin johtuen siitä, että käytin elementtien luomista vanhentuneen JavaScript-standardin sääntöjen mukaisesti, kaikki "p"-muuttujat luotiin vasta määrityshetkellä (var-direktiiviä käytettäessä muuttujat luodaan välittömästi arvolla undefined, ja alustuksen aikana "= » arvo korvataan).

Toiseksi, tässä tapauksessa arvon määrittämiseksi implisiittisesti luoduille elementeille js:ssä käytetään olemassa olevaa globaalia muuttujaa tai luodaan uusi. Siksi yllä olevassa esimerkissä testifunktion kutsun jälkeen globaalin "p":n arvo menetettiin.

Vältä kaatumiset käyttämällä aina avainsanaa var. Sitten kaikki objektit ilmoitetaan eksplisiittisesti ja uusia luodaan.

Tässä korjattu esimerkki:

toimintotesti() ( var p = 2; hälytys (p); return p; ) hälytys(p); // undefined var p = "tärkeää tekstiä"; hälytys(p); // näyttää "tärkeää tekstiä" testi(); // kutsua funktiota, tässä tapauksessa se näyttää 2 alert(p); // näyttää "tärkeää tekstiä"

Nyt koodi toimii oikein. Kuten huomasit, paikallisen "p":n laajuus on testifunktion sisällä ja globaali on muussa koodissa.

Muutama sana vakioista

Kuten kaikilla muilla ohjelmointikielillä, JavaScriptillä on vakioita. Niille, jotka eivät tiedä mitä se on, liitän määritelmän.

Vakio on muuttujan tyyppi, jonka arvo pysyy muuttumattomana.

Js:n syntaksin sääntöjen mukaan heidän nimensä kirjoitetaan aina pienillä (isoilla) kirjaimilla. Esimerkiksi,

var MAIN_COLOR = "#fff"

Skriptikielessä ei ole teknisiä ominaisuuksia, jotka tekisivät vakiosta todella vakion. Itse asiassa ne ovat tavallisia muuttujia, jotka voidaan kirjoittaa päälle. Sääntöjen mukaan kehittäjät kuitenkin käyttävät näitä elementtejä isoilla kirjaimilla nimessä vakioina eivätkä muuta niiden merkitystä koodia kirjoittaessaan.

Vakioiden päätarkoitus on tallentaa monimutkaisia ​​merkkijonoja, tärkeitä numeroita tai muita arvoja, joihin uudelleen kirjoitettaessa on helppo tehdä kirjoitusvirhe tai niitä ei pidä koskaan muuttaa, tai yksinkertaistaa koodia. Vakioihin voidaan esimerkiksi tallentaa usein toistuvia pyyntöjä

JavaScriptissä on kaksi laajuutta: paikallinen ja globaali. Riippuu siitä, missä muuttuja on ilmoitettu, funktion sisällä vai funktion ulkopuolella.

Jos muuttuja on ilmoitettu funktion sisällä, sitä kutsutaan paikalliseksi, jos muuttuja ilmoitetaan funktion ulkopuolella, sitä kutsutaan globaaliksi.

Nykyaikainen ohjelmointikonsepti suosittelee, että kaikki skriptien (ohjelmien) muuttujat ovat paikallisia, ja itse ohjelma koostuu vain funktioista, joissa jokainen toiminto suorittaa vain yhden tehtävän. Esimerkiksi toisessa web-ohjelmointikielessä, PHP:ssä, he luopuivat kokonaan globaalien muuttujien käytöstä.

Globaalit muuttujat JavaScriptissä

Globaalit muuttujat ilmoitetaan funktioiden ulkopuolella ja niihin voidaan päästä (pääsy) mistä tahansa funktiosta tai ohjelmarivistä.

Var Venäjä; Venäjä = "Venäjä"; funktio getValueRussia() ( hälytys(Venäjä); ) getValueRussia();

Tässä Venäjä on globaali muuttuja, koska se on ilmoitettu funktion ulkopuolella. Todistaaksemme, että muuttuja on globaali, käytimme sitä getValueRussia()-käyttäjäfunktion sisältä käyttämällä alert()-funktiota, joka näytti venäjä-muuttujan arvon.

Paikalliset muuttujat JavaScriptissä

JavaScriptin paikalliset muuttujat ilmoitetaan funktioiden sisällä. Voit käyttää paikallisia muuttujia vain siinä funktiossa, jossa ne on ilmoitettu.

Funktio getValueRussia() ( var russia; russia = "Venäjä"; ) alert(Venäjä);

Tässä esimerkissä mitään ei tapahdu ("Venäjä" -ikkunaa ei tule näkyviin), ja jos tarkastelemme komentosarjaa konsolin kautta, se kertoo meille, että russia-muuttuja on määrittelemätön, mikä tarkoittaa, että alert()-funktio (sijaitsee funktion ulkopuolella), ei näe funktion sisällä luotua russia-muuttujaa.

Funktio getValueRussia() ( var russia; russia = "Venäjä"; alert(Venäjä); ) getValueRussia();

Sijoittamalla alert()-funktion funktion sisään ja kutsumalla sitten getValueRussia()-funktiota, näemme ikkunan, jossa on teksti "Venäjä". Nämä esimerkit osoittavat, että paikallisia muuttujia voidaan käyttää vain siinä funktiossa, jossa ne on luotu.

Kaikki globaalit muuttujat ja funktiot ovat itse asiassa erityisobjektin, jota kutsutaan globaaliksi objektiksi, ominaisuuksia ja menetelmiä.

Globaali objekti on tavallinen objekti, joka luodaan automaattisesti tulkin käynnistyessä.

JavaScriptissä yleisen objektin roolia esittää Window-objekti. Tällä objektilla on ikkunaominaisuus, joka viittaa itse ikkunaobjektiin. Ikkuna-objekti on sekä globaali objekti että lisäksi se sisältää useita omia ominaisuuksia ja menetelmiä työskennellä selainikkunan kanssa.

Ylätason koodissa voit myös viitata globaaliin objektiin käyttämällä tätä avainsanaa:

Alert(this === ikkuna); // totta

Koska globaalit muuttujat ovat globaalin objektin ominaisuuksia, työskentelemme globaalin muuttujan kanssa itse asiassa ikkunan ominaisuuksien kanssa:

Var num = 10; alert(window.num); // 10

Sen sijaan, että ilmoittaisit muuttujan avainsanalla var, voit luoda muuttujan määrittämällä nimenomaisesti uuden ominaisuuden Window-objektille:

Window.num = 10; hälytys(numero); // 10

Huomaa, että vaikka globaalit muuttujat ovat itse asiassa Window-objektin ominaisuuksia, muuttujan nimeä ei tarvitse lisätä:

Var num = 10; hälytys(numero); // 10 hälytys(window.num); // 10. Sama kuin alert(num);

Jos yleinen muuttuja ilmoitetaan käyttämällä var- tai let-avainsanaa, luodaan ei-konfiguroitavissa oleva ominaisuus, eli ominaisuus, jota ei voi poistaa delete-operaattorilla:

Var num = 10; hälytys(poista numero); // false, muuttujaa ei poisteta

Jos määrität arvon ilmoittamattomalle muuttujalle, JavaScript-tulkki luo automaattisesti yleisen muuttujan. Tällä tavalla luoduista muuttujista tulee globaalin objektin säännöllisiä, mukautettuja ominaisuuksia, eli ne voidaan poistaa delete-operaattorilla:

Num = 10; hälytys(poista numero); // tosi, muuttuja poistettu

menetelmät Menetelmän kuvaus

decodeURI()	Palauttaa merkkijonon, joka sisältää dekoodatun URI:n.
decodeURIComponent()	Palauttaa merkkijonon, joka sisältää URI:n dekoodatun osan.
encodeURI()	Palauttaa merkkijonon, joka sisältää koodatun URI:n.
encodeURIComponent()	Palauttaa merkkijonon, joka sisältää URI:n koodatun osan.
eval()	Funktio eval() suorittaa sille merkkijonona välitetyn koodin. Funktiolle välitetty koodi suoritetaan alueella, jossa funktiota kutsuttiin.
isFinite()	Muuntaa argumentin luvuksi (tarvittaessa) ja palauttaa tosi, jos argumentissa on jokin muu arvo kuin NaN, positiivinen ääretön ja negatiivinen ääretön. Näissä kolmessa tapauksessa se palauttaa epätosi.
isNaN()	Määrittää, onko hyväksytty argumentti NaN vai ei.
parseFloat()	Jäsentää merkkijonoargumentin ja palauttaa liukulukuluvun tai NaN:n.
parseInt()	Jäsentää merkkijonoargumentin ja palauttaa kokonaisluvun tai NaN:n.

Tämä neliosainen opetusohjelma kattaa laadukkaan JavaScript-koodin kirjoittamisen, jota on helppo ylläpitää ja kehittää, vaikka joutuisit palaamaan projektiin pitkän ajan kuluttua.

Kirjoita koodi sillä odotuksella, että sitä on tuettava

Ohjelmistovirheillä on hintansa. Niiden hinta ilmaistaan ​​ajassa, joka kuluu niiden korjaamiseen. Virheet julkisesti käynnistetyissä projekteissa ovat erityisen kalliita. On erittäin hyvä, jos voit korjata virheet heti, kun koodirakenne on vielä tuoreessa muistissa, ja voit löytää ongelma-alueen nopeasti. Mutta jos olet siirtynyt muihin tehtäviin ja olet jo unohtanut tietyn koodin ominaisuudet, projektiin paluu vaatii:

• Aika tutkia ja ymmärtää ongelma.
• On aika ymmärtää ongelman aiheuttava koodi.

Toinen suuriin projekteihin tai yrityksiin vaikuttava ongelma on se, että virheiden korjaaja ei ole sama henkilö, joka tekee ne (eikä usein löydä niitä projektista). Siksi koodin ymmärtämiseen kuluvan ajan lyhentäminen tulee kriittiseksi ongelmaksi riippumatta siitä, kirjoititko koodin itse jokin aika sitten vai onko sen kirjoittanut toinen tiimisi kehittäjä. Vastaus kysymykseen vaikuttaa merkittävästi sekä projektin taloudelliseen tulokseen että kehittäjien tyytyväisyyteen, koska joskus on parempi tehdä kaikki uudella tavalla kuin viettää tunteja ja päiviä vanhan, käsittämättömän koodin ylläpitämiseen.

Toinen tosiasia ohjelmistokehityksestä on, että se kestää yleensä kauemmin lukeminen koodia, ei sen luomista. Kun ongelma alun perin ilmaistaan, kehittäjä keskittyy ja uppoutuu kysymykseen, jonka jälkeen istuu alas ja voi luoda merkittävää koodia yhdessä illassa. Koodi luultavasti silloin toimii, mutta ohjelmistotuotteiden luonnollisessa luonteessa syntyy tilanteita, jotka vaativat toistuvia koodin revisioita. Esimerkiksi:

• Virheet havaitaan.
• Projektiin on lisätty uusia ominaisuuksia.
• Sovellus on käynnistettävä uudessa ympäristössä (esimerkiksi uusi selain on ilmestynyt).
• Koodin tarkoitus muuttuu.
• Koodi on kirjoitettava kokonaan uudelleen tai siirrettävä toiselle arkkitehtuurille tai ohjelmointikielelle.

Seurauksena on, että koodin kirjoittamiseen kuluu useita työtunteja ja lukemiseen useita työpäiviä. Siksi helposti ylläpidettävän koodin luominen on ratkaisevan tärkeää sovelluksen menestyksen kannalta.

Helposti ylläpidettävällä koodilla on seuraavat ominaisuudet:

• Se on helppo lukea.
• Se on hyvin jäsennelty ja osat ovat yhdenmukaisia ​​keskenään.
• Hän on ennustettavissa.
• Näyttää siltä, ​​että sen on kirjoittanut yksi henkilö.
• Dokumentoitu.

Globaalien muuttujien käytön minimoiminen

JavaScript käyttää toimintoja kontekstin hallintaan. Funktioiden sisällä ilmoitetut muuttujat ovat niille paikallisia, eivätkä ne ole käytettävissä funktioiden ulkopuolella. Globaalit muuttujat ilmoitetaan funktioiden ulkopuolella tai niitä käytetään yksinkertaisesti ilman ilmoitusta.

Jokaisessa JavaScript-ympäristössä on globaali objekti, jota käytetään funktioiden ulkopuolella. Jokaisesta luomastasi globaalista muuttujasta tulee globaalin objektin ominaisuus. Selaimissa yleisessä objektissa on mukavuussyistä ylimääräinen ominaisuus nimeltä ikkuna, joka (yleensä) osoittaa itse globaaliin objektiin. Seuraava koodi näyttää esimerkin globaalien muuttujien luomisesta ja käyttämisestä selainympäristössä:

Var myglobal = "hei"; console.log(myglobal); // "hello" konsoli.log(window.myglobal); // "hei" konsoli.log(window["myglobal"]); // "hello" console.log(this.myglobal); // "Hei"

Ongelmia globaalien muuttujien kanssa

Yleisten muuttujien ongelmana on, että ne ovat käytettävissä koko sovelluksesi tai sivusi JavaScript-koodissa. Ne ovat globaalissa nimiavaruudessa, ja aina on mahdollisuus nimeämistörmäyksiin, joissa sovelluksen kaksi eri osaa määrittelevät globaaleja muuttujia samalla nimellä, mutta eri tarkoituksiin.

Lisäksi verkkosivu sisältää yleensä muiden kehittäjien kirjoittamaa koodia. Esimerkiksi:

• Muut JavaScript-kirjastot.
• Käsikirjoitukset mainoskumppaneilta.
• Koodi käyttäjien seurantaa ja analytiikkaa varten.
• Erilaisia ​​widgetejä, painikkeita ja laajennuksia.

Oletetaan, että jossakin kolmannen osapuolen komentosarjassa on määritelty globaali muuttuja, jota kutsutaan esimerkiksi tulokseksi. Sitten määrität toisen globaalin muuttujan johonkin funktioistasi ja kutsut sitä tulokseksi. Tämän seurauksena tulosmuuttujan viimeinen ilmoitus ohittaa ensimmäisen, ja kolmannen osapuolen komentosarja saattaa lakata toimimasta.

Siksi eri koodien yhdistäminen yhdelle sivulle on tärkeää käyttää mahdollisimman vähän globaaleja muuttujia. Tässä asiassa var-direktiivin käyttö muuttujien ilmoittamisessa on tärkeä rooli.

Valitettavasti on erittäin helppoa tahattomasti luoda globaali muuttuja JavaScriptiin sen kahden ominaisuuden vuoksi. Ensinnäkin voit käyttää muuttujaa ilmoittamatta sitä. Toiseksi JavaScriptillä on implisiittisen globaalin määritelmä, mikä tarkoittaa, että mistä tahansa ilmoittamattomasta muuttujasta tulee globaalin objektin ominaisuus (ja se on käytettävissä oikein ilmoitettuna globaalina muuttujana). Esimerkiksi:

Funktio summa(x, y) ( // huono: oletettu globaali tulos = x + y; palauttaa tulos; )

Tässä koodissa tulosmuuttujaa käytetään ilman ilmoitusta. Koodi toimii hyvin, mutta funktion kutsumisen jälkeen päädyt toiseen tulosmuuttujaan globaalissa nimiavaruudessa, mikä voi johtaa ongelmiin.

Minimointisääntö on määrittää muuttujat käyttämällä var-direktiiviä. Alla on parannettu versio summa()-funktiosta:

Funktio summa(x, y) ( var tulos = x + y; palauttaa tulos; )

Toinen huono vaihtoehto implisiittisten globaalien luomiseen on ketjuttaa arvo var-ilmoituksessa. Seuraavassa esimerkissä muuttuja a on paikallinen ja muuttuja b globaali, mikä ei todennäköisesti ole koodin luojan tarkoitus:

// huono, älä käytä funktiota foo() ( var a = b = 0; // ... )

Jos olet yllättynyt siitä, mitä tapahtuu, kyse on oikealta vasemmalle -laskelmista. Lause b = 0 suoritetaan ensin, ja siksi muuttujaa b ei ilmoiteta. Lausekkeen palautusarvo on 0, ja se määrätään uudelle paikalliselle muuttujalle a, jonka var-direktiivi ilmoittaa. Tämä muuttujien määritelmä vastaa seuraavaa merkintää:

Var a = (b = 0);

Jos olet jo ilmoittanut muuttujat, ketjutettu esitys toimii hyvin eikä luo ei-toivottuja globaaleja muuttujia:

Funktio foo() ( var a, b; a = b = 0; // molemmat muuttujat ovat paikallisia )

Toinen syy välttää globaalien muuttujien käyttöä on koodin siirrettävyys. Jos aiot suorittaa koodin eri ympäristössä, globaalit muuttujat voivat korvata objektit, jotka eivät ole alkuperäisessä ympäristössä (joten saattaa vaikuttaa siltä, ​​että käyttämäsi nimi on turvallinen).

Unohdetun var-ilmoituksen sivuvaikutus

Eksplisiittisesti määriteltyjen ja implisiittisten globaalien muuttujien välillä on pieni ero. Se on kyky poistaa muuttuja käyttämällä delete-operaattoria:

• Globaalia muuttujaa, joka on ilmoitettu var-määrityksellä (joka on luotu funktioiden ulkopuolella olevassa ohjelmassa), ei voida poistaa.
• Ilman ilmoitusta luotu oletettu globaali muuttuja (riippumatta siitä, missä se on luotu) voidaan poistaa.

Teknisesti oletettu globaali muuttuja on globaalin objektin ominaisuus, ei muuttuja. Ominaisuudet voidaan poistaa käyttämällä delete-operaattoria, mutta muuttujat eivät voi:

// määritä kolme globaalia muuttujaa var global_var = 1; globaali_novar = 2; // huono (funktio () ( global_fromfunc = 3; // huono )()); // Yritetään poistaa global_var; // väärä poista global_novar; // true delete global_fromfunc; // true // Tarkistetaan global_varin poistotyyppi; // "numero"-tyyppi global_novar; // "määrittämätön" global_fromfunc-tyyppi; // "määrittämätön"

Pääsy maailmanlaajuiseen kohteeseen

Selaimissa globaali objekti on käytettävissä missä tahansa koodissasi ikkuna-ominaisuuden kautta (ellet tee jotain erityistä tai odottamatonta, kuten ilmoitat paikallista muuttujaa nimeltä ikkuna). Mutta muissa ympäristöissä tämä käyttömukavuusominaisuus voi olla käytettävissä eri tavalla (tai ei edes ohjelmoijan käytettävissä). Jos tarvitset pääsyn yleiseen objektiin ilman ikkunan tunnistetta, voit käyttää seuraavaa menetelmää millä tahansa sisäkkäisen funktion nimitilan tasolla:

Muutt globaali = (funktio () ( palauttaa tämän; )());

Näin ollen on aina mahdollista päästä käsiksi globaaliin objektiin, koska funktiona kutsutun funktion sisällä (eikä rakentajana uudella ilmoituksella) tämä osoittaa aina globaaliin objektiin.

Yksittäinen ilmoitusmalli var

Yksittäisen var-ilmoituksen käyttäminen funktion yläosassa on erittäin hyödyllinen käytäntö. Tällä menetelmällä on seuraavat edut:

• Tarjoaa yhden paikan funktion kaikkien paikallisten muuttujien ilmoittamiseen.
• Estää loogiset virheet, kun muuttujaa käytetään ennen sen ilmoittamista.
• Auttaa muistamaan paikallisten muuttujien ilmoittamisen ja vähentää siten globaalien muuttujien määrää.

Malli, jossa on yksi var-ilmoitus, näyttää tältä:

Funktio func() ( var a = 1, b = 2, summa = a + b, omaobjekti = (), i, j; // Funktiokoodi... )

Käytät yhtä var-ilmoitusta useiden muuttujien ilmoittamiseen pilkuilla erotettuina. Erinomainen lisäys olisi alustaa muuttujat lähdetiedoilla niiden ilmoittamisen yhteydessä. Tämä estää loogiset virheet (kaikki alustamattomat muuttujat ovat oletusarvoisesti määrittämättömiä) ja parantaa koodin luettavuutta. Kun katsot koodia myöhemmin, voit määrittää muuttujan tarkoituksen sen alkuarvon perusteella (esimerkiksi näet heti, että se on objekti tai kokonaisluku).

Voit myös suorittaa toiminnon muuttujan ilmoitukselle, kuten summa = a + b edellisestä esimerkkikoodista. Toinen toimiva esimerkki on DOM-manipulaatio. Voit määrittää viittauksia DOM-elementteihin paikallisiin muuttujiin, kun ilmoitat:

Funktio updateElement() ( var el = document.getElementById("tulos"), style = el.style; // suorittaa operaatioita el:llä ja tyylillä... )

Nosto: ongelma hajallaan olevien var-ilmoitusten kanssa

JavaScript sallii useita var-määrityksiä missä tahansa funktiossa, ja ne toimivat samalla tavalla sijoittelusta riippumatta. Tätä ominaisuutta kutsutaan "nostoksi". Tämä toiminta voi johtaa loogisiin virheisiin, kun käytät muuttujaa ja määrität sen sitten myöhempää funktiokoodia varten. JavaScriptille, koska muuttuja on samassa nimiavaruudessa (samassa funktiossa), sen oletetaan olevan ilmoitettu, vaikka sitä käytettäisiin ennen var-direktiiviä. Esimerkiksi

// huono omanimi = "globaali"; // yleinen muuttujafunktio func() ( alert(omanimi); // "määrittämätön" var myname = "local"; alert(omanimi); // "paikallinen" ) func();

Tässä esimerkissä ensimmäisen kutsun to alert() odotetaan tuottavan viestin "global" ja toisen kutsun "local". Kohtuullinen odotus, koska ensimmäisessä kutsussa paikallista muuttujaa myname ei ilmoiteta ja funktion on käytettävä globaalia muuttujaa myname. Mutta todellisuudessa asiat toimivat toisin. Ensimmäinen alert()-kutsu palauttaa "undefined", koska omaa nimeä käsitellään funktiossa ilmoitettuna paikallisena muuttujana (vaikka ilmoitus tulee myöhemmin). Kaikki muuttujailmoitukset nostetaan funktion yläosaan. Siksi tämän tyyppisten virheiden välttämiseksi sinun on ilmoitettava kaikki muuttujat funktion yläosassa.

Edellinen esimerkki toimii ikään kuin se olisi toteutettu näin:

Omanimi = "maailmanlaajuinen"; // yleinen muuttujafunktio func() ( var myname; // sama kuin -> var omanimi = undefined; alert(omanimi); // "undefined" myname = "local"; alert(myname); // " local" ) func();

On syytä mainita, että koodin varsinainen toteutus on monimutkaisempaa. Koodinkäsittelyssä on kaksi vaihetta. Ensimmäisessä vaiheessa luodaan muuttujat, funktioilmoitukset ja muodolliset parametrit sekä määritellään konteksti. Toinen vaihe suorittaa koodin, arvioi funktiot ja luo määrittelemättömät tunnisteet (ilmoittamattomat muuttujat). Mutta käytännön käyttöön voit käyttää nosto-käsitettä, joka kuvaa koodin käyttäytymistä hyvin.