Javascript-laskentaoperaattorit. JavaScript-operaattorit. JavaScriptin sykliset operaattorit - For

Tässä luvussa kuvataan JavaScriptin lausekkeet ja operaattorit, mukaan lukien osoitus, vertailu, aritmetiikka, bittikohtainen, looginen, merkkijono, kolmiosainen ja paljon muuta.

Täydellinen ja yksityiskohtainen luettelo operaattoreista ja lausekkeista löytyy myös viitteestä.

Operaattorit

JavaScriptillä on seuraavan tyyppiset operaattorit. Tässä osiossa kuvataan operaattoreita ja annetaan tietoja operaattorien ensisijaisuudesta.

JavaScriptillä on molemmat binääri ja yksipuolinen operaattorit ja yksi erityinen kolmiosainen operaattori, ehdollinen operaattori. Binäärioperaattori vaatii kaksi operandia, yhden ennen operaattoria ja toisen operaattorin jälkeen:

operandi1 operaattori operandi2

Esimerkiksi 3+4 tai x*y .

Unaarinen operaattori vaatii yhden operandin joko ennen operaattoria tai sen jälkeen:

operaattori operandi operandi operaattori 12; // 0,5 1/2 == 1,0 / 2,0; // Tämä on totta

Tavallisten aritmeettisten operaatioiden (+, -, * /) lisäksi JavaScript tarjoaa seuraavassa taulukossa luetellut aritmeettiset operaattorit:

Aritmeettiset operaattorit Esimerkki käyttäjäkuvauksesta

Loput (%)	Binäärioperaattori. Palauttaa kahden operandin jakamisen kokonaisluvun jäännöksen.	12% 5 palauttaa 2.
Kasvata (++)	Unaarinen operaattori. Lisää yhden operandiinsa. Jos sitä käytetään etuliiteoperaattorina (++x), palauttaa operandinsa arvon lisättyään yhden; jos sitä käytetään postfix-operaattorina (x++), palauttaa operandinsa arvon ennen sen lisäämistä.	Jos x on 3, ++x asettaa x:n 4:ksi ja palauttaa 4:n, kun taas x++ palauttaa 3:n ja vain silloin asettaa x:n 4:ksi.
Vähennä (--)	Unaarinen operaattori. Vähentää yhden operandistaan. Paluuarvo on samanlainen kuin lisäysoperaattorin arvo.	Jos x on 3, niin --x asettaa x:n 2:ksi ja palauttaa 2:n, kun taas x-- palauttaa 3:n ja vain silloin asettaa x:n 2:ksi.
Unaarinen negaatio (-)	Yksittäinen operaattori. Palauttaa operandinsa negation.	Jos x on 3, niin -x palauttaa -3.
Yksittäinen plus (+)	Yksittäinen operaattori. Yrittää muuntaa operandi luvuksi, jos se ei jo ole.	+"3" palauttaa 3:n. +true palauttaa 1.
Eksponentiaalinen operaattori (**)	Laskee kantaluvun eksponentin potenssiin, eli kantaeksponentin	2 ** 3 palauttaa 8 . 10 ** -1 palauttaa 0.1 .

Bittikohtaiset operaattorit

Käytä instanceofia, kun sinun on vahvistettava objektin tyyppi suorituksen aikana. Esimerkiksi poikkeuksia pyydtäessäsi voit haarautua erilaisiin poikkeustenkäsittelykoodiin heitetyn poikkeuksen tyypistä riippuen.

Esimerkiksi seuraava koodi käyttää instanceofia määrittääkseen, onko theDay Date-objekti. Koska theDay on Date-objekti, if-käskyn käskyt suoritetaan.

