Javascript-joukon muuttujatyyppi. Kuinka tarkistaa muuttujan tyyppi oikein JavaScriptissä. JavaScript-tyypit ovat dynaamisia
JavaScript-muuttujat voivat tallentaa monenlaisia tietoja - numeroita, merkkijonoja, objekteja ja muita:
muuttujan pituus = 16; // Numero var lastName = "Sidorov"; // Merkkijono var x = (etunimi:"Ivan", sukunimi:"Ivanov"); // Esine
Tietotyypin käsite
Ohjelmoinnissa tietojen kirjoittaminen on erittäin tärkeä käsite.
Jotta muuttujia voidaan käsitellä, on erittäin tärkeää tietää niiden tyypit.
Ilman tietotyyppejä tietokone ei osaa arvioida turvallisesti seuraavanlaista lauseketta:
Muutt x = 16 + "Volvo";
Onko järkevää lisätä numero 16 merkkijonoon "Volvo"? Tuleeko tästä virhe tai jokin järkevä tulos?
JavaScript tulkitsee yllä olevan esimerkin seuraavasti:
Var x = "16" + "Volvo";
Huomio! Kun lisäät numeron ja merkkijonon, JavaScript käsittelee numeroa merkkijonona.
JavaScript arvioi lausekkeet vasemmalta oikealle. Siten eri sekvenssit voivat johtaa erilaisiin tuloksiin:
JavaScript: var x = 16 + 4 + "Volvo"; Tulos: 20Volvo JavaScript: var x = "Volvo" + 16 + 4; Tulos: Volvo164
Ensimmäisessä esimerkissä JavaScript käsittelee numeroita 16 ja 4 numeroina, kunnes se saavuttaa merkkijonon "Volvo".
Toisessa esimerkissä, koska ensimmäinen operandi on merkkijono, myös kaikki seuraavat operandit katsotaan merkkijonoiksi.
JavaScript-tyypit ovat dynaamisia
JavaScriptissä kaikki tietotyypit ovat dynaamisia. Tämä tarkoittaa, että samaa muuttujaa voidaan käyttää erityyppisten tietojen tallentamiseen:
Var x; // x on tyyppiä määrittelemätön x = 5; // nyt x on luku x = "John"; // nyt x on merkkijono
Merkkijonot JavaScriptissä
Merkkijono (tai tekstimerkkijono) on merkkijono, esimerkiksi "Ivan Petrov".
Merkkijonot on kirjoitettava lainausmerkkien sisään. Nämä voivat olla kaksois- tai yksittäislainauksia:
Var carName = "Volvo XC60"; // Lainausmerkkejä käytetään var carName = "Volvo XC60"; // Yksittäisiä lainausmerkkejä käytetään
Voit käyttää merkkijonon sisällä lainausmerkkejä vain, jos ne eroavat merkkijonon sisällä olevista lainausmerkeistä:
Var answer = "Se on kunnossa"; // Yksittäiset lainausmerkit kaksoislainausmerkkien sisällä var answer = "Häntä kutsutaan "Johnnyksi""; // Yksittäiset lainausmerkit kaksoislainausmerkkien sisällä var answer = "Häntä kutsutaan "Johnnyksi""; // Tuplalainausmerkit singlen sisällä
Numerot JavaScriptissä
JavaScriptissä on vain yksi numeerinen tietotyyppi.
Numerot voidaan kirjoittaa desimaalipilkun kanssa tai ilman:
Muutt x1 = 34,00; // Desimaalipilkulla var x2 = 34; // Ilman desimaalipistettä
Erittäin suuria ja hyvin pieniä lukuja voidaan kirjoittaa tieteellisellä (eksponentiaalisella) merkinnällä (näyttää Mep:ltä, jossa M on luku, e tarkoittaa "kerrotaan 10:llä potenssilla...", p on järjestys tai potenssi, johon 10 on nostettu):
Var y = 123e5; // 12300000 var z = 123e-5; // 0,00123
Boolen tiedot JavaScriptissä
Boolen arvoja on kaksi: totta(tosi) ja väärä(valehdella).
Var x = 5; var y = 5; var z = 6; (x == y) // Palauttaa tosi (x == z) // Palauttaa epätosi
Boolen arvoja käytetään usein eri olosuhteiden testaamiseen.
Taulukot JavaScriptissä
JavaScriptin taulukot kirjoitetaan hakasulkeilla.
Taulukon elementit erotetaan pilkuilla.
Seuraava esimerkki ilmoittaa (luo) taulukon nimeltä autot, joka sisältää kolme elementtiä:
Var cars = ["Saab", "Volvo", "BMW"];
Matriisielementtien indeksointi alkaa nollasta. Tämä tarkoittaa, että ensimmäisellä elementillä on indeksi, toisella ja niin edelleen.
Objektit JavaScriptissä
JavaScriptin objektit kirjoitetaan aaltosulkeilla.
Objektin ominaisuudet kirjoitetaan pareina nimi:arvo , Pilkuin erotettu.
Var person = (etunimi:"John", sukunimi:"Doe", ikä:50, eyeColor:"sininen");
Yllä olevassa esimerkissä objekti nimeltä henkilö on 4 ominaisuutta: etunimi, sukunimi, ikä, silmänväri.
operaattorin tyyppi
JavaScriptin muuttujan tietotyypin määrittämiseen käytetään operaattoria tyyppi.
Operaattori tyyppi palauttaa muuttujan tai lausekkeen tietotyypin:
Typeof "" // Palauttaa "string" typeof "John" // Palauttaa "string" typeof "John Doe" // Palauttaa "string" typeof 0 // Palauttaa "number" typeof 314 // Palauttaa "number" typeof 3.14 // Palauttaa "number" typeof (3) // Palauttaa "number" typeof (3 + 4) // Palauttaa "number"
Tyyppi määrittelemätön
JavaScriptissä muuttujilla ilman arvoa on itse asiassa merkitys määrittelemätön. Ja operaattori tyyppi näyttää myös tyypin määrittelemätön.
Var auto; // Arvo määrittelemätön, tyyppi undefined
Mikä tahansa muuttuja voidaan "nollata" antamalla sille arvo määrittelemätön. Hänen tyypistä tulee myös määrittelemätön.
Auto = määrittelemätön; // Arvo määrittelemätön, tyyppi undefined
Tyhjät arvot
Tyhjällä arvolla ei ole mitään tekemistä merkityksen kanssa määrittelemätön.
Tyhjällä merkkijonolla on kelvollinen arvo ja tyyppi.
Var auto = ""; // Arvo "", "merkkijonon" tyyppi
Tyhjä
JavaScriptissä arvo tyhjä tarkoittaa "ei mitään". Se on jotain mitä ei ole olemassa.
Samaan aikaan JavaScriptissä tyyppi tyhjä on esine.
Voit nollata objektin määrittämällä sille arvon tyhjä:
Muut henkilö = (etunimi:"John", sukunimi:"Doe", ikä:50, eyeColor:"sininen"); henkilö = tyhjä; // Nyt arvo tässä on nolla, mutta tyyppi on edelleen objekti
Voit myös nollata kohteen käyttämällä arvoa määrittelemätön:
Muut henkilö = (etunimi:"John", sukunimi:"Doe", ikä:50, eyeColor:"sininen"); henkilö = määrittelemätön; // Nyt tässä arvoa ja tyyppiä ei ole määritetty
Ero määrittelemättömän ja nollan välillä
Määrittämätön Ja tyhjä merkitykseltään samanlainen, mutta tyypiltään erilainen:
Määrittämättömän tyyppi // määrittelemätön null // objekti null === määrittelemätön // false null == määrittelemätön // tosi
Primitiivistä dataa
Primitiiviset tiedot ovat yksittäisiä yksinkertaisia arvoja ilman lisäominaisuuksia ja menetelmiä.
Tässä tapauksessa operaattori tyyppi palauttaa yhden seuraavista primitiivityypeistä:
- merkkijono
- määrä
- boolean
- määrittelemätön
Monimutkainen (monimutkainen) data
JavaScriptissä on kaksi monimutkaista tai monimutkaista tietotyyppiä:
- toiminto
- esine
Operaattori typeof palauttaa tyypin "object" objekteille, taulukoille ja null.
Funktioille typeof-operaattori ei palauta tyyppiä "objekti", vaan "funktio".
Typeof (nimi:"John", ikä:34) // Palauttaa "object" typeof // Palauttaa "object" (ei "array", katso alla) typeof null // Palauttaa "object" typeof function myFunc()() / / Palauta "funktio"
Huomio! Tauluille typeof-operaattori palauttaa tyypin "object", koska taulukot ovat JavaScriptin objekteja.
Tässä opetusohjelmassa esittelemme erittäin tärkeän käsitteen - JavaScript-tietotyypit. Suosittelemme, että kiinnität erityistä huomiota tähän käsitteeseen - jos et ymmärrä sitä alusta alkaen, joudut usein käsittelemään luomasi ohjelman outoa käyttäytymistä.
Dynaaminen kirjoittaminen
Toiminnan aikana tietokoneohjelmat käsittelevät erilaisia arvoja, joista jokainen voidaan käsitellä ohjelmointikielellä ja viittaa tiettyyn tietotyyppiin.
JavaScriptissä tietotyypit voidaan jakaa kahteen luokkaan: yksinkertaisiin (kutsutaan myös primitiivisiksi) ja yhdistelmätyypeiksi (kutsutaan myös viitteeksi tai objektiksi).
JavaScript on heikosti kirjoitettu tai dynaaminen ohjelmointikieli, jonka avulla tietotyyppejä voidaan määritellä, jäsentää ja kääntää lennossa ohjelman suorittamisen aikana. Tämä tarkoittaa, että sinun ei tarvitse määrittää muuttujan tyyppiä etukäteen. Tyyppi määritetään automaattisesti ohjelman suorituksen aikana.
Siten ohjelman eri osissa sama muuttuja voi saada erityyppisiä arvoja:
Tietotyypit
ECMAScript®-standardi määrittelee seuraavat tietotyypit:
- Yksinkertainen(niitä kutsutaan myös primitiivisiksi) tyypit:
- Boolen arvo - voi ottaa kaksi mahdollista arvoa, joita joskus kutsutaan tosi ja epätosi;
- null – arvo null edustaa viittausta, joka osoittaa, yleensä tarkoituksella, olemattomaan tai virheelliseen objektiin tai osoitteeseen;
- undefined – tarkoittaa ennalta määritettyä globaalia muuttujaa, joka on alustettu määrittelemättömällä arvolla;
- numeerinen (englanninkielinen numero) – numeerinen tietotyyppi 64-bittisen kaksinkertaisen tarkkuuden liukulukuluvun muodossa;
- merkkijono (eng. String) – on merkkijono, jota käytetään kuvaamaan tekstiä;
- symboli (eng. Symbol) on tietotyyppi, jonka esiintymät ovat ainutlaatuisia ja muuttumattomia. (uusi ECMAScript 6:ssa).
- Esine(Englanti Object) on kokoelma nimettyjä arvoja, joita yleensä kutsutaan kohteen ominaisuuksiksi (ominaisuuksiksi).
Ero primitiivisten ja komposiittityyppien välillä
Ennen kuin tarkastelemme kutakin tietotyyppiä, tarkastellaan ensin operaattorin tyyppiä. Typeof-operaattori palauttaa muuttujan tietotyyppiä kuvaavan merkkijonon.
Osoitetaan, miten se toimii seuraavan esimerkin avulla:
Esimerkkikomentosarja ilmoittaa muuttujat, alustaa ne (määrittää arvot) ja tulostaa sitten kunkin muuttujan tyypin.
Ero primitiivisten ja yhdistelmätietotyyppien välillä ilmenee, kun niiden arvot kopioidaan.
Kun muuttujalle annetaan yksinkertaista tyyppiä oleva arvo, itse arvo (esimerkiksi numero) kirjoitetaan muuttujaan. Kun me määrittää yksinkertaisen tyypin muuttujan toiselle, hän kopioiden arvo. Tämän seurauksena jokaisella muuttujalla on sen tarkoitus ja muutokset yhdessä muuttujista ei ole vaikutusta toisen muuttujan arvosta:
Kun muuttuja määrittää yhdistelmän arvon(viite) -tyyppi, muuttuja kirjoitetaan linkki arvostaa ( objektiviittaus). Kun määritämme yhden muuttujan (jonka arvo sisältää viittauksen yhdistelmäarvoon) toiselle muuttujalle, mitä tapahtuu kopioi linkki yhdistelmäarvoon. Tuloksena molemmat muuttujat viittaavat samaan yhdistelmäarvoon ja yhden muuttujan arvon muutokset tulee olemaan vaikutusta toisessa muuttujassa:
Primitiiviset tyypit
Kaikki JavaScriptin tietotyypit objekteja lukuun ottamatta ovat muuttumattomia tai muuttumattomia. Tämä tarkoittaa, että niiden arvoja ei voi muuttaa, vaan ne vain korvataan uudella, erilaisella arvolla. Esimerkiksi merkkijonoja ei voida säätää merkki kerrallaan - ne voidaan vain kirjoittaa kokonaan uudelleen. Tällaisten tyyppien arvoja kutsutaan "primitiivisiksi".
Yksinkertaisinta dataa, jolla ohjelma voi toimia, kutsutaan literaaleiksi. Literaalit ovat numeroita tai merkkijonoja, joita käytetään edustamaan arvoja JavaScriptissä. Annetut tiedot voivat olla hyvin erilaisia, ja siksi arvot ovat erilaisia. JavaScriptin yksinkertaisimpia tietotyyppejä kutsutaan perustietotyypeiksi: numeroiksi, merkkijonoiksi ja booleaniksi. Kaikki ne luokitellaan "primitiivisiksi".
Boolen (looginen) tyyppi "boolean"
Loogisilla tai Boolen arvoilla (keksijänsä nimen jälkeen - Boolean) voi olla vain yksi kahdesta arvosta: tosi (tosi) tai epätosi (epätosi). Arvot tosi tai epätosi näkyvät yleensä vertailussa tai loogisissa operaatioissa.
Seuraava ohjelma luo Boolen muuttujan ja testaa sitten sen arvon if/else-käskyn avulla:
Mitä tahansa lauseketta voidaan käyttää vertailulausekkeena. Mikä tahansa lauseke, joka palauttaa arvon 0, null, määrittelemätön tai tyhjä merkkijono, tulkitaan epätosi . Lauseke, joka määrittää minkä tahansa muun arvon, tulkitaan tosiksi.
Huomautus: Kun kirjoitetaan Boolen arvoja, niitä ei suljeta lainausmerkkeihin: var myVar = true;
Samaan aikaan var myVar = "true" ilmoittaminen luo merkkijonomuuttujan.
Numerotietotyyppi
JavaScriptissä ei ole eroa kokonaisluvun ja liukulukuluvun välillä – JavaScript edustaa pääasiassa kaikkia lukuja liukulukuarvoina.
JavaScript käyttää IEEE-754-standardin määrittelemää 64-bittistä muotoa numeroiden esittämiseen. Tämä muoto pystyy esittämään numeroita välillä ±1,7976931348623157 × 10308 - ±5 × 10 -324.
Suoraan ohjelmakoodista löytyvää lukua kutsutaan numeeriseksi literaaliksi. Desimaalisten kokonaislukuliteraalien lisäksi JavaScript tunnistaa heksadesimaaliarvot.
Heksadesimaaliluvut voivat sisältää minkä tahansa numerosarjan 0–9 ja kirjaimia a:sta f:iin, joiden on alettava merkkijonolla "0x".
Var a = 255; var b = 0xFF; // Numero 255 heksadesimaalimuodossa
Lisäksi JavaScript sisältää erityisiä numeerisia arvoja:
- NaN (ei luku tai laskuvirhe). Johtuu virheellisen datan, kuten merkkijonojen tai määrittelemättömän arvon, virheellisestä matemaattisesta operaatiosta.
- Ääretön (positiivinen ääretön). Käytetään, kun positiivinen luku on liian suuri esitettäväksi JavaScriptissä.
- -Infinity (negatiivinen ääretön). Käytetään, kun negatiivinen luku on liian suuri esitettäväksi JavaScriptissä.
- ±0 (positiivinen ja negatiivinen 0). JavaScript erottaa positiivisen ja negatiivisen nollan.
Merkkijonotietotyyppi
Merkkijonotyyppi on muuttumaton, järjestetty 16-bittisten arvojen sarja, joista jokainen edustaa Unicode-merkkiä (kirjaimet, numerot, välimerkit, erikoismerkit ja välilyönnit). Rivit voivat olla tyhjiä tai koostua yhdestä tai useammasta merkistä. Merkkijonot luodaan käyttämällä kaksinkertaisia (") tai yksittäisiä (") lainausmerkkejä. Yksittäislainausparilla erotettu merkkijono voi käyttää kaksoislainausmerkkejä, ja päinvastoin yksittäisiä lainausmerkkejä voidaan käyttää kaksoislainausparin sisällä olevassa merkkijonossa:
JavaScriptissä kaksois- ja kertalainausmerkkien välillä ei ole eroa, mutta merkkijonon alussa ja lopussa olevien lainausmerkkien ei pitäisi olla erilaisia. Esimerkiksi tällainen lauseke aiheuttaisi syntaksivirheen:
var firstName = "Max"; //syntaksivirhe - erilaiset lainausmerkit
Huomautus: JavaScriptillä ei ole erityistä yksimerkkistä tietotyyppiä, kuten char C:ssä, C++:ssa ja Javassa. Yksittäistä merkkiä edustaa yksikköpituinen merkkijono.
Nollatietotyyppi
Nolla-tyyppi sisältää yhden erikoisarvon – nollan.Nolla-avainsanaa ei voi käyttää funktiona tai muuttujan nimenä. Nolla-arvo on viittaus "tyhjään" objektiin ja sillä on erityinen tarkoitus - sitä käytetään yleensä alustamaan muuttuja, jolle annetaan myöhemmin arvo.
Typeof-operaattori nullissa palauttaa merkkijonon "object", mikä osoittaa, että null on erityinen "tyhjä" objekti.
Määrittämätön tietotyyppi
Määrittämätön tyyppi muodostaa oman tyyppinsä, joka sisältää yhden erikoisarvon - undefined. Tämä on muuttujan arvo, joka on ilmoitettu käyttämällä var-operaattoria, mutta jota ei ole alustettu:
Arvo undefined palautetaan käytettäessä muuttujaa, jolle ei ole koskaan määritetty arvoa, olematonta objektiominaisuutta tai taulukkoelementtiä.
On huomattava, että muuttuja, jonka arvo on määrittelemätön, eroaa muuttujasta, jota ei ole määritelty ollenkaan:
Tässä esimerkissä alert()-menetelmä näyttää ikämuuttujan arvon, joka on määrittelemätön. Toisessa tapauksessa ilmoittamaton automuuttuja välitetään alert()-metodille, mikä johtaa virheeseen.
Seuraava esimerkki saattaa olla hieman hämmentävä aloitteleville ohjelmoijille, koska... Operaattorityyppi palauttaa määrittelemättömän sekä alustamattomalle että ilmoittamattomalle muuttujalle:
Yllä olevassa esimerkissä muuttuja ikä on ilmoitettu, mutta siihen ei kirjoiteta mitään, joten sen arvo on vain määrittelemätön . Automuuttujaa ei ole ilmoitettu - itse asiassa sitä ei ole olemassa. Typeof kuitenkin palauttaa merkkijonon määrittelemättömänä molemmissa tapauksissa. Tämä on tietysti järkevää, koska minkään näistä muuttujista on mahdotonta suorittaa toimintoja, vaikka teknisesti ne ovat täysin erilaisia.
Huomautus: On suositeltavaa alustaa ilmoitettu muuttuja aina. Tässä tapauksessa tiedät, että typeof-operaattori palauttaa määrittelemättömän, koska muuttujaa ei ole ilmoitettu, ei siksi, että sitä ei alustettu.
Arvo undefined on johdettu arvosta null , joten ECMA-262:ssa == ekvivalenssioperaattori käsittelee niitä yhtäläisinä:
Vaikka null ja undefined liittyvät toisiinsa, niitä käytetään eri tavalla. Sinun ei pitäisi nimenomaisesti määrittää muuttujalle arvoa undefined, mutta tämä ei koske nollaa. Jos vaadittua objektia ei ole saatavilla, tulee sen sijaan käyttää nulla. Tämä osoittaa, että null otettiin käyttöön osoittimena tyhjään objektiin ja korostaa sen eroa määrittelemättömään kohteeseen.
Voit tehdä eron nollan ja määrittelemättömän välillä ohjelmassa käyttämällä identiteettioperaattoria === :
Tietotyyppi Symboli
Symboli on JavaScriptin innovaatio ECMAScriptin versiosta 6 lähtien. Symboli on ainutlaatuinen, muuttumaton, primitiivinen arvo, jota käytetään yksilöllisten tunnisteiden luomiseen.
Symbolin luomiseksi sinun on kutsuttava Symboli-toiminto:
var mySymbol = Symboli();
Symbolin määrittämiseen voit käyttää operaattorin tyyppiä, jos arvo on symboli, merkkijonosymboli palautetaan:
Symboli-funktiolla on valinnainen parametri - merkkijono, joka kuvaa symbolia:
Symbolin tärkeä piirre on myös, että sen merkitys on ainutlaatuinen. Voit käyttää ominaisuuden nimenä symbolia, joka ei taatusti toistu minkään muun ominaisuuden kanssa. Vaikka kahdella symbolilla on sama nimi, tämä ei tarkoita, että ne ovat samanarvoisia:
Objektin tietotyyppi
Edellä käsiteltyjen primitiivisten tietotyyppien lisäksi JavaScript tukee yhdistelmätietotyyppiä nimeltä objekti. Objekti koostuu monista arvoista (joko perusarvoista, kuten numeroista ja merkkijonoista, tai kompleksisista arvoista, kuten muista objekteista), joita kutsutaan kohteen ominaisuuksiksi. Ominaisuuksiin päästään ominaisuuden nimellä (kutsutaan joskus "avaimella").
Ominaisuuden nimi on merkkijono, joten objektien voidaan katsoa yhdistävän merkkijonoja arvoihin. Yhdessä nämä tiedot muodostavat avain-arvo-pareja.
JavaScriptissä objekteja voidaan luoda käyttämällä jompaakumpaa kahdesta syntaksista:
1. var obj = (); // objektiliteraalilla 2. var obj = new Object(); // käyttämällä konstruktori-nimistä menetelmää
Objektin luominen objektiliteraalilla alkaa säännöllisen muuttujan määrittämisellä. Tämän lausunnon oikealle puolelle kirjoitetaan objektiliteraalin - tämä on pilkuilla eroteltu luettelo pareista, jotka on suljettu aaltosulkeisiin (). "nimi-arvo", suljettu kihara olkaimet. Ominaisuuden nimi ja arvo erotetaan kaksoispisteellä:
var cat = ( "jalat": 4, "nimi": "Murzik", "väri": "punainen" )
Toinen tapa luoda objekteja on käyttää Object()-konstruktoria. Tässä tapauksessa käytetään ensin uutta Object()-lauseketta ja sitten määritetään ja alustetaan tuloksena olevan objektin ominaisuudet:
Tärkeät muistiinpanot
tyhjä
JavaScriptissä undefinedin lisäksi on null . Se tarkoittaa "ei arvoa". Jos esimerkiksi luot muuttujan, mutta et anna sille arvoa, sen arvo on määrittelemätön:
Olkoon a; console.log(a); // määrittelemätön
Tässä ei ollut tahattomasti merkitystä. Ilmeisesti ei yksinkertaisesti ole vielä tullut aika antaa tälle muuttujalle arvoa.
null tarvitaan nimenomaisesti, tarkoituksellisesti osoittamaan, että arvoa ei ole. Voit sanoa, että anna a = null; . Pyysit esimerkiksi käyttäjää syöttämään tietoja, mutta hän ei syöttänyt mitään. Tässä tapauksessa tulokseen kannattaa kirjoittaa nolla.
null , toisin kuin undefined, voidaan asettaa manuaalisesti, välittää argumenttina funktiolle ja käyttää yleensä kuten mitä tahansa muuta eksplisiittistä arvoa.
(undefined voidaan määrittää myös manuaalisesti, mutta sinun ei pitäisi koskaan tehdä niin: tämä arvo luodaan semanttisesti vain tietokoneen, ei ohjelmoijan, luomista varten).
Sinun on oltava varovainen vertailtaessa nollaa ja määrittelemätöntä:
nollatyyppi; // "objekti" (ei "null" historiallisista syistä) typeof undefined; // "undefined" null === määrittelemätön; // false null == määrittelemätön; // true null === null; // true null == null; // tosi !null; // tosi isNaN(1 + nolla); //väärä isNaN(1 + määrittelemätön); //totta
Vertailu
Tällä kurssilla vertaamme tietoja kolmella yhtäläisyysmerkillä:
A === b; 12 === 12;
Tämä vertailu on suora: ovatko nämä tiedot täysin identtisiä?
JavaScriptillä on rento vertailu kahdella yhtäläisyysmerkillä. Ne osoittavat, mitä tapahtuu JavaScriptin sisällä, kun se käsittelee kirjoitusasuja:
1 === "1"; // false 1 == "1"; // tosi tosi === 1; // väärä tosi == 1; // totta
Oppitunnin yhteenveto
JavaScriptin kirjoittaminen
JavaScript ymmärtää tyypit: numerot, merkkijonot, funktiot, loogiset arvot ja niin edelleen. typeof palauttaa merkkijonon, joka sisältää tyypin:
NaN tarkoittaa "ei numeroa", mutta tämän arvon tyyppi on numero .
Muuttujalla ilman arvoa on erityinen merkitys määrittelemätön. Tällaisen muuttujan tyyppi on määrittelemätön:
Dynaaminen ja staattinen kirjoitus
Koodi muunnetaan toiseen muotoon, jota tietokone voi käyttää. Tätä prosessia kutsutaan kokoamiseksi, ja ajanjakso, jonka aikana tämä prosessi tapahtuu, on kokoamisvaihe(kääntämisaika).
Kun käännös on valmis, ohjelma ajetaan ja jakso sen ollessa käynnissä kutsutaan toteutusvaihe(ajoaika).
Staattisesti kirjoitettu kielet tarkistavat tyypit ja etsivät kirjoitusvirheitä käännöshetkellä.
Dynaamisesti kirjoitettu kielet tarkistavat tyypit ja etsivät kirjoitusvirheitä suorituksen aikana.
Toisin sanoen: staattinen kirjoittaminen tarkoittaa tyyppien tarkistamista ennen ohjelman suorittamista; dynaaminen - tyypin tarkistus ohjelman ollessa käynnissä.
Heikko ja vahva kirjoitus
JavaScript muuntaa usein tyypit automaattisesti:
JavaScript on heikosti kirjoitettu kieli. Hänellä on käsitys tyypeistä, mutta hän on niiden suhteen rento ja osaa operoida arvojen kanssa, voisi sanoa, mielivaltaisesti. Mitä vahvempi kirjoitusjärjestelmä, sitä tiukemmat säännöt.
Eksplisiittiset konversiot JavaScriptissä
Valinnainen
Hauskaa
Oppitunnin transkriptio
Yhdellä edellisellä oppitunnilla puhuimme virheistä ja niiden käsittelystä. Virheitä on useita, ja haluan muistuttaa sinua yhdestä tietystä tyypistä. Tässä pieni fragmentti oppitunnista:
Katso tämä koodi:
Vakiopituus = 12; const num = pituus(54);
Ensin loimme vakion. Muista, että tämä on kuin antaisi jollekin nimen: meidän tapauksessamme numerolle 12 annetaan nimen pituus . Seuraavalla rivillä kutsumme pituusfunktiota ja välitämme sille argumentin - numeron 54. Mutta odota! pituus ei ole funktio! Se on vain numero. Numerot eivät ole toimintoja, eivät laatikoita, jotka suorittavat jonkinlaisen toiminnon. Ja JavaScript valittaa juuri tästä:
→ solmu testi.js /Käyttäjät/rakhim/test.js:2 const num = pituus(-54); ^ TypeError: pituus ei ole objektin funktio.
Tämä Kirjoitusvirhe: Käyttämäsi objektityyppi on virheellinen. JavaScript-tulkki ei kerro sinulle mikä jokin on, mutta hän varmasti sanoo mitä se ei ole. pituus ei ole funktio.
Kirjoitusvirhe on kuin pyytäisi kissaa pesemään pyykkiä. Ehkä halusit kysyä asiasta ystävältäsi.
Ohjelmoinnissa "kirjoitus" on tiedon luokittelu. Tämä on yleinen termi ja eri ohjelmointikielet käsittelevät kirjoittamista eri tavalla. Kuten jo tiedät, JavaScript voi erottaa tyypit. Funktio on yksi tyyppi, numero on toinen, etkä voi käyttää vain numeroa funktiona.
typeof on erityinen operaattori, joka palauttaa merkkijonon, johon tyyppi on kirjoitettu.
Tyyppi 42; // "numero"-tyyppi 3.14; // NaN:n "numero"-tyyppi; // "numero"-tyyppi "Berry"; // "merkkijono" tyyppi tosi; // "boolean" typeof false; // "boolean"
42 ja 3.14 ovat ilmeisesti numeroita, useat lainausmerkeissä olevien kirjainten yhdistelmät ovat merkkijonoja ja tosi ja false ovat Boolen arvoja. Kaikki nämä ovat JavaScript-tyyppejä - numero, merkkijono ja looginen.
NaN tarkoittaa "ei numeroa", mutta tyyppi NaN on "luku". Kyllä tiedän. Toinen outo asia JavaScriptissä. Nämä ovat säännöt tällä kielellä.
Kirjoittaminen on hyödyllistä. Kun yritämme suorittaa numeron ikään kuin se olisi funktio, JavaScript alkaa valittaa ja näemme virheen ja korjaamme sen. Jos JavaScriptissä ei olisi tyyppimerkintöjä, päätyisimme joko epänormaaliin käyttäytymiseen tai mystiseen virheeseen. Selkeän "pituus ei ole funktio" -sanan sijasta näkisimme jotain, kuten "anteeksi Dave, en valitettavasti voi tehdä sitä".
Entä jos luot muuttujan, mutta et anna sille arvoa? Mikä tyyppi on tässä tapauksessa? Se ei ole numero, se ei ole merkkijono, se ei ole mitään... Koska sillä ei ole merkitystä, eikö niin?
JavaScript tekee tässä tapauksessa jotain sinulta salassa. Muuttujalla ilman arvoa on itse asiassa erityinen merkitys - "määrittämätön". Ja tällaisen muuttujan tyyppiä kutsutaan "määrittämättömäksi".
Olkoon a; console.log(a); // määrittelemätön tyyppi a; // "määrittämätön"
Esimerkiksi numerotyypillä on monia mahdollisia arvoja: 1, 2, -10, 69000 ja muita lukuja. Ja määrittelemättömiä on vain yksi tyyppi - määrittelemätön.
Ohjelmoinnin kirjoittamisen kannalta on tärkeää erottaa kaksi käsitettä: dynaaminen vs. staattinen ja heikko vs. vahva.
Ymmärtääksemme eron dynaamisen ja staattisen kirjoittamisen välillä meidän on ensin tarkasteltava, kuinka kirjoitetuista ohjelmista tulee käynnissä olevia ohjelmia.
Kirjoittamasi koodi muunnetaan yleensä muotoon, jota tietokone voi suorittaa. Tätä prosessia kutsutaan kääntämiseksi, ja ajanjaksoa, jonka aikana tämä tapahtuu, kutsutaan "kääntämisvaiheeksi" tai käännösajaksi.
Kun käännös on valmis ja ohjelma käynnistetty, alkaa aikalaskenta, jota kutsutaan "suoritusvaiheeksi" tai ajoajaksi.
Jotkut kielet tarkistavat tyypit ja etsivät kirjoitusvirheitä käännösvaiheessa. Niissä on staattinen kirjoitus.
Muut kielet tarkistavat tyypit ja etsivät kirjoitusvirheitä suorituksen aikana. Tämä kirjoitus on dynaamista.
Toisin sanoen: staattinen kirjoittaminen tarkoittaa tyyppien tarkistamista ennen ohjelman suorittamista, dynaaminen kirjoittaminen tarkoittaa tyyppien tarkistamista ohjelman ollessa käynnissä.
C#, C++, Java ja Go ovat staattisesti kirjoitettuja kieliä. Jos jollakin näistä kielistä luot luvun ja yrität käyttää sitä funktiona, saat käännösaikavirheen ja ohjelma ei toimi – se ei edes pääse siihen vaiheeseen, koska kirjoitus virhe havaitaan ennen suoritusta kääntämisen aikana.
JavaScript, Ruby ja PHP ovat dynaamisesti kirjoitettuja kieliä. Kuten aiemmin näit, jos käytät väärää tyyppiä, ohjelmasi suoritetaan ja virhe havaitaan vasta, kun kyseinen koodirivi suoritetaan. Täällä tyypit tarkistetaan ajon aikana.
Itse asiassa JavaScriptissä yleensä kokoelmaa ei ole, mutta se on toisen oppitunnin aihe.
Dynaaminen kirjoittaminen ei ole huonompi tai parempi kuin staattinen kirjoittaminen. Molemmilla tavoilla on hyvät ja huonot puolensa. Dynaamisesti kirjoitetut kielet ovat yleensä helpompia oppia ja kirjoittaa ohjelmia, mutta kuten voit kuvitella, tämä saattaa lisätä virheitä ja bugeja.
Puhutaan nyt heikosta ja vahvasta kirjoittamisesta. Katso tämä JavaScript-koodi:
4 + "7"; // "47" 4 * "7"; // 28 2 + tosi; // 3 epätosi - 3; // -3
Hmmm... Tämä... Ok, mitä täällä tapahtuu? Kun lisäät numeron 4 merkkijonoon "7", saamme merkkijonon "47". JavaScript muuntaa luvun 4 merkkijonoksi "4" ja ketjuttaa kaksi merkkijonoa - liittää ne yhteen. JavaScript vain ottaa sen itsensä olettaa, että tämä on mitä halusimme. On typerää syyttää häntä - mitä me todella halusimme? Numeron lisäämisessä merkkijonoon ei ole mitään järkeä. Mikä tahansa muu kieli, kuten Ruby tai Python, valittaisi eivätkä tekisi mitään.
Numeron 4 tulo merkkijonolla "7", kuten näet, on JavaScriptin mukaan 28. Tässä tapauksessa hän muunsi merkkijonon "7" numeroksi 7 ja suoritti tavanomaisen kertolaskun.
JavaScript tekee tämän koko ajan. Se tietää eri arvojen tyypit, mutta kun tyypit eivät täsmää, se yrittää arvata ja muuntaa yhden tyypin toiseksi varoittamatta. Joskus se on hyödyllistä, joskus se on mieltä räjäyttävää. Tämä johtuu siitä, että JavaScript on heikosti kirjoitettu kieli. Hänellä on käsitys tyypeistä, mutta hän vastaa: "Se on vain peliä, miksi olet vihainen?"
Tällä konseptilla ei ole mitään yhteistä dynaamisen ja staattisen kirjoittamisen kanssa, jonka tarkoitus on MILLOIN tarkistaa tyypit. Vahva vs heikko on KUINKA VAKAVAT tyyppitarkistusta.
Toisin kuin dynaamisuus ja staattisuus, kirjoittamisen voima on spektri. PHP:n kirjoitus on hieman vahvempi. Python on vielä vahvempi. Ja ne ovat kaikki dynaamisesti kirjoitettuja kieliä.
JavaScript tekee paljon implisiittisiä muunnoksia, mutta se antaa meille myös työkalut tehdä eksplisiittisiä muunnoksia itse. Voimme muuntaa merkkijonot numeroiksi, numerot merkkijonoiksi, loogiset arvot merkkijonoiksi ja niin edelleen:
Numero("590"); // 590 Numero("aaa!!"); // NaN Boolen(1); // tosi Boolen(0); // false String(true); // "true" String(false); // "false" String(44843); // "44843"
Voidaan olettaa, että implisiittinen muuntaminen tyypistä tyyppiin ei ole hyvä idea. Implisiitti tarkoittaa piilotettua ja piilotettu vaikeasti ymmärrettävää ja virhealtista. Ohjelman käyttäytyminen tulee vähemmän ilmeiseksi. Kirjoitat vähemmän koodia, kyllä, mutta koodi on hauraampaa ja vähemmän ymmärrettävää.
Kaikilla ohjelmointikielillä on sisäänrakennetut tietorakenteet, mutta ne vaihtelevat usein kielistä toiseen. Tässä artikkelissa yritetään luetella JavaScriptin sisäänrakennetut tietorakenteet ja niiden ominaisuudet. näitä voidaan käyttää muiden tietorakenteiden rakentamiseen. Aina kun mahdollista, tehdään vertailuja muihin kieliin.
Dynaaminen kirjoittaminen
JavaScript on a löyhästi kirjoitettu tai a dynaaminen Kieli. JavaScriptin muuttujat eivät liity suoraan mihinkään tiettyyn arvotyyppiin, ja mille tahansa muuttujalle voidaan määrittää (ja määrittää uudelleen) kaikentyyppisiä arvoja:
Var foo = 42; // foo on nyt numero foo = "bar"; // foo on nyt merkkijono foo = tosi; // foo on nyt boolean
Tietotyypit
Uusin ECMAScript-standardi määrittelee kahdeksan tietotyyppiä:
- Seitsemän tietotyyppiä ovat:
Primitiiviset arvot
Kaikki tyypit paitsi objektit määrittävät muuttumattomia arvoja (arvoja, joita ei voida muuttaa). Esimerkiksi, toisin kuin C, merkkijonot ovat muuttumattomia. Kutsumme tämän tyyppisiä arvoja "primitiiviarvoiksi".
Boolen tyyppi
Boolean edustaa loogista kokonaisuutta ja sillä voi olla kaksi arvoa: true ja false . Katso Boolen ja Boolen lisätiedot.
Nollatyyppi
Ominaisuudet
JavaScriptissä objektit voidaan nähdä kokoelmana ominaisuuksia. Oliokirjaimellisella syntaksilla alustetaan rajoitettu joukko ominaisuuksia; sitten ominaisuuksia voidaan lisätä ja poistaa. Ominaisuusarvot voivat olla mitä tahansa arvoja, myös muita objekteja, mikä mahdollistaa monimutkaisten tietorakenteiden rakentamisen. Ominaisuudet tunnistetaan avainarvojen avulla. Avainarvo on joko merkkijono tai symboliarvo.
On olemassa kahden tyyppisiä objektiominaisuuksia, joilla on tietyt attribuutit: Data-ominaisuus ja aksessorin ominaisuus.
Data-ominaisuus
Liittää avaimen arvoon ja sillä on seuraavat attribuutit:
| Attribuutti | Tyyppi | Kuvaus | Oletusarvo |
|---|---|---|---|
| [] | Mikä tahansa JavaScript-tyyppi | Arvo, joka on haettu omaisuuden käyttöoikeudella. | määrittelemätön |
| [] | Boolean | Jos epätosi , ominaisuutta [] ei voi muuttaa. | väärä |
| [] | Boolean | varten...silmukoissa. Katso myös Kiinteistöjen luetetavuus ja omistus | väärä |
| [] | Boolean | Jos epätosi , ominaisuutta ei voi poistaa, sitä ei voi muuttaa aksessorin omaisuudeksi eikä muita attribuutteja kuin [] ja [] voida muuttaa. | väärä |
| Attribuutti | Tyyppi | Kuvaus |
|---|---|---|
| Lue ainoastaan | Boolean | ES5 []-attribuutin käänteinen tila. |
| DontEnum | Boolean | ES5 []-attribuutin käänteinen tila. |
| Älä poista | Boolean | ES5 []-attribuutin käänteinen tila. |
Lisävarusteominaisuus
Liittää avaimen yhteen tai kahteen aksessorifunktioon (get ja set) arvon hakemiseksi tai tallentamiseksi, ja sillä on seuraavat attribuutit:
| Attribuutti | Tyyppi | Kuvaus | Oletusarvo |
|---|---|---|---|
| [] | Funktioobjekti tai määrittelemätön | Funktiota kutsutaan tyhjällä argumenttiluettelolla ja se hakee ominaisuuden arvon aina, kun arvoon haetaan pääsy. Katso myös saada. | määrittelemätön |
| [] | Funktioobjekti tai määrittelemätön | Funktiota kutsutaan argumentilla, joka sisältää määritetyn arvon, ja se suoritetaan aina, kun määritettyä ominaisuutta yritetään muuttaa. Katso myös setti. | määrittelemätön |
| [] | Boolean | Jos tosi, ominaisuus luetellaan for...silmukoihin. | väärä |
| [] | Boolean | Jos epätosi , ominaisuutta ei voi poistaa eikä muuttaa data-omaisuudeksi. | väärä |
Huomautus: Attribuuttia käytetään yleensä JavaScript-moottorissa, joten et voi käyttää sitä suoraan (katso lisää Object.defineProperty()). Tästä syystä attribuutti laitetaan kaksoishakasulkeisiin yhden sijasta.
"Normaalit" objektit ja toiminnot
JavaScript-objekti on avainten ja arvojen välinen kartoitus. Avaimet ovat merkkijonoja (tai symboleja) ja arvot voivat olla mitä tahansa. Tämä tekee esineistä luonnollisesti sopivia hashmappiin.
Funktiot ovat tavallisia objekteja, joiden lisäominaisuus on kutsuttavissa.
Päivämäärät
Päivämääriä esitettäessä paras valinta on käyttää JavaScriptin sisäänrakennettua Date-apuohjelmaa.
Indeksoidut kokoelmat: taulukot ja kirjoitetut taulukot
Taulukot ovat säännöllisiä objekteja, joiden kokonaislukuavaimella varustettujen ominaisuuksien ja "length"-ominaisuuden välillä on erityinen suhde. Lisäksi taulukot periytyvät Array.prototypesta, joka tarjoaa niille kourallisen käteviä menetelmiä taulukoiden käsittelyyn. Esimerkiksi indexOf (arvon etsiminen taulukosta) tai push (elementin lisääminen taulukkoon) jne. Tämä tekee Arraysista täydellisen ehdokkaan edustamaan listoja tai joukkoja.
Tyypityt taulukot ovat uusia JavaScriptille ECMAScript 2015:llä, ja ne tarjoavat taulukon kaltaisen näkymän alla olevasta binääritietopuskurista. Seuraava taulukko auttaa sinua löytämään vastaavat C-tietotyypit:
TypedArray-objektit
| Tyyppi | Arvoalue | Koko tavuina | Kuvaus | Web IDL tyyppi | Vastaava C-tyyppi |
| Int8Array | -128-127 | 1 | 8-bittinen kahden tuuman komplementtimerkkinen kokonaisluku | tavu | int8_t |
| Uint8Array | 0-255 | 1 | 8-bittinen etumerkitön kokonaisluku | oktetti | uint8_t |
| Uint8ClampedArray | 0-255 | 1 | 8-bittinen etumerkitön kokonaisluku (kiinnitetty) | oktetti | uint8_t |
| Int16Array | -32768 - 32767 | 2 | 16-bittinen kahden tuuman komplementtimerkkinen kokonaisluku | lyhyt | int16_t |
| Uint16 Array | 0 - 65535 | 2 | 16-bittinen etumerkitön kokonaisluku | allekirjoittamaton lyhyt | uint16_t |
| Int32Array | -2147483648 - 2147483647 | 4 | 32-bittinen kahden tuuman komplementtimerkkinen kokonaisluku | pitkä | int32_t |
| Uint32Array | 0 numeroon 4294967295 | 4 | 32-bittinen etumerkitön kokonaisluku | allekirjoittamaton pitkä | uint32_t |
| Float32Array | 1,2 x 10 -38 - 3,4 x 10 38 | 4 | 32-bittinen IEEE-liukuluku (7 merkitsevää numeroa, esim. 1,1234567) | rajoittamaton kelluvuus | kellua |
| Float64Array | 5,0 x 10 -324 - 1,8 x 10 308 | 8 | 64-bittinen IEEE-liukuluku (16 merkitsevää numeroa, esim. 1,123...15) | rajoittamaton tupla | kaksinkertainen |
| BigInt64Array | -2 63 - 2 63 -1 | 8 | 64-bittinen kahden tuuman komplementtimerkkinen kokonaisluku | bigint | int64_t (allekirjoitettu pitkä pitkä) |
| BigUint64Array | 0 - 2 64 -1 | 8 | 64-bittinen etumerkitön kokonaisluku | bigint | uint64_t (allekirjoittamaton pitkä pitkä) |
Avainkokoelmat: Maps, Sets, WeakMaps, WeakSets
Nämä tietorakenteet käyttävät objektiviittauksia avaimina, ja ne otetaan käyttöön ECMAScript Edition 6:ssa. Set ja WeakSet edustavat joukkoa objekteja, kun taas Map ja WeakMap yhdistävät arvon objektiin. Ero Mapsin ja WeakMapsin välillä on, että edellisessä objektiavaimet voidaan luetella yli. Tämä mahdollistaa jätekeräyksen optimoinnin jälkimmäisessä tapauksessa.
Kartat ja joukot voitaisiin toteuttaa puhtaassa ECMAScript 5:ssä. Koska objekteja ei kuitenkaan voida verrata (esimerkiksi "vähemmän kuin" merkityksessä), hakusuorituskyky olisi välttämättä lineaarinen. Niiden alkuperäisillä toteutuksilla (mukaan lukien WeakMapsilla) voi olla hakusuorituskyky, joka on suunnilleen logaritminen vakioaikaan nähden.
Yleensä datan sitomiseksi DOM-solmuun voidaan määrittää ominaisuudet suoraan objektille tai käyttää data-*-attribuutteja. Tämän haittapuolena on, että tiedot ovat kaikkien samassa kontekstissa käynnissä olevien skriptien käytettävissä. Kartat ja WeakMaps helpottavat tietojen yksityistä sitomista objektiin.
Strukturoitu data: JSON
JSON (JavaScript Object Notation) on kevyt tiedonsiirtomuoto, joka on johdettu JavaScriptistä, mutta jota monet ohjelmointikielet käyttävät. JSON rakentaa universaaleja tietorakenteita. Katso lisätietoja kohdasta JSON ja JSON.
Lisää objekteja vakiokirjastossa
JavaScriptillä on standardi sisäänrakennettujen objektien kirjasto. Katso viite saadaksesi lisätietoja kohteista.
Tyyppien määrittäminen operaattorin typellä
Typeof-operaattori voi auttaa sinua löytämään muuttujasi tyypin. Lue lisätietoja ja reunakotelot.
Tekniset tiedot
| Erittely | Tila | Kommentti |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Vakio | Alkuperäinen määritelmä. |
| ECMAScript 5.1 (ECMA-262) "Tyyppien" määritelmä kyseisessä eritelmässä. |
Vakio | |
| ECMAScript 2015 (6. painos, ECMA-262) |
Vakio | Symboli lisätty. |
| ECMAScriptin uusin luonnos (ECMA-262) "ECMAScript-tietotyyppien ja -arvojen" määritelmä kyseisessä määrittelyssä. |
Luonnos |
Kun tietokoneohjelmat toimivat, ne käsittelevät arvoja, kuten numeroa 7 tai tekstiä "HelloWorld!" Jokainen ohjelmointikielellä esitettävä ja prosessoitava arvo kuuluu tiettyyn tietotyyppiin. Tietotyyppi määrittelee arvotyypit, joita käytetään ohjelmointikielessä.
JavaScriptissä tietotyypit voidaan jakaa kahteen luokkaan: yksinkertaisiin (kutsutaan myös primitiivisiksi) ja yhdistelmätyypeiksi (kutsutaan myös viitteeksi tai objektiksi).
- merkkijono- tekstimerkkijonot (yleensä niitä kutsutaan yksinkertaisesti merkkijonoiksi)
- määrä- numerot
- boolean- Loogiset (Boolen) arvot
Yksinkertaisiin tyyppeihin kuuluu myös kaksi erikoisarvoa:
- tyhjä
- määrittelemätön
Yhdistelmätietotyyppejä ovat:
- toiminto-toiminnot
- joukko- taulukot
- esine- esineitä
Ero yksinkertaisten ja yhdistelmätyyppien välillä
Ero yksinkertaisten ja yhdistelmätyyppien välillä ilmenee, kun arvot kopioidaan.
Kun muuttujalle (funktioparametrille, ominaisuudelle tai taulukon elementille) annetaan yksinkertaista tyyppiä oleva arvo, kuten luku, itse arvo (tässä tapauksessa numero) kirjoitetaan muuttujaan. Kun määrität yhden muuttujan (jonka arvo on yksinkertainen) toiselle muuttujalle, arvo kopioidaan. Tämän seurauksena jokaisella muuttujalla on oma kopio arvosta, eivätkä yhden muuttujan muutokset vaikuta toisen arvoon:
Var num1 = 10; var numero2 = numero1; // Kopioi arvo alert("num1: " + num1 + // 10 "\nnum2: " + num2); // 10 num1 = 15; // Muuta arvoa alert("num1: " + num1 + // 15 "\nnum2: " + num2); // 10
Kun muuttujalle (funktioparametrille, ominaisuudelle tai taulukon elementille) on määritetty kompleksityyppinen arvo, kuten objekti, viittaus arvoon (tässä tapauksessa viittaus objektiin) kirjoitetaan muuttujaan. Kun määrität yhden muuttujan (jonka arvo sisältää viittauksen yhdistelmäarvoon) toiselle muuttujalle, viittaus yhdistelmäarvoon kopioidaan. Tämän seurauksena molemmat muuttujat viittaavat samaan yhdistelmäarvoon, ja kaikki yhden muuttujan arvoon tehdyt muutokset vaikuttavat toiseen muuttujaan:
Var o1 = (x:10); var o2 = o1; // Kopioi linkki objektiin alert("o1.x: " + o1.x + // 10 "\no2.x: " + o2.x); // 10 o2.x = 15; // Muuta arvoa alert("o1.x: " + o1.x + // 15 "\no2.x: " + o2.x); // 15
tyhjä ja määrittelemätön
Nolla - tyypillä on vain yksi arvo -- null . Arvo null on viittaus tyhjään objektiin ja sillä on erityinen tarkoitus - sitä käytetään yleensä alustamaan muuttuja, jolle kohde myöhemmin liitetään.
Määrittämättömällä tyypillä on vain yksi arvo - undefined. Arvo määrittelemätön tarkoittaa, että alkuarvoa ei ole. Voit saada määrittelemättömän arvon seuraavasti:
- Käytettäessä muuttujaa, joka on ilmoitettu, mutta jota ei ole alustettu.
- Kun päästään käsiksi esineen olemattomaan ominaisuuteen.
- Käytettäessä olematonta taulukkoelementtiä.
- Käytettäessä funktioparametreja, joita ei alustettu argumenteilla funktiota kutsuttaessa.
- Palauttaa funktiot, joilla ei ole palautusarvoa.
- Palauttaa typeof-operaattorin, jos operandi on olematon muuttuja.
Tunniste undefined on ennalta määritetyn globaalin muuttujan nimi, joka alustetaan arvolla undefined. Määrittelemätön muuttuja on vain luku -tilassa.
Kääre esineitä
Aina kun ohjelma yrittää käyttää primitiivityypin arvon ominaisuutta tai menetelmää, tulkki muuntaa väliaikaisesti primitiivisen arvon sopivan tyypin objektiksi. Väliaikaisia objekteja, joihin primitiivityypin arvot muunnetaan, kutsutaan kääreesineet. Tulkki käyttää näitä objekteja päästäkseen haluttuun ominaisuuteen tai menetelmään. Välittömästi ominaisuuden tai menetelmän kutsumisen jälkeen kääreobjekti tuhoutuu. Wrapper-objektit luodaan vain arvoille, joiden tyyppi on numero , merkkijono ja boolean. Arvoilla null ja undefined ei ole kääreobjekteja: kaikki yritykset päästä käsiksi näiden arvojen ominaisuuksiin synnyttävät virheen.
Jos yrität asettaa kääreobjektille uuden ominaisuuden, uutta ominaisuutta ei tallenneta, koska kääreobjekti tuhoutuu välittömästi sen jälkeen, kun se on suorittanut työnsä:
Var str = "teksti"; str.len = 5; // Aseta ominaisuus, jolla on arvo. Välittömästi tämän jälkeen kohde tuhotaan alert(str.len); // määrittelemätön, koska edellinen kääreobjekti on jo tuhottu
Wrapper-objekteja voidaan pitää yksinkertaisesti mukavuustoteutuksena primitiivityyppisten arvojen kanssa työskentelyyn, eikä niitä ajatella ollenkaan.