Muutt theDay = uusi päivämäärä(1995, 12, 17); if (päivämäärän esiintymä) ( // suoritettavat käskyt )

Operaattorin etusija

The etusijalla operaattoreista määrittää järjestyksen, jossa niitä käytetään lauseketta arvioitaessa. Voit ohittaa operaattorin ensisijaisuuden käyttämällä sulkeita.

Seuraavassa taulukossa kuvataan operaattoreiden ensisijaisuus korkeimmasta pienimpään.

Operaattorin etusija Käyttäjätyyppi Yksittäiset operaattorit

jäsen	.
soita/luo ilmentymä	() Uusi
negaatio/lisäys	! ~ - + ++ -- tyhjän poiston tyyppi
kertoa/jakaa	* / %
yhteenlasku/vähennys	+ -
bittikohtainen siirto	> >>>
suhteellinen	< >= tapauksessa
tasa-arvo	== != === !==
bitwise-ja	&
bitwise-xor	^
bittikohtaisesti-tai	|
looginen-ja	&&
looginen-tai	||
ehdollinen	?:
toimeksianto	= += -= *= /= %= = >>>= &= ^= |=
pilkku	,

Tämän taulukon yksityiskohtaisempi versio, jossa on linkit lisätietoihin kustakin operaattorista, löytyy JavaScript-viittauksesta.

Ilmaisut

An ilmaisu on mikä tahansa kelvollinen koodiyksikkö, joka ratkaisee arvon.

Jokainen syntaktisesti kelvollinen lauseke ratkaisee jonkin arvon, mutta käsitteellisesti on olemassa kahdenlaisia ​​lausekkeita: sivuvaikutuksineen (esimerkiksi ne, jotka antavat arvon muuttujalle) ja ne, jotka jossain mielessä arvioivat ja siten ratkaisevat arvon.

Lauseke x = 7 on esimerkki ensimmäisestä tyypistä. Tämä lauseke käyttää = operaattori määrittääksesi arvon seitsemän muuttujalle x . Itse lausekkeen arvo on seitsemän.

Koodi 3 + 4 on esimerkki toisesta lauseketyypistä. Tämä lauseke käyttää +-operaattoria kolmen ja neljän yhteen lisäämiseen ilman, että tulos, seitsemän, annetaan muuttujalle.

JavaScriptillä on seuraavat lausekeluokat:

Ensisijaiset ilmaisut

Perusavainsanat ja yleiset lausekkeet JavaScriptissä.

Tämä

Käytä tätä avainsanaa viitataksesi nykyiseen objektiin. Yleensä tämä viittaa kutsuvaan objektiin menetelmässä. Käytä tätä joko pisteen tai hakasulkeiden kanssa:

Tämä["omaisuudenNimi"] this.propertyName

Oletetaan, että validate-niminen toiminto vahvistaa objektin arvoominaisuuden, kun otetaan huomioon objekti sekä korkeat ja pienet arvot:

Funktio valide(obj, lowval, hival) ( if ((obj.arvo< lowval) || (obj.value >hival)) console.log("Virheellinen arvo!"); )

Voit kutsua validointia kunkin lomakeelementin onChange-tapahtumakäsittelijässä ja välittää sen lomakeelementille, kuten seuraavassa esimerkissä:

Anna numero väliltä 18-99:

Ryhmittelyoperaattori

Ryhmittelyoperaattori() ohjaa lausekkeiden arvioinnin ensisijaisuutta. Voit esimerkiksi ohittaa kerto- ja jakolaskun ensin ja sitten yhteen- ja vähennyslaskun laskeaksesi yhteenlaskua ensin.

Var a = 1; var b = 2; var c = 3; // oletusarvo a + b * c // 7 // arvioitu oletusarvoisesti näin a + (b * c) // 7 // nyt ohittava etusija // yhteenlasku ennen kertolaskua (a + b) * c // 9 / / joka vastaa a * c + b * c // 9

Vasemman puolen ilmaisut

Vasemmat arvot ovat tehtävän kohde.

Uusi

Voit käyttää uutta operaattoria luodaksesi ilmentymän käyttäjän määrittämälle objektityypille tai jollekin sisäänrakennetuista objektityypeistä. Käytä uutta seuraavasti:

Muutt objektinNimi = uusi objektityyppi();

super

Super-avainsanaa käytetään kutsumaan funktioita objektin ylätasolla. Luokkien kanssa on hyödyllistä kutsua esimerkiksi ylätason konstruktoria.

Super(); // kutsuu ylätason konstruktoria. super.functionOnParent();

Spread-operaattori

Hajautusoperaattori mahdollistaa lausekkeen laajentamisen paikoissa, joissa odotetaan useita argumentteja (funktiokutsuille) tai useita elementtejä (taulukkoliteraaleille).

Esimerkki: Jos sinulla on tänään taulukko ja haluat luoda uuden taulukon, jossa olemassa oleva on osa sitä, taulukon kirjaimellinen syntaksi ei enää riitä ja sinun on palattava pakolliseen koodiin käyttämällä yhdistelmää push , splice , concat jne. Hajautetulla syntaksilla tästä tulee paljon ytimekkäämpi:

Var osat = ["hartiat", "polvet"]; var lyrics = ["pää", ...osat, "ja", "varpaat"];

Samoin leviämisoperaattori toimii funktiokutsujen kanssa:

Funktio f(x, y, z) ( ) var args = ; f(...args);

Ensinnäkin lyhyesti JavaScriptin ilmaisuista.

JavaScript-lausekkeet

JavaScriptillä on lauseita ja lausekkeita.

Ohjeet eivät palauta arvoja.

Ilmaisut Aina palauttaa joitain arvoja. Kun tulkki näkee lausekkeen, se arvioi sen arvon ja korvaa lausekkeen sen arvolla.

Ilmaisut voivat olla yksinkertaisia ​​tai yhdistettyjä. Yksinkertaiset lausekkeet eivät sisällä muita lausekkeita.

Yksinkertaisia ​​ilmaisuja ovat mm.

Tunnisteet: someVar (muuttujan nimi);

Literaalit: "merkkijono" tai 675 (numero tai numeerinen literaali);

Jotkut avainsanat kuten tämä ;

Kun jäsentäjä löytää tunnisteen, sen on ensin laskettava sen arvo, eli esimerkiksi korvattava muuttujan nimi sen arvolla.

Literaalin arvo on sama kuin se on kirjoitettu komentosarjakoodiin.

JavaScript-operaattorit ja monimutkaiset lausekkeet

Operaattoreita käytetään yhdistämään useita yksinkertaisia ​​lausekkeita yhdeksi monimutkaiseksi lausekkeeksi.

Operaattoreita ovat:

• Unaarinen (yksi operandi).
• Binääri (kaksi operandia).
• Kolmiosainen operaattori? JavaScriptissä (kolme operandia, on vain yksi kolmioperaattori).

Operandi on yksinkertainen lauseke, johon sovelletaan operaattoria.

Esimerkiksi aritmeettinen summausoperaattori "+" on binäärioperaattori. Se summaa vasemman ja oikean operandin ja palauttaa summan.

Muuttujan luku = 4 + 7;

Muuten, osoitus tapahtuu määritysoperaattorilla "=". Tämä operaattori arvioi oikean operandin arvon ja osoittaa sen vasemmalle operandille.

JavaScriptissä unary plusilla on vain yksi operandi. Unary plus ei ole aritmeettinen operaattori, se muuntaa operandin luvuksi.

Muutt myVar = "7"; document.write(typeof(myVar) + "
"); // Tulostaa merkkijonon myVar = +omaVar; document.write(typeof(myVar) + "
"); // Tulosta numero asiakirjaan

Aluksi myVar sisälsi merkkijonon "7", joka on merkkijonotyypin literaali, ei numero. Unary plus -operaattorin avulla muunnosimme merkkijonon literaalin numeeriseksi.

Aritmeettiset operaatiot

Aritmeettiset operaatiot ovat hyvin tunnettuja matemaattisia operaatioita.

Ehkä % (modulo) -operaattori kaipaa selvennystä. 9 jaetaan viidellä jäännöksellä 4, ja tämä operaattori palauttaa tämän jäännöksen. Sitä kutsutaan myös moduloksi. Kun käytetään kokonaislukuja, tämän operaattorin tulos on myös kokonaisluku. Kun käytetään liukulukuja, tuloksena on liukuluku.

5.5 % 2.2 = 1.1

Aritmeettisia operaatioita suoritettaessa on muistettava, että jos ne suoritetaan väärin, ne voivat johtaa seuraaviin tuloksiin:

• NaN (Not a Number) ei ole numero.
• Infinity - ääretön.

Tässä on mitä nollalla jakaminen tekee:

Muutt myVar = 0 / 0; document.write("Muuttujan arvo: " + myVar + ", sen tyyppi: " + typeof(myVar) + "
");

Vertailutoiminnot

Vertailuoperaattoreita käytetään lausekkeiden vertaamiseen. Lauseke, jossa on ehdollinen operaattori, palauttaa Boolen arvon - tosi tai epätosi (tosi / epätosi).

Vertailuoperaatioita voidaan suorittaa myös merkkijonojen avulla. Ainoa ehto oikealle tulokselle on täsmäyttää samantyyppiset tiedot. Muussa tapauksessa JavaScript yrittää muuntaa tietoja tyypistä toiseen, eikä tämä ole aina mahdollista. Virheiden välttämiseksi vertaa vain yhden tyypin tietoja.

Tehtäväoperaattorit

Ilmeisin esimerkki osoitusoperaattorista on yksinkertainen osoitus (=). Tätä operaattoria (=) käytetään arvon määrittämiseen muuttujalle.

Mutta on myös joukko määritysoperaattoreita, jotka ovat pikakuvakkeita.

Loogiset operaatiot

Boolen operaatioita käytetään usein if else-konstruktion kanssa JS:ssä. Heidän työnsä esitellään esimerkkien avulla. Mutta ensin luettelo loogisista operaattoreista.

Nyt yksinkertaisia ​​esimerkkejä:

If (tosi && tosi) document.write("Se toimii!
"); if (tosi || false) document.write("Se toimii!
"); if (!false) document.write("Se toimii!
");

Katsotaanpa näitä esimerkkejä:

Looginen AND-operaattori (&&) palauttaa arvon tosi, jos molemmat operandit ovat tosi.

Looginen TAI-operaattori (||) palauttaa tosi, jos ainakin yksi operandi on tosi.

Looginen EI (!) -operaattori ottaa yhden operandin ja kääntää tosi/epätosi-arvon.

Unaariset operaattorit

Unaarioperaattorit ovat operaattoreita, joilla on yksi operandi. Tässä on muutamia tällaisia ​​operaattoreita:

• ++ - lisää 1 (lisäys). Se voi olla etuliite ja jälkiliite, lisää siitä alla.
• -- - vähennä 1 (vähennä). Se voi olla etuliite ja jälkiliite, lisää siitä alla.
• + - yksipuolinen plus.
• - - yksipuolinen miinus.

Yksinäinen miinus

Unaarinen miinus kääntää lausekkeen etumerkin. Esimerkiksi kun kirjoitat -100 ohjelmaan, käytät yksinkertaisesti unaarista miinusta lukukirjaimeen 100.

Sinun on ymmärrettävä tarkasti, kuinka unaari miinus toimii - se palauttaa operandin arvon päinvastaisella merkillä. Tässä on esimerkki siitä, kuinka unaari-miinusta käytetään oikein:

Muutt myVar = -100; document.write(-myVar + " - unaari miinus toimi, mutta muuttuja myös = " + myVar + ".
"); myVar = -omaVar; document.write("Nyt muuttuja = " + myVar + ".
");

Annetaan merkityksetön esimerkki kaksinkertaisesta unaarisesta miinuksesta. Uskon, että siitä on hyötyä opetustarkoituksiin:

Muutt myVar = -100; document.write(--myVar + " on lisäys, ei kaksinkertainen unaari miinus.
"); document.write("Nyt muuttuja = " + myVar + ".
"); document.write(-(-myVar) + " ja tämä on unaari-miinus -merkin kaksoiskäyttö.
");

Yksinäinen plussa

Unary plus ei suorita matemaattisia operaatioita. Se heittää literaalin numeeriseen tyyppiin.

Var myVar = "78687"; document.write(typeof(myVar) + ".
"); myVar = +omaMuutt.; document.write(tyyppi(omaMuut.) + ".
");

Lisäys ja vähennys

Ohjelmoinnissa joudut usein lisäämään tai vähentämään muuttujan arvoa yhdellä. Tälle on unaarioperaattoreita:

• ++ - lisää 1 (lisäys).
• -- - vähennä 1 (vähennys).

Toisin kuin yksipuolinen plus ja miinus, lisäys ja vähennys muuttavat muuttujan arvoa kutsuttaessa.

Muutt myVar = 10; document.write(++myVar + ".
"); document.write(myVar + ".
");

Vähennys (--) toimii samalla tavalla.

Katsotaan nyt näiden operaattoreiden etu- ja jälkiliitteiden käyttöä.

• ++myVar - etuliite kasvaa yhdellä.
• myVar++ - postfixin lisäys 1:llä.

Ero on tämä:

• Näiden operaattoreiden etuliitekäyttö arvioi ensin unaarioperaattorin arvon ja käyttää sitten tulosta lausekkeessa.
• Postfixin käyttö arvioi ensin lausekkeen ja sen jälkeen unaarioperaattorin (++ tai -- ).

Yksinkertainen esimerkki auttaa sinua ymmärtämään tämän:

Muutt myVar = 10; document.write((++myVar + 5) + ".

"); var myVar = 10; document.write((omaMuuttu++ + 5) + ".
"); document.write("Muuttuja = " + myVar + ".
");

Lisäystä ja vähennystä voidaan käyttää vain muuttujien kanssa, niitä ei voi käyttää numeeristen literaalien kanssa. Yksinkertaisesti sanottuna ++7-koodi antoi virheen komentosarjassa.

Muut operaattorit

JavaScriptissä on muita operaattoreita:

• Kolmiosainen (kolme operandi) -operaattori

Asiakirjan sisällysluettelo

JavaScript tukee kompaktia joukkoa operaattoreita, joita voidaan käyttää interaktiivisten Web-sivujen luomiseen. Tämä luku sisältää yleiskatsauksen näistä operaattoreista.

Tämä luku sisältää seuraavat osiot, jotka tarjoavat lyhyen yleiskatsauksen jokaisesta lausunnosta:

• Operaattorilohko: ( )

• Ehdolliset lauseet: jos...else ja vaihda

• Silmukkalausekkeet: for, while, do...while, otsikko, katkaisee ja jatka (tunniste itsessään ei ole silmukkakäsky, mutta sitä käytetään usein tiettyjen lauseiden kanssa)

• Objektin manipulointioperaattorit: sisään ja kanssa

• Kommentit

• Poikkeuskäsittelyoperaattorit: kokeile... ota kiinni ja heitä

Mikä tahansa lauseke on myös operaattori. Katso luku 3 osiossa "Lausekkeet ja toiminnot" saadaksesi täydelliset tiedot toiminnoista.

Käytä puolipistettä (;) erottaaksesi lausunnot JavaScript-koodissa.

Katso kirja JavaScript Core. Hakemisto. lisätietoja operaattoreista tästä luvusta.

1. Lausekelohko Lauselohkoa käytetään lausekkeiden ryhmittelyyn. Lohko on rajattu kiharoilla aaltosulkeilla:

( lauseke1 lausunto2 . lauseke )

2. Ehdolliset lauseet Ehdollinen lauseke on joukko komentoja, jotka suoritetaan, jos määritetty ehto on tosi. JavaScript tukee kahta ehdollista lauseketta: if...else ja switch .2.1. if...else lauseke Tätä lausetta käytetään tiettyjen lauseiden suorittamiseen, jos Boolen ehto on tosi ; käytä valinnaista else - lohkoa muiden käskyjen suorittamiseen , jos ehto on epätosi . if-lause näyttää tältä:

jos (ehto) (lausekkeet1) [else (lausekkeet2)]

Ehto voi olla mikä tahansa JavaScript-lauseke, jonka arvo on tosi tai epätosi. Suoritettavat lauseet voivat olla mitä tahansa JavaScript-lauseita, mukaan lukien sisäkkäiset if-lauseet. Jos sinun on suoritettava useampi kuin yksi käsky if-tai else-lauseen jälkeen, sinun on suljettava nämä suoritettavat käskyt aaltosulkeisiin ().

Ehdollislausekkeessa ei saa käyttää yksinkertaisia ​​tehtäviä. ÄLÄ käytä esimerkiksi tällaista koodia:

Jos sinun on käytettävä tehtävää ehdollisessa käskyssä, kirjoita ylimääräisiä sulkeita tehtäväoperaattorin ympärille. Esimerkiksi if((x = y)) .

Älä sekoita primitiivisiä Boolen arvoja true ja false Boolen objektin todellisiin ja vääriin arvoihin. Kaikki objektit, joiden arvo ei ole määrittelemätön , null , nolla , **NaN** tai tyhjä merkkijono, mukaan lukien Boolen objekti, jonka arvo on false , evaluoituu tosi, kun se välitetään ehdolliseen lauseeseen. Esimerkiksi:

var b = uusi Boolen arvo(false); jos (b ) // tämä ehto on tosi

Esimerkki.

Tässä esimerkissä checkData-funktio palauttaa tosi, jos Teksti-objektin merkkien määrä on kolme; muussa tapauksessa tulostaa varoituksen ja palauttaa false .

funktio checkData () ( if (asiakirja . muoto1 . kolmimerkki . arvo . pituus == 3 ) ( return true ) else ( alert (" Syötä täsmälleen kolme merkkiä " + dokumentti . muoto1 . threeChar . arvo + " ei kelpaa." ) palauta väärä ))

2.2. Switch-lause Switch-käskyn avulla ohjelma voi arvioida lausekkeen ja yrittää sovittaa lausekkeen arvon tapausmerkinnän arvoon. Jos vastaavuus löytyy, ohjelma suorittaa siihen liittyvän käskyn. Kytkimen lausunto näyttää tältä:

kytkin (lauseke )( case label : lauseke ; break ; case label : lauseke ; break ; ... oletus : lauseke ;)

Ohjelma etsii ensin otsikon, joka vastaa lausekkeen arvoa ja suorittaa sitten siihen liittyvän käskyn. Jos vastaavaa nimiötä ei löydy, ohjelma etsii valinnaista oletuskäskyä ja suorittaa siihen liittyvän käskyn, jos se löytyy. Jos oletuskäskyä ei löydy, ohjelma jatkaa käskyn suorittamista switch-käskyn päättymisen jälkeen.

Tapaustasoon liittyvä valinnainen break-käsky varmistaa, että ohjelma katkaisee switch-käskyn suorittamisen heti, kun match-käsky on suoritettu, ja jatkaa suoritusta kytkinkäskyä seuraavasta käskystä. Jos break ei ole läsnä, ohjelma jatkaa seuraavan käskyn suorittamista switch-käskyn sisällä.

Esimerkki.

Tässä, jos expr evaluoi banaanit, ohjelma vastaa kirjainkoon Banaanit ja suorittaa siihen liittyvän käskyn. Jos break kohdataan, ohjelma katkaisee kytkimen ja suorittaa käskyn switch-käskylohkon jälkeen. Jos tauko puuttuu, myös kirsikoita koskeva lauseke suoritetaan.

kytkin (expr) ( case "Oranges" : document. write (" Appelsiinit ovat 0,59 dollaria paunalta.
" ); break ; case " Apples " : document . write ( " Omenat ovat 0,32 dollaria puntaa.
" ); break ; case " Banaanit " : document . write ( " Banaanit ovat 0,48 dollaria paunalta.
" ); break ; case " Cherries " : document . write ( " Kirsikat ovat 3,00 dollaria puntaa.
" ); break ; oletus : document . write ( " Anteeksi , olemme loppuneet " + i + " .
" ) ;) document . write (" Onko jotain muuta, mitä haluaisit?
" ) ;

3. Silmukkakäskyt Silmukka on joukko lauseita, jotka suoritetaan useita kertoja tietyn ehdon täyttyessä. JavaScript tukee , do...while ja while -silmukkalausekkeita sekä label-toimintoa (tunniste itsessään ei ole silmukkaoperaattori, mutta sitä käytetään usein määritettyjen lauseiden kanssa). Lisäksi voit käyttää katkeaa ja jatka-lauseita silmukkakäskyjen sisällä.

Toinen silmukkaoperaattori, for...in , suorittaa myös käskynsä syklisesti, mutta sitä käytetään työskentelemään objektien kanssa. Katso Objektin manipulointioperaattorit.

3.1. for Statement For-silmukka toistuu, kunnes määritetty arvo on epätosi. JavaScript for silmukka on samanlainen kuin Java ja C for -lause näyttää tältä:

for ([ originExpression ]; [ condition ]; [ incrementExpression ]) ( lausekkeet )

Kun for-silmukka suoritetaan, tapahtuu seuraavaa:

1. Alkulauseke, jos se on olemassa, suoritetaan. Tämä lauseke tyypillisesti alustaa yhden tai useamman silmukkalaskurin, ja syntaksi sallii kaiken monimutkaiset lausekkeet. Tämä lauseke voi myös ilmoittaa muuttujia.

2. Ehtolauseke arvioidaan. Jos ehto on tosi, silmukkakäskyt suoritetaan. Jos ehto on epätosi, for-silmukka päättyy. Jos ehtolauseke puuttuu kokonaan, ehdon oletetaan olevan tosi.

3. Lausunnot toteutetaan.

4. IncrementExpression, jos se on olemassa, suoritetaan ja ohjaus palaa vaiheeseen 2.

Esimerkki.

Tämä funktio sisältää for-lausekkeen, joka laskee valittujen vaihtoehtojen määrän vieritettävässä luettelossa (Valitse-objekti, jonka avulla voit valita useita kohteita). For-lause ilmoittaa muuttujan i ja alustaa sen nollaan. Se tarkistaa, onko i pienempi kuin Select-objektin vaihtoehtojen määrä, suorittaa if-käskyn ja kasvattaa muuttujaa i yhdellä jokaisen silmukan läpikulun jälkeen.

funktio howMony(selectObject) ( var numberSelected=0; for (var i=0; i< selectObject.options.length; i++) { if (selectObject.options[i].selected==true) numberSelected++; } return numberSelected; }

Valitse musiikkityyppejä ja napsauta alla olevaa painiketta:
R&B Jazz Blues New Age Klassinen ooppera

3.2. do...while-lause Do...while-lausetta toistetaan niin kauan kuin määritetty lauseke on epätosi. Do...while -lause näyttää tältä:

tehdä ( lause ) while ( ehto )

lauseke suoritetaan kerran ennen ehdon tarkistamista. Jos ehto on tosi, lauseke suoritetaan uudelleen. Kunkin suorituksen lopussa kunto tarkistetaan. Jos ehto on epätosi , suoritus pysähtyy ja hallinta siirtyy käskyyn do...while -toiminnon jälkeen.

Esimerkki.

Tässä esimerkissä do-silmukka iteroituu vähintään kerran ja toistaa iteraatiot niin kauan kuin i on pienempi kuin 5 .

do ( i += 1 ; dokumentti . kirjoittaa (i ) ; ) while (i< 5 ) ;

3.3. While-lause while-lause suorittaa lauseensa niin kauan kuin määritetty ehto on tosi. while-lause näyttää tältä:

while (ehto) (lausekkeet)

Jos ehdosta tulee epätosi , silmukan sisällä olevat käskyt lopettavat suorittamisen ja ohjaus siirtyy silmukan jälkeiseen seuraavaan lauseeseen.

Ehto tarkistetaan ennen kuin silmukan sisällä olevat lauseet suoritetaan. Jos ehto palauttaa tosi, lauseet suoritetaan ja ehto tarkistetaan uudelleen. Jos ehto palauttaa false , silmukka päättyy ja ohjaus siirtyy while-lausetta seuraavaan käskyyn.

Esimerkki 1.

Tämä while-silmukka toistuu, kunnes n on pienempi kuin 3:

n = 0; x = 0; kun (n< 3 ) { n ++; x += n ; }

Jokaisessa iteraatiossa silmukka lisää n:ää ja lisää tämän arvon x:ään. Siksi x ja n saavat seuraavat arvot:

• Ensimmäisen ajon jälkeen: n = 1 ja x = 1

• Toisen ajon jälkeen: n = 2 ja x = 3

• Kolmannen ajon jälkeen: n = 3 ja x = 6

Kolmen silmukan ajon jälkeen ehto n< 3 больше не true, поэтому выполнение цикла прерывается.

Esimerkki 2: Infinite loop.

Varmista, että silmukan ehdoista tulee koskaan epätosi; muuten sykli ei koskaan keskeydy. Seuraava while-silmukka suoritetaan loputtomasti, koska ehdosta ei koskaan tule epätosi:

while (tosi) (hälytys (" Hei, maailma " ) )

3.4. Label Statement Tarralauseke on tunniste, johon voidaan viitata mistä tahansa ohjelmasta. Voit esimerkiksi käyttää tunnistetta silmukan tunnistamiseen ja sitten lopettaa silmukan tai jatkaa suoritusta break- tai jatka-käskyjen avulla.

Tunnistelausekkeen syntaksi näyttää tältä:

otsikko: lausunto

Tunnisteen arvo voi olla mikä tahansa kelvollinen JavaScript-tunniste, joka ei ole varattu sana. Tunnisteella tunnistettu lausunto/lausunto voi olla mikä tahansa lausunto.

Esimerkki.

Tässä esimerkissä tarra markLoop identifioi while-silmukan.

markLoop : while (theMark == true ) doSomething () ; )

3.5. break-lause Käytä break-lausetta katkaistaksesi kytkinsilmukan tai nimikekäskyn.

• Jos käytät break-näppäintä ilman tunnistetta, se katkaisee välittömästi lähimmän sisältävän while , do-while , for or switch -käskyn ja siirtää ohjauksen seuraavalle käskylle.

• Jos käytät break with label -toimintoa, se katkaisee määritetyn otsikoitetun lauseen.

Break-lauseen syntaksi on:

1 . tauko 2. rikkoa etiketti

Ensimmäinen vaihtoehto katkaisee lähimmän sisältävän silmukan tai kytkimen ; toinen vaihtoehto keskeyttää määritellyn käskyn, jolla on tunniste.

Esimerkki.

Tämä toistuu taulukon elementtien läpi, kunnes elementin indeksi arvolla theValue löytyy:

for (i = 0; i< a . length ; i ++ ) { if (a [ i ] = theValue ) break ; }

3.6. Jatka-operaattori Jatka-operaattoria käytetään while-, do-while-, for- ja label -lausekkeiden uudelleenkäynnistykseen.

• Jos käytät jatka-toimintoa ilman tunnistetta, se katkaisee lähimmän while-, do-while- tai for-silmukan nykyisen iteraation ja jatkaa kyseisen silmukan suorittamista seuraavasta iteraatiosta. Toisin kuin break-lause, jatka ei keskeytä silmukan suorittamista kokonaan. While-silmukassa se menee kuntoon. For-silmukassa inkrementtilausekkeessa .

• Jos käytät jatka-tunnistetta, se koskee silmukkakäskyä, joka tunnistetaan.

Continue-lauseen syntaksi on:

1 . jatka 2. jatka etikettiä

Esimerkki 1.

Tämä on esimerkki while-silmukasta, jossa on jatkamiskäsky, joka suoritetaan, jos i:n arvo on 3 . Joten n saa arvot 1, 3, 7 ja 12.

i = 0; n = 0; sillä aikaa kun minä< 5 ) { i ++; if (i == 3 ) continue ; n += i ; }

Esimerkki 2.

Lause, jonka nimi on checkiandj, sisältää lauseen, jonka nimi on checkj . Jos jatkuu, ohjelma keskeyttää nykyisen checkj:n iteraation ja aloittaa seuraavan iteraation. Joka kerta, kun jatkaminen havaitaan, checkj aloittaa iteroinnin uudelleen, kunnes sen ehto palauttaa false . Jos false palautetaan, loput checkiandj-käskystä suoritetaan ja checkiandj toistetaan, kunnes sen ehto palauttaa epätosi. Jos palautetaan false, ohjelma jatkaa suoritusta checkiandj:n jälkeisestä käskystä.

Jos jatkalla on checkiandj-tunniste, ohjelma jatkaa suoritusta checkiandj-käskyn alusta.

checkiandj : while (ts< 4 ) { document . write (i + "
" ) ; i += 1 ; checkj : while (j > 4 ) ( dokumentti . kirjoittaa (j + "
" ) ; j -= 1 ; jos ((j % 2 ) == 0 ) jatka tarkistustaj ; dokumentti . kirjoittaa (j + " on pariton.
kirjoittaa ( " i = " + i + " ) dokumentti
" ); dokumentti . kirjoittaa ( " j = " + j + "
" ) ; }

4. Objektin manipulointioperaattorit JavaScript käyttää...in ja lauseiden kanssa manipuloidakseen kohteita.4.1. For...in-operaattori For...in-operaattori iteroi määritetyn muuttujan objektin kaikilla ominaisuuksilla. Jokaiselle saavutetulle ominaisuudelle JavaScript suorittaa määritetyt operaattorit. For...-in lausunto näyttää tältä:

For (muuttuja objektissa) (

Esimerkki.

Tämä funktio ottaa objektin ja objektin nimen argumenttina. Sitten se toistaa objektin kaikki ominaisuudet ja palauttaa merkkijonon - luettelon ominaisuuksien nimistä ja niiden arvoista.

funktio dump_props (obj , objektin_nimi ) ( var tulos = "" ; for (var i in obj ) ( tulos += objektin_nimi + " . " + i + " = " + obj [ i ] + "
" ) tulos += " " ; palauta tulos ;)

Autoobjektille, jolla on merkki- ja malliominaisuudet, tulos olisi:

auto. merkki = Ford-auto. malli=Mustang

4.2. with-lauseke with-käsky asettaa oletusobjektin käskylohkojoukolle. JavaScript tarkastelee määrittämättömiä nimiä käskylohkon sisällä ja määrittää, ovatko nimet oletuksena objektin ominaisuuksia. Jos määrittelemätön nimi on ominaisuus, tätä ominaisuutta käytetään lausunnossa; muussa tapauksessa käytetään paikallista tai globaalia muuttujaa.

Lauseke näyttää tältä:

kanssa (objekti)( lauseet)

Esimerkki.

Tässä with-käsky määrittää, että Math-objekti on oletusobjekti. With-käskyn jälkeiset lauseet käyttävät PI-ominaisuutta sekä cos- ja sin-menetelmiä määrittelemättä objektia. JavaScript hyväksyy matemaattisen objektin näiden kutsujen objektiksi.

var a , x , y ;; var r = 10 ja (Math) (a = PI * r * r ; x = r * cos (PI ) ; y = r * sin (PI / 2); )

Huomautus:

With-käskyn käyttäminen voi hidastaa ohjelman suorittamista merkittävästi.

5. Kommentit Kommentit selittävät yleensä, mitä koodi tekee. Tulkki jättää kommentit huomioimatta. JavaScript tukee Java- ja C++-tyylisiä kommentteja:

• Yksirivinen kommentti, jossa on kaksoisviiva rivin alussa (//).

• Monirivinen kommentti /* alussa ja */ lopussa.

Esimerkki.

Tässä on esimerkki kahdesta kommentista:

// Tämä on yksirivinen kommentti. /* Ja tämä on monirivinen. Se voi olla minkä pituinen tahansa ja voit laittaa tänne mitä haluat. */

6. Poikkeuskäsittelyoperaattorit Voit nostaa poikkeuksen throw-käskyllä ​​ja käsitellä sitä try...catch-käskyillä.

Try...catch-käskyä käytetään myös Java-poikkeuksien käsittelyyn. Katso Java-poikkeuksien käsitteleminen JavaScriptissä ja JavaScript-poikkeusten käsittely Javassa.

6.1. Throw-lause Heitto-lausetta käytetään heittämään poikkeus. Jos teet poikkeuksen, määrität lausekkeen, joka sisältää poikkeuksen arvon:

heittää ilme

Seuraava koodi antaa useita poikkeuksia.

heittää "Error2" ; // heittää poikkeuksen merkkijonoarvolla heitto 42 ; // heittää poikkeuksen arvolla 42 throw true ; // heittää poikkeuksen arvolla true

Kun teet poikkeuksen, voit määrittää objektin. Tämän jälkeen pääset käsiksi kohteen ominaisuuksiin catch-lohkossa. Seuraava esimerkki luo myUserException-objektin, jonka tyyppi on UserException, ja käyttää sitä throw-käskyssä.

// Luodaan UserException-tyyppinen objekti funktio UserException (viesti) ( this . message = message ; this . name = " UserException " ; ) // Objektin esiintymä luodaan ja sitä kutsutaan nimellä myUserException = new UserException ( " Arvo liian korkea " ) ; heittää myUserException ;

6.2. try...catch-lause try...catch-käsky merkitsee lausekkeiden lohkon, yrittää suorittaa ne ja määrittää yhden tai useamman mahdollisen vastauksen poikkeuksen sattuessa. Jos tapahtuu poikkeus, try...catch-käsky saa sen kiinni.

try...catch-käsky koostuu try-lohkosta, joka sisältää yhden tai useamman käskyn, ja nollasta tai useammasta catch-lohkosta, jotka sisältävät käskyjä, jotka määrittelevät, mitä tehdä, kun try-lohkossa tehdään poikkeus. Eli jos haluat suorittaa try-lohkon, mutta se ei suorita, annat ohjauksen catch-lohkolle. Jos jokin try-lohkon (tai try-lohkon sisältä kutsutun funktion käsky) antaa poikkeuksen, ohjaus siirtyy välittömästi catch-lohkoon. Jos poikkeusta ei heitetty, kiinnityslohko ohitetaan. Lopullinen lohko suoritetaan sen jälkeen, kun try and catch -lauseet on suoritettu, mutta ennen kuin try...catch -lauseen jälkeinen käsky suoritetaan.

Seuraava esimerkki käyttää try...catch-käskyä. Kutsutaan funktio, joka pyytää taulukosta kuukauden nimen funktiolle välitetyn arvon perusteella. Jos arvo ei vastaa kuukauden numeroa (1-12), annetaan poikkeus arvolla "InvalidMonthNo" ja catch block -lauseet asettavat muuttujan monthName arvoksi tuntematon.

funktio getMonthName (mo ) ( mo = mo - 1 ; // Kuukauden numero määritellään taulukon indeksillä (1=tam, 12=dec) var months = new Array (" tammi " , " helmikuu " , " maalis " , " huhtikuu " , " toukokuu " , " kesäkuu " , " heinäkuu " , " elokuu " , " syyskuu " , " loka " , " marraskuu " , " joulukuu " ) if ( kuukautta [ kk ] ! = null ) ( paluukuukaudet ; [ mo ] ) else ( heittää " InvalidMonthNo " ) ) try ( // yritä suorittaa nämä lauseet: monthName = getMonthName (myMonth ) // funktio saattaa heittää poikkeuksen ) catch (e ) ( monthName = " tuntematon " logMyErrors (e ) // poikkeuksen aiheuttanut objekti välitetään poikkeuskäsittelijälle)

heittää ; voit käyttää tätä tunnistetta saadaksesi tietoja poikkeuksesta. JavaScript luo tämän tunnisteen syöttäessään catch-lohkon; tunniste on olemassa vain catch-lohkon suorittamisen aikana; Kun catch-lohko on suoritettu loppuun, tunniste ei ole enää käytettävissä.

Esimerkiksi seuraava koodi heittää poikkeuksen. Jos tapahtuu poikkeus, ohjaus välitetään catch-lohkolle.

yritä (heittää "myException" // poikkeus heitetään) catch (e) ( // operaattorit käsittelemään poikkeuksia logMyErrors (e) // poikkeus välitetään virheenkäsittelijälle)

Useita kiinnityslohkoja

Yksi try-lause voi sisältää useita catch-lauseita, joista jokainen käsittelee tietyntyyppisiä poikkeuksia. Tässä tapauksessa asianmukainen ehdollinen catch-lohko syötetään vain, kun kyseiselle lohkolle määritetty poikkeus nostetaan. Voit myös valinnaisesti sisällyttää erillisen catch-lohkon kaikille määrittelemättömille poikkeuksille viimeisenä catch-lohkona käskyssä.

Esimerkiksi seuraava funktio kutsuu kolmea muuta funktiota (ilmoitettu muualla), jotka testaavat sen argumentteja. Jos vahvistustoiminto määrittää, että testattava komponentti on virheellinen, se palauttaa 0:n, jolloin kutsuva funktio heittää määritetyn poikkeuksen.

funktio getCustInfo (nimi , tunnus , sähköposti ) ( var n , i , e ; if (! validate_name (nimi )) heittää " InvalidNameException " else n = nimi ; if (! validate_id (id )) heittää " InvalidIdException " else i = id if (! validate_email ( email )) throw " InvalidEmailException " else e = email = ( n + " " + i + " " + e ) ;

Ehdolliset catch-lohkot ohjaavat asianmukaisen poikkeuskäsittelijän kutsumista.
" ) ( // kutsuu virheellisen ids-käsittelijän bad_id_handler (e ) ) catch (e if e == " InvalidEmailException " ) ( // kutsuu virheellisen sähköpostiosoitteen käsittelijän bad_email_handler (e ) ) catch (e )( // tuntematon poikkeus on kirjoitettu lokitiedostoon logError (e) )

vihdoin esto

Lopullinen lohko sisältää käskyt, jotka suoritetaan try and catch -lauseiden suorittamisen jälkeen, mutta ennen kuin try...catch -lauseen jälkeen tulevat käskyt suoritetaan. Lopullinen lohko suoritetaan riippumatta siitä, heitetäänkö poikkeus. Jos poikkeus heitetään, lopullisen lohkon käskyt suoritetaan, vaikka mikään catch-lohko ei olisi käsitellyt poikkeusta.

Voit käyttää lopullista estoa lopettaaksesi skriptin sulavasti, kun poikkeus tapahtuu; saatat joutua esimerkiksi vapauttamaan komentosarjan sitoman resurssin. Seuraavassa esimerkissä tiedosto avataan ja operaattorit toimivat sillä (palvelinpuolen JavaScript sallii pääsyn tiedostoihin). Jos poikkeus tehdään tiedoston ollessa auki, lopullinen lohko sulkee tiedoston ennen kuin komentosarja epäonnistuu.

openMyFile(); yritä ( writeMyFile ( theData ) ) vihdoin ( closeMyFile ( ) // resurssi on aina suljettu )

Pesäkokeilu...saappaa lausunnot

Voit upottaa yhden tai useamman try...catch lausunnon toistensa sisään. Jos sisäisessä try...catch-käskyssä ei ole catch-lohkoa, tarkistetaan sisältävän try...catch-lauseen catch-lohko vastaavuus.

Tässä luvussa kuvataan JavaScript-lausekkeet ja -operaattorit, kuten osoitus, vertailu, aritmeettinen, bittikohtainen, looginen, merkkijono ja erilaiset erikoisoperaattorit.

Tässä oppaassa on myös täydellinen ja yksityiskohtainen luettelo operaattoreista ja ilmauksista.

Operaattorit

JavaScriptillä on seuraavan tyyppiset operaattorit. Tässä alaosassa kuvataan kutakin tyyppiä ja annetaan tietoja niiden etusijasta toisiinsa nähden.

JavaScript tukee binääri- ja unaarioperaattoreita sekä toista erityistä kolmiosaista operaattoria, ehdollista operaattoria. Binäärioperaatio käyttää kahta operandia, yhtä ennen operaattoria ja yhtä sen jälkeen:

operandi1 operaattori operandi2

Esimerkiksi: 3+4 tai x*y.

Unaarioperaatio puolestaan ​​käyttää yhtä operandia ennen tai jälkeen operaattorin:

operaattori operandi operandi operaattori

Esimerkki: x++ tai ++x .

Tehtäväoperaattorit

Osoitusoperaation tuloksena osoitusoperaattorin vasemmalla puolella oleva operandi (merkki "=") asetetaan arvoon, joka on otettu oikealta operandilta. Perusosoitusoperaattori on =, joka määrittää oikean operandin arvon vasemmanpuoleiselle operandille. Siten lauseke x = y tarkoittaa, että x:lle on annettu y:n arvo.

On myös yhdistelmäosoitusoperaattoreita, joita käytetään esittämään lyhennettynä seuraavassa taulukossa kuvatut toiminnot:

Luettelo toimeksiantooperaattoreista Nimi Lyhennetty operaattori Merkitys

Tehtävä	x = y	x = y
Tehtävä lisäyksellä	x += y	x = x + y
Tehtävä vähennyksellä	x -= y	x = x - y
Tehtävä kertolaskulla	x *= y	x = x * y
Tehtävä jakoineen	x/=y	x = x / y
Modulotehtävä	x %= y	x = x % y
Vasen vuorotehtävä	x>y
Allekirjoittamaton vuoro oikealle	x >>>= y	x = x >>> y
Tehtävä bittikohtaisesti AND	x &= y	x = x & y
Tehtävä bittikohtaisella XOR:lla	x^=y	x = x^y
Tehtävä bittikohtaisesti TAI	x |= y	x = x | y

Tuhoaminen

Monimutkaisempia määrityksiä varten JavaScript sisältää rakenteen purkavan syntaksin, lausekkeen, jonka avulla voit noutaa tietoja taulukoista tai objekteista käyttämällä syntaksia, joka peilaa taulukon rakentajia ja objektiliteraaaleja.

Var foo = ["yksi", "kaksi", "kolme"]; // ilman rakennemuutosta var one = foo; var kaksi = foo; var kolme = foo; // rakennemuutoksilla var = foo;

Vertailuoperaattorit

Voit käyttää delete-operaattoria implisiittisesti ilmoitettujen muuttujien poistamiseen, mutta et voi käyttää sitä sellaisten muuttujien poistamiseen, jotka on ilmoitettu parametrilla var.

Poista-operaattorin käyttöönoton jälkeen elementin ominaisuus muuttuu muotoon undefined . Poista-operaattori palauttaa true, jos operaatio on mahdollista; operaattori palauttaa false, jos toimintoa ei voida suorittaa.

X = 42; var y = 43; myobj = uusi Numero(); myobj.h = 4; // luo ominaisuus h poista x; // palauttaa tosi (voit poistaa implisiittisesti ilmoitetun muuttujan) delete y; // palauttaa false (et voi poistaa muuttujaa, joka on ilmoitettu komennolla var) delete Math.PI; // palauttaa false (sisäänrakennettuja ominaisuuksia ei voi poistaa) delete myobj.h; // palauttaa tosi (voit poistaa mukautettuja ominaisuuksia) delete myobj; // palauttaa tosi (voit poistaa implisiittisesti määritellyn objektin)

Array Elementtien poistaminen

Taulukon elementin poistaminen ei vaikuta taulukon pituuteen. Jos esimerkiksi poistat a, elementti a pysyy a:na ja a muuttuu määrittelemättömäksi.

Kun taulukon elementti poistetaan käyttämällä delete-operaattoria, kyseisen elementin arvo poistetaan taulukosta. Seuraavassa esimerkissä puut-elementti poistetaan käyttämällä delete-operaattoria. Puut-elementti pysyy kuitenkin osoitettavissa ja palauttaa määrittämättömän .

Var puut = new Array("punapuu", "lahti", "setri", "tammi", "vaahtera"); poistaa puita; jos (3 puissa) ( // ehto ei täyty)

Jos haluat elementin pysyvän taulukossa, mutta sillä on määrittelemätön arvo, käytä undefined-avainsanaa delete-operaattorin sijaan. Seuraava esimerkki asettaa trees-elementin arvoon undefined , mutta elementti pysyy taulukossa:

Var puut = new Array("punapuu", "lahti", "setri", "tammi", "vaahtera"); puut = määrittelemätön; if (3 puissa) ( // tämä koodilohko suoritetaan)

operaattorin tyyppi

Käytä instanceof-operaattoria, kun sinun on vahvistettava objektin tyyppi ohjelman suorittamisen aikana. Esimerkiksi poikkeuksia kerättäessä voit luoda erilaisia ​​ohjelmointisiirtymiä käsittelemään poikkeuksia käsiteltävän poikkeuksen tyypin mukaan.

Esimerkiksi seuraava koodi käyttää instanceof-operaattoria testatakseen, onko Day-objekti Date-objekti. Koska theDay on todellakin Date-objekti, ohjelma suorittaa if-käskyn sisältämän koodin.

Muutt theDay = uusi päivämäärä(1995, 12, 17); if (päivämäärän esiintymä) ( // suoritettava koodi )

Operaattorin etusija

Prioriteetti operaattorit määrittää järjestyksen, jossa ne suoritetaan, kun se arvioi lauseketta. Voit vaikuttaa operaattoreiden tärkeysjärjestykseen suluilla.

Alla olevassa taulukossa kuvataan operaattorin ensisijaisuus korkeimmasta pienimpään.

Taulukko 3.7 Käyttäjän prioriteetti Käyttäjätyyppi Operaattorit

esineen omaisuutta	.
kutsua, ilmentää esine	() Uusi
kieltäminen, lisäys	! ~ - + ++ -- tyhjän poiston tyyppi
kertolasku, jako	* / %
yhteen-, vähennys-	+ -
bitin muutos	> >>>
vertailu, esiintyminen	< >= tapauksessa
tasa-arvo	== != === !==
bitti-ja	&
bittinen yksinomainen-tai	^
bit-tai	|
boolen-ja	&&
boolen-tai	||
ehdollinen (kolmiosainen) operaattori	?:
toimeksianto	= += -= *= /= %= = >>>= &= ^= |=
pilkku	,

Tämän taulukon tarkempi versio, joka sisältää linkkejä ja lisätietoja kullekin operaattorille, löytyy JavaScript-viittauksesta.

Ilmaisut

Ilmaisu on mikä tahansa kelvollinen koodilohko, joka palauttaa arvon.

Käsitteellisesti on olemassa kahden tyyppisiä lausekkeita: ne, jotka antavat arvon muuttujalle, ja ne, jotka arvioivat arvon määrittämättä sitä.

Lauseke x = 7 on esimerkki ensimmäisen tyyppisestä lausekkeesta. Tämä ilmaus käyttää operaattori= antaa muuttujalle x arvon 7 . Itse lauseke on myös yhtä kuin 7.

Koodi 3 + 4 on esimerkki toisen tyyppisestä lausekkeesta. Tämä ilmaus käyttää operaattori"+" numeroiden 3 ja 4 lisäämiseen ilman, että tuloksena olevaa tulosta 7 annetaan muuttujalle.

Kaikki JavaScript-lausekkeet on jaettu seuraaviin luokkiin:

Peruslausekkeet

Perusavainsanat ja peruslausekkeet JavaScriptissä.

Tämä operaattori

Käytä tätä avainsanaa osoittaaksesi nykyiseen objektiin. Yleensä tämä viittaa kutsuttavaan objektiin, joka omistaa menetelmän. Käytä tätä näin:

Tämä["omaisuudenNimi"] this.propertyName

Oletetaan, että validointitoiminto tarkistaa jonkin objektin arvon ominaisuuden; kohde on määritetty sekä tämän ominaisuuden arvon ylä- ja alarajat:

Funktio valide(obj, lowval, hival)( if ((obj.arvo< lowval) || (obj.value >hival)) alert("Virheellinen arvo!"); )

Voit kutsua validointifunktiota onChange-tapahtumakäsittelijässä jokaiselle lomakeelementille osoittamaan lomakeelementtiin seuraavan esimerkin mukaisesti:

Syötä numero väliltä 18-99:

Ryhmittelyoperaattori

Sulkujen ryhmittelyoperaattori () ohjaa lausekkeiden arviointiprioriteettia. Voit esimerkiksi määrittää järjestyksen uudelleen - "kerto ja jaa ennen yhteen- ja vähennyslaskua" niin, että esimerkiksi yhteenlasku tehdään ennen kertolaskua:

Var a = 1; var b = 2; var c = 3; // tavallinen järjestys a + b * c // 7 // tehty tavalliseen tapaan, joten a + (b * c) // 7 // nyt muuta järjestystä // yhteenlasku ennen kertolaskua (a + b) * c // 9 // joka vastaa seuraavaa a * c + b * c // 9

Yksinkertaistettu syntaksi taulukoiden ja generaattoreiden luomiseen

Yksinkertaistettu syntaksi on kokeellinen JavaScript-ominaisuus, joka voidaan lisätä tuleviin ECMAScript-versioihin. Syntaksista on 2 versiota:

Yksinkertaistettu syntaksi taulukoille. ((x of y) y) Yksinkertaistettu syntaksi generaattoreille.

Yksinkertaistettuja syntakseja on monissa ohjelmointikielissä, ja niiden avulla voit nopeasti koota uuden taulukon olemassa olevan taulukon perusteella. Esimerkiksi:

) i*i ]; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; ; // [ "a", "b", "c" ]

Vasenkätiset ilmaisut

Vasemmalla olevat arvot on määritetty oikeanpuoleisille arvoille.

Uusi

Voit käyttää uutta operaattoria mukautetun tyyppisen objektin tai jonkin sisäänrakennetun objektin muodostamiseen. Käytä uutta operaattoria näin:

Muutt objektinNimi = uusi objektityyppi();

super

Avainsanaa käytetään pääobjektin funktioiden kutsumiseen. Tämä on hyödyllistä myös luokissa, joissa esimerkiksi kutsutaan vanhemman rakentajaa.

Super(); // kutsuu vanhemman rakentajaa. super.functionOnParent();

Laajennusoperaattori

Laajennusoperaattori sallii lausekkeen laajentumisen paikkoihin, joissa on useita argumentteja (funktiokutsuille) tai useita elementtejä (taulukoita varten).

Esimerkki: Jos sinulla on tänään taulukko ja haluat luoda uuden olemassa olevalla osalla ensimmäisestä, kirjaimellinen taulukon syntaksi ei enää riitä ja sinun on kirjoitettava pakottava (ei muunnelmia) koodi käyttämällä push-yhdistelmää, liitos, concat jne. Mutta tällä operaattorilla koodi lyhenee:

Var osat = ["olkapää", "polvet"]; var lyrics = ["pää", ...osat, "ja", "varpaat"];

Operaattori toimii samalla tavalla funktiokutsujen kanssa:

Funktio f(x, y, z) ( ) var args = ; f(...args);

JavaScriptin lausekkeet ovat yhdistelmiä operandit Ja operaattorit.

Toiminnot lausekkeissa suoritetaan peräkkäin prioriteetin arvon mukaisesti (mitä korkeampi prioriteettiarvo, sitä suurempi se on). Palautettu tulos ei aina ole samaa tyyppiä kuin käsiteltävän tiedon tyyppi. Esimerkiksi vertailuoperaatioissa käytetään erityyppisiä operandeja, mutta palautustulos on aina looginen tyyppi.

Riisi. 1. Lausekerakenne JavaScriptissä

Operandit ovat JavaScript-komentosarjan käsittelemiä tietoja. Operandit voivat olla yksinkertaisia ​​tai monimutkaisia ​​tietotyyppejä sekä muita lausekkeita.

Operaattorit ovat kielisymboleja, jotka suorittavat erilaisia ​​toimintoja datalle. Operaattorit voidaan kirjoittaa käyttämällä välimerkkejä tai avainsanoja.

Operandien lukumäärästä riippuen erotetaan seuraavat operaattorityypit:
unary - yksi operandi on mukana operaatiossa;
binääri - operaatioon kuuluu kaksi operandia;
ternäärinen - yhdistää kolme operandia.

Lausekkeen yksinkertaisin muoto on literaali - jotain, joka arvioi itsestään, esimerkiksi numero 100, merkkijono "Hei maailma". Muuttuja voi olla myös lauseke, koska se evaluoituu sille annettuun arvoon.

Lausekkeet ja operaattorit JavaScriptissä 1. Aritmeettiset operaattorit

Aritmeettiset operaattorit on suunniteltu suorittamaan matemaattisia operandeja (tai muuttujia, jotka tallentavat numeerisia arvoja) ja palauttavat tuloksena numeerisen arvon.

Jos jokin operandeista on merkkijono, JavaScript-tulkki yrittää muuntaa sen numeeriseksi ja suorittaa sitten asianmukaisen toiminnon. Jos tyyppimuunnos ei ole mahdollista, tuloksena on NaN (ei numero).

Taulukko 1. Aritmeettiset operaattorit Käyttäjä/toiminto Kuvaus Prioriteetti

+ Lisäys	Lisää numeeriset operandit. Jos yksi operandeista on merkkijono, lausekkeen tulos on merkkijono.	12
- Vähennys	Vähentää toisen operandin ensimmäisestä.	12
- Yksinäinen miinus	Muuntaa positiivisen luvun negatiiviseksi luvuksi ja päinvastoin.	14
* Kertominen	Kertoo kaksi operandia.	13
/ Division	Jakaa ensimmäisen operandin toisella. Jaon tulos voi olla joko kokonaisluku tai liukuluku.	13
% Modulo-divisioona (jaon jäännös)	Laskee jäännöksen, joka saadaan ensimmäisen operandin kokonaislukujaosta toisella. Koskee sekä kokonaislukuja että liukulukuja.	13

var x = 5, y = 8, z; z = x + y; // palauttaa 13 z = x - y; // paluu -3 z = - y; // paluu -8 z = x * y; // palauttaa 40 z = x / y; // paluu 0,625 z = y % x; // return 3 2. Tehtäväoperaattorit

Määritysoperaattoreita käytetään arvojen määrittämiseen muuttujille. Yhdistettyjen operaattorien avulla voit tallentaa alkuperäiset ja myöhemmät arvot yhteen muuttujaan.

var a = 5; // määritä numeerinen arvo 5 muuttujalle a var b = "hello"; // tallenna merkkijono hellow muuttujaan b var m = n = z = 10; // anna muuttujille m, n, z numeerinen arvo 10 x += 10; // vastaa x = x + 10; x = 10; // vastaa x = x - 10; x * = 10; // vastaa x = x * 10; x /= 10; // vastaa x = x / 10; x % = 10; // vastaa x = x % 10; 3. Lisäys- ja vähennysoperaattorit

Lisäys- ja vähennysoperaatiot ovat unaarisia ja lisäävät ja vähentävät operandin arvoa yhdellä. Operandi voi olla muuttuja, taulukkoelementti tai objektiominaisuus. Useimmiten tällaisia ​​operaatioita käytetään laskurin kasvattamiseen silmukassa.

var x = y = m = n = 5, z, s, k, l; z = ++x*2; /* laskennan tuloksena palauttaa arvon z = 12, x = 6, ts. x:n arvoa kasvatetaan ensin yhdellä ja sitten suoritetaan kertolasku */s = y++ * 2; /* laskennan tuloksena palauttaa arvon s = 10, y = 6, ts. Ensin suoritetaan kertolasku, jonka jälkeen 1:llä korotettu arvo tallennetaan muuttujaan y */ k = --m * 2; // palauttaa arvon k = 8, m = 4 l = n-- * 2; // palauttaa arvon l = 10, n = 4 4. Vertailuoperaattorit

Vertailuoperaattoreita käytetään operandien vertailuun, lausekkeen tulos voi olla toinen kahdesta arvosta - tosi tai epätosi. Operandit voivat olla paitsi numeroita, myös merkkijonoja, loogisia arvoja ja objekteja. Vertailuja voidaan kuitenkin tehdä vain numeroille ja merkkijonoille, joten operandit, jotka eivät ole numeroita tai merkkijonoja, muunnetaan.

Jos kumpaakaan operandia ei voida onnistuneesti muuntaa numeroiksi tai merkkijonoiksi, operaattorit palauttavat aina false .

Jos molemmat operandit ovat merkkijonoja/lukuja tai ne voidaan muuntaa merkkijonoiksi/luvuiksi, niitä verrataan merkkijonoina/lukuina.

Jos yksi operandi on merkkijono/muuntaa merkkijonoksi ja toinen on luku/muuntaa luvuksi, operaattori yrittää muuntaa merkkijonon luvuksi ja suorittaa numerovertailun. Jos merkkijono ei ole luku, se muunnetaan NaN:ksi ja vertailun tulos on false .

Useimmiten vertailutoimintoja käytetään ohjelmien konttoreiden järjestämisessä.

Taulukko 4. Vertailuoperaattorit Käyttäjä/toiminto Kuvaus Prioriteetti

== Tasa-arvo	Testaa kahta arvoa samalle arvolle, mikä mahdollistaa tyypin muuntamisen. Palauttaa tosi, jos operandit ovat samat, ja epätosi, jos ne ovat erilaisia.	9
!= Epätasa-arvo	Palauttaa tosi, jos operandit eivät ole yhtä suuret	9
=== Identiteetti	Testaa kahta operandia "identiteetin" varalta käyttämällä tiukkaa vastaavuuden määritelmää. Palauttaa tosi, jos operandit ovat yhtä suuret ilman tyyppimuunnosa.	9
!== Ei-identiteetti	Suorittaa henkilöllisyyden vahvistuksen. Palauttaa tosi, jos operandit eivät ole yhtä suuret ilman tyyppimuunnosa.	9
> Lisää	Palauttaa tosi, jos ensimmäinen operandi on suurempi kuin toinen, muussa tapauksessa palauttaa epätosi.	10
>= Suurempi tai yhtä suuri kuin	Palauttaa tosi, jos ensimmäinen operandi ei ole pienempi kuin toinen, muussa tapauksessa palauttaa epätosi.	10
	Palauttaa tosi, jos ensimmäinen operandi on pienempi kuin toinen, muussa tapauksessa palauttaa epätosi.	10
	Palauttaa tosi, jos ensimmäinen operandi ei ole suurempi kuin toinen, muussa tapauksessa palauttaa epätosi.	10

5 == "5"; // palauttaa tosi 5 != -5.0; // palauttaa tosi 5 === "5"; // return false false === false; // palauttaa tosi 1 !== tosi; // palauttaa tosi 1 != tosi; // palauttaa false, koska tosi muunnetaan arvoksi 1 3 > -3; // palauttaa tosi 3 >= "4"; // return false 5. Loogiset operaattorit

Loogisten operaattorien avulla voit yhdistää ehtoja, jotka palauttavat Boolen arvoja. Useimmiten käytetty if-ehdollinen lauseke.

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); // palauttaa arvon tosi, jos x on välillä 0-10 !false; // palauttaa tosi 6. Bittioperaattorit

Bittioperaattorit käyttävät operandiaan 32-bittisenä ykkösten ja nollien sarjana ja palauttavat toiminnon tulosta edustavan numeerisen arvon, joka on kirjoitettu desimaalimuodossa. Kokonaislukuja pidetään operandeina; operaandin murto-osa hylätään. Bittitoimintoja voidaan käyttää esimerkiksi tiedon salaamiseen, lippujen kanssa työskentelyyn ja käyttöoikeuksien rajaamiseen.

Taulukko 6. Bittioperaattorit Käyttäjä/toiminto Kuvaus Prioriteetti

& Bittikohtaisesti JA	Jos molemmat bitit ovat 1, tuloksena oleva bitti on 1. Muuten tulos on 0.	8
| Bittikohtaisesti TAI	Jos jokin operandi sisältää 1:n kohdassa, tulos sisältää myös 1:n kyseisessä paikassa, muuten tulos kyseisessä paikassa on 0.	6
^ Yksinomainen TAI	Jos yksi ja vain yksi arvo sisältää 1:n missä tahansa paikassa, tulos sisältää 1:n kyseisessä paikassa, muuten tulos kyseisessä paikassa on 0.	7
~ Kieltäminen	Lausekkeen arvon binääriesitykseen suoritetaan bittikohtainen negaatio. Mikä tahansa sijainti, joka sisältää 1:n alkuperäisessä lausekkeessa, korvataan 0:lla. Mistä tahansa sijainnista, joka sisältää 0:n alkuperäisessä lausekkeessa, tulee 0. Positiiviset luvut alkavat 0:sta, negatiiviset luvusta -1, joten ~ n == -(n+1) .	14
	Operaattori siirtää ensimmäisen operandin bittejä vasemmalle toisen operandin asettamien bittipaikkojen lukumäärän verran. Nollia käytetään oikeanpuoleisten paikkojen täyttämiseen. Palauttaa samantyyppisen tuloksen kuin vasen operandi.	11
>> Bitti kerrallaan oikealle	Operaattori siirtää ensimmäisen operandin bittejä oikealle toisen operandin asettamien bittipaikkojen lukumäärän verran. Alueen ulkopuolelle siirretyt numerot poistetaan. Merkittävin bitti (32.) jätetään ennalleen, jotta tuloksen etumerkki säilyy. Jos ensimmäinen operandi on positiivinen, tuloksen merkittävimmät bitit täytetään nolilla; jos ensimmäinen operandi on negatiivinen, tuloksen merkittävimmät bitit täytetään ykkösillä. Arvon siirtäminen oikealle yhdellä pisteellä vastaa jakamista kahdella (jäännösosan hylkäämistä), ja arvon siirtäminen oikealle kahdella asemalla vastaa jakamista 4:llä jne.	11
>>> Bittisuuntainen siirto oikealle ilman etumerkkiä	Operaattori siirtää ensimmäisen operandin bittejä oikealle toisen operandin asettamien bittipaikkojen lukumäärän verran. Nollat ​​lisätään vasemmalle ensimmäisen operandin etumerkistä riippumatta. Alueen ulkopuolelle siirretyt numerot poistetaan.	11

var x = 9, y = 5, z = 2, s = -5, tulos; // 9 vastaa 1001, 5 vastaa 0101 tulos = x & y; // palauttaa 1 (vastaa 0001) tulos = x | y; // palauttaa 13 (vastaa 1101) tulos = x ^ y; // palauttaa 12 (vastaa 1100) tulos = ~ y; // palauttaa -6 (vastaa 1100) tulos = x > z; // palauttaa 2 (vastaa 10) tulos = s >>> z; // palauttaa 1073741822 (vastaa 111111111111111111111111111110) 7. Merkkijonooperaattorit

On olemassa useita operaattoreita, jotka työskentelevät merkkijonojen kanssa erityisillä tavoilla.

"1" + "10"; // palauttaa "110" "1" + 10; // palauttaa "110" 2 + 5 + "värikynät"; // palauttaa "7 värikynät" "Värikynät" + 2 + 5; // palauttaa "25 värikynää" "1" > "10"; // palauttaa epätosi "10" 10 ? x * 2: x / 2; // palauttaa x * 2, jos x > 10, muuten x / 2 9. Kommentit JavaScriptissä

Yksirivinen kommentti: Kommenttitekstiä edeltää symbolit // .