Kuinka tarkistaa muuttujan tyyppi oikein JavaScriptissä. Javascript typeof getter -operaattori tarkista muuttujan tyyppi

Operaattori tyyppi palauttaa merkkijonon, joka ilmaisee operandin tyypin.

Syntaksi

Operandi noudattaa operaattorin tyyppiä:

Tyyppi operandi

Vaihtoehdot

operandi on lauseke, joka edustaa objektia tai primitiiviä, jonka tyyppi palautetaan.

Kuvaus

Seuraava taulukko näyttää mahdolliset tyypin palautusarvot. Lisätietoa tyypeistä ja primitiiveistä löytyy sivulta.

Esimerkkejä

// Numeroiden tyyppi 37 === "numero"; tyyppi 3.14 === "numero"; typeof(42) === "numero"; typeof Math.LN2 === "numero"; typeof Infinity === "luku"; NaN tyyppi === "luku"; // vaikka tämä on "Not-A-Number"-tyyppinen Number(1) === "numero"; // Älä käytä tätä merkintää! // Merkkijonojen tyyppi "" === "merkkijono"; "bla" === "merkkijono"; tyyppi "1" === "merkkijono"; // Huomaa, että merkkijonon sisällä oleva numero on edelleen merkkijonotyyppiä (typeof 1) === "string"; // typeof palauttaa aina merkkijonon tässä tapauksessa typeof String("abc") === "merkkijono"; // Älä käytä tätä merkintää! // Boolen typeof true === "boolean"; typeof false === "looginen"; typeof Boolen(true) === "looginen"; // Älä käytä tätä merkintää! // Symbols typeof Symbol() === "symbol" typeof Symbol("foo") === "symbol" typeof Symbol.iterator === "symboli" // Undefined typeof undefined === "määrittämätön"; typeof deklardButUndefinedVariable === "määrittämätön"; typeof undeclaredVariable === "määrittämätön"; // Objektien tyyppi (a: 1) === "objekti"; // käytä Array.isArraya tai Object.prototype.toString.call // erottaaksesi tavalliset objektit ja taulukot, joiden tyyppi === "objekti"; typeof new Date() === "objekti"; // Seuraava johtaa virheisiin ja ongelmiin. Älä käytä! typeof new Boolen(true) === "objekti"; typeof new Number(1) === "objekti"; typeof new String("abc") === "objekti"; // Funktiot typeof function() () === "funktio"; luokan tyyppi C() === "funktio"; typeof Math.sin === "funktio";

tyhjä

// Tämä on määritetty JavaScript-tyypin null === "object" syntymästä lähtien;

JavaScriptin ensimmäisessä toteutuksessa arvot edustivat tunnistetyyppiä ja arvoparia. Objektien tunnistetyyppi oli 0. null esitettiin nollaosoittimena (0x00 useimmilla alustoilla). Siksi null-tunnisteen tyyppi oli null, joten typeof:n palautusarvo on dummy. ()

Korjausta ehdotettiin ECMAScriptissä (pois käytöstä), mutta se hylättiin. Tämä johtaisi typeof null === "null" .

Uuden operaattorin käyttö

// Kaikki "new":lla luodut konstruktorifunktiot ovat tyyppiä "object" var str = new String("String"); var num = uusi Numero(100); str-tyyppi; // Palauttaa "objektin" typeof num; // Palauttaa "objektin" // Mutta funktion rakentajalle on poikkeus var func = new Function(); toiminnan tyyppi; // Palauta "funktio"

Säännölliset lausekkeet

Kutsuttavat säännölliset lausekkeet olivat epätyypillinen lisäys joissakin selaimissa.

Typeof /s/ === "funktio"; // Chrome 1-12 Ei ole ECMAScript 5.1 -tyypin mukainen /s/ === "objekti"; // Firefox 5+ yhteensopiva ECMAScript 5.1:n kanssa

Virheet liittyvät väliaikaisiin kuolleisiin vyöhykkeisiin

Ennen ECMAScript 2015:tä operaattorin tyyppi taattiin palauttavan merkkijonon mille tahansa operandille, jolla sitä kutsuttiin. Tämä muuttui lisäämällä lohkokohtaiset non-hoisting let- ja const -ilmoitukset. Nyt, jos muuttujat on ilmoitettu parametreilla let ja const ja typeof kutsutaan niitä muuttujan ilmoituslohkossa, mutta ennen ilmoitusta, niin ReferenceError heitetään. Käyttäytyminen eroaa ilmoittamattomista muuttujista, joille typeof palauttaa "undefined". Lohkon laajuisilla muuttujilla on "väliaikainen kuollut alue", joka kestää lohkon alusta muuttujan ilmoittamiseen asti. Tällä vyöhykkeellä yritys käyttää muuttujia aiheuttaa poikkeuksen.

Typeof undeclaredVariable === "määrittämätön"; newLetVariable-tyyppi; anna newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "hei"; // ReferenceError

Poikkeukset

Kaikissa nykyisissä selaimissa on standardista poikkeava isäntäobjekti document.all, joka on tyyppiä Undefined.

Typeof document.all === "määrittämätön";

Vaikka spesifikaatio sallii mukautetut tyyppinimet epätyypillisille eksoottisille objekteille, se edellyttää, että nämä nimet ovat erilaisia kuin ennalta määritetyt nimet. Tilanne, jossa document.all on tyyppiä undefined, on katsottava poikkeukselliseksi sääntöjen rikkomiseksi.

Tekniset tiedot

Erittely	Tila	Kommentit
ECMAScriptin uusin luonnos (ECMA-262)	Luonnos
ECMAScript 2015 (6. painos, ECMA-262) "Käyttäjän tyypin" määritelmä on tässä spesifikaatiossa.	Vakio
ECMAScript 5.1 (ECMA-262) "Käyttäjän tyypin" määritelmä on tässä spesifikaatiossa.	Vakio
ECMAScript 3rd Edition (ECMA-262) "Käyttäjän tyypin" määritelmä on tässä spesifikaatiossa.	Vakio
ECMAScript 1st Edition (ECMA-262) "Käyttäjän tyypin" määritelmä on tässä spesifikaatiossa.	Vakio	Alkuperäinen määritelmä. Toteutettu JavaScript 1.1:ssä

Selaimen yhteensopivuus

Päivitä GitHubin yhteensopivuustiedot

	Tietokoneet						mobiili						Palvelin
	Kromi	Reuna	Firefox	Internet Explorer	Ooppera	Safari	Android-verkkonäkymä	Chrome Androidille	Firefox Androidille	Opera Androidille	Safari iOS:ssä	Samsung Internet	Node.js
tyyppi	Kromi Täysi tuki 1	Reuna Täysi tuki 12	Firefox Täysi tuki 1	I.E. Täysi tuki 3	Ooppera Täysi tuki Joo	Safari Täysi tuki Joo	WebView Android Täysi tuki 1	Chrome Android Täysi tuki 18	Firefox Android Täysi tuki 4	Opera Android Täysi tuki Joo	Safari iOS Täysi tuki Joo	Samsung Internet Android Täysi tuki 1.0	nodejs Täysi tuki Joo

Legenda

Täysi tuki Täysi tuki

IE-kohtaisia huomautuksia

IE 6:ssa, 7:ssä ja 8:ssa monet isäntäobjektit ovat objekteja, mutta eivät toimintoja. Esimerkiksi.

Määrittämätön: "määrittämätön"
Null: "objekti"
Boolean: "boolean"
Numero: "numero"
Merkkijono: "merkkijono"
Toiminto: "toiminto"
Kaikki muu: "objekti"

Tähän taulukkoon on lisättävä seuraavat huomautukset:

1. typeof null === "objekti" .

Teoriassa tässä on hienovarainen pointti. Staattisesti kirjoitetuissa kielissä objektityypin muuttuja ei saa sisältää objektia (NULL, nolla, nollaosoitin).

Käytännössä tämä on hankalaa JavaScriptissä. Joten ES 5.1 -kehittäjät aikovat tehdä jotain intuitiivisempaa: typeof null === "null" .

Mutta koska meillä on edelleen ES3 kaikkialla, älä erehdy esimerkiksi tämän kanssa:

/* Funktio etsii jotain objektia ja palauttaa sen tai nollan, jos mitään ei löydy */ function search() () var obj = search(); if (objektin tyyppi === "objekti") ( // Löysimmekö todella kohteen (FAIL) obj.method(); )

2. Älä unohda kääreobjekteja (uuden tyyppi(5) === "objekti").

3. Älä myöskään unohda selaimien oikeutta tehdä isäntäobjektien kanssa mitä tahansa.

Älä ihmettele, että Safari pitää HTMLCollectionia itsepäisesti funktiotyyppinä, ja versiota 9 vanhempi IE säilyttää suosikki alert()-funktiomme objektina. Myös Chrome piti RegExp:tä funktiona, mutta nyt se näyttää tajuavansa ja reagoivan siihen objektilla.

toString()

Arvon tyypin selvittäminen sen toString()-metodin tuloksesta on turhaa. Kaikissa "luokissa" tämä menetelmä on ohitettu.

Menetelmä on hyvä virheenkorjaustietojen näyttämiseen, mutta sitä ei voida käyttää muuttujan tyypin määrittämiseen.

Object.prototype.toString()

Vaikka toString ohitetaan tietyissä "luokissa", meillä on edelleen sen alkuperäinen toteutus Objectista. Yritetään käyttää sitä:

console.log(Object.prototype.toString.call(arvo));

Clinton lieventää tätä tylsyyttä

Kummallista kyllä, tämä menetelmä toimii yllättävän hyvin.

Skalaarityypeille palauttaa , , , .

Hassua on, että jopa uusi Numero(5), jonka tyyppi epäonnistui tässä, palauttaa .

Menetelmä epäonnistuu nollalla ja määrittelemättömällä. Eri selaimet palaavat, joskus odotettavissa ja joskus, joskus yleensä. Voit kuitenkin helposti määrittää näiden kahden arvon tyypin ilman tätä.

Asiat tulevat mielenkiintoisiksi, kun tulemme esineisiin (niihin, joiden tyyppi === "objekti").

sisäänrakennetut esineet toimivat käytännössä räjähdysmäisesti:

{} —
—
Päivämäärä -
Virhe -
Säännöllinen lauseke —

Ainoa asia on, että se putoaa argumenttiluettelosta, joka on joko .
Asiat pahenevat jälleen isäntäobjektien kanssa.

IE:ssä DOM-objekteista alkoi tulla "normaaleja" objekteja vasta versiosta 8 lähtien, eikä silloinkaan kokonaan. Siksi IE 6-8:ssa kaikki nämä objektit (HTMLCOllection, DOMElement, TextNode ja samalla asiakirja ja ikkuna) pelkistetään muotoon .

Kaikissa muissa selaimissa (mukaan lukien IE9) voit jo tehdä jotain toStringin tuloksella. Vaikka kaikki ei myöskään ole helppoa: HTMLCollection on siellä, niin . ikkuna - sitten, sitten, sitten. Mutta voit jo yrittää saada tästä jotain irti.

Se on monimutkaisempaa DOMElementin kanssa: se näytetään muodossa - jokaiselle tunnisteelle eri muoto. Mutta runkosarja auttaa meitä myös tässä.

Tarina on suunnilleen sama muiden isäntäobjektien kanssa (sijainti- ja navigaattoritesteissä). Kaikkialla paitsi IE:llä ne voidaan tunnistaa viivalla.

Object.prototype.toString(:n) käytön haitat:

1. Standardi ei kata tätä mahdollisuutta. Ja tässä meidän pitäisi mieluummin iloita siitä, että kaikki toimii niin hyvin, kuin valittaa joistakin puutteista.

2. Tyypin määrittäminen jäsentämällä merkkijonoa, joka on palautettu menetelmällä, jota ei käytetä tyypin määrittämiseen ollenkaan ja jota kutsutaan myös objektiin, johon se ei sovellu, jättää jonkin verran sedimenttiä sieluun.

3. Vanhassa IE:ssä, kuten näet, on normaalia olla tunnistamatta isäntäobjekteja.

Tämä on kuitenkin täysin toimiva asia, kun sitä käytetään yhdessä muiden keinojen kanssa.

Rakentajat

Ja lopuksi suunnittelijat. Kukapa sen paremmin sanoisi JS:n objektin "luokasta" kuin sen rakentaja?

null ja undefined eivät sisällä kääreobjekteja eikä rakentajia.

Muissa skalaarityypeissä on kääreet, joten voit hankkia myös konstruktorin:

(5).konstruktori === Numero; (Numero .NaN ) .constructor === Numero ; (true).constructor === Boolen; ("merkkijono" ) .constructor === Merkkijono ;

(5).konstruktori === Numero; (Numero.NaN).konstruktori === Numero; (true).constructor === Boolen; ("merkkijono").constructor === Merkkijono;

Mutta esimerkki ei toimi täällä:

5 esiintymän numero ; // false Number .NaN instanceof Number ; // false true instanceof Boolen ; // väärä "merkkijono" esiintymä merkkijono ; // väärä

5 esiintymän numero; // false Number.NaN instanceof Number; // väärä tosi esiintymä Boolen; // väärä "merkkijono"-instanssi String; // väärä

(instanceof toimii pitkään kärsineelle uudelle numerolle(5))

Toiminnoilla (jotka ovat myös objekteja) instanceof toimii:

console.log ( (funktio () ( ) ) Functionin esiintymä); // true console.log ( (funktio () ( ) ).constructor === Funktio ); // totta

console.log((funktio () ()) Function-instanssi); // true console.log((funktio () ()).constructor === Funktio); // totta

Myös rakentajat tunnistavat helposti kaikki sisäänrakennettujen luokkien objektit: Array, Date, RegExp, Error.

Yksi ongelma syntyy tässä argumenttien kanssa, joiden rakentaja on Object.

Ja toinen koskee itse Objectia, tai pikemminkin kuinka määrittää mukautetun konstruktorin avulla luotu objekti sille.

Tällä tavalla voit määrittää vain perusobjektin:

obj instanceof Object;

Yksi määrittelyvaihtoehdoista on käydä läpi kaikki muut mahdolliset tyypit (Array, Error...) ja jos mikään niistä ei sovi - "objekti".

Rakentajat ja isäntäobjektit

Asiat pahenevat isäntäobjektien kanssa.

Aloitetaan siitä, että IE versioon 7 asti ei pidä niitä ollenkaan normaaleina objekteina. Heillä ei yksinkertaisesti ole suunnittelijoita ja prototyyppejä (joka tapauksessa ohjelmoija ei voi tavoittaa heitä).

Muissa selaimissa asiat ovat paremmin. On olemassa konstruktoreita, ja voit käyttää niitä määrittämään arvon luokan. Niitä kutsutaan vain eri tavalla eri selaimissa. Esimerkiksi HTMLCollectionin rakentaja on joko HTMLCollection tai NodeList tai jopa NodeListConstructor.

Sinun tulisi myös määrittää DOMElementin peruskonstruktio. FF:ssä tämä on esimerkiksi HTMLElement , josta HTMLDivElement ja muut jo perivät.

Temppu heitetään FireFoxiin alle version 10 ja Operan alle 11. Kokoelman rakentaja siellä on Object .

rakentaja.nimi

Rakentajilla on myös nimiominaisuus, joka voi olla hyödyllinen.

Se sisältää rakentajafunktion nimen, esimerkiksi (5).constructor.name === "Numero" .

Kuitenkin:
1. Sitä ei ole IE:ssä ollenkaan, edes 9:ssä.
2. Selaimet taas luovat isäntäobjekteihin mitä haluavat (ja usein heillä ei ole tätä ominaisuutta ollenkaan). Operassa DOMElementin konstruktorinimi on yleensä Function.prototype .
3. argumentit jälleen "objekti".

johtopäätöksiä

Mikään esitetyistä menetelmistä ei tarjoa 100 %:n arvon tyypin/luokan määritystä kaikissa selaimissa. Yhdessä ne kuitenkin mahdollistavat tämän.

Lähitulevaisuudessa yritän koota kaikki tiedot taulukoihin ja antaa esimerkin määritelmäfunktiosta.

JavaScript tai JS(lyhennettynä) ei ole helppo kieli, eivätkä aloittelevat kehittäjät opi siitä heti. Aluksi he oppivat perusasiat ja kaikki näyttää värikkäältä ja kauniilta. Kun mennään hieman syvemmälle, näkyviin tulee JavaScript-taulukoita, objekteja, takaisinsoittoja ja kaikkea sellaista, mikä usein räjäyttää mielesi.

JavaScriptissä on tärkeää tarkistaa muuttujan tyyppi oikein. Oletetaan, että haluat tietää, onko muuttuja taulukko vai objekti? Kuinka tarkistaa tämä oikein? Tässä nimenomaisessa tapauksessa vahvistuksen aikana on temppuja, ja tämä viesti käsittelee niitä. Aloitetaan heti.

Muuttujan tyypin tarkistaminen

Sinun on esimerkiksi tarkistettava, onko muuttuja objekti, taulukko, merkkijono vai numero. Voit käyttää typeof-tyyppiä tähän, mutta se ei aina kerro totuutta ja alla olevassa esimerkissä näytän miksi.

Kirjoitin tämän esimerkin osoittaakseni selvästi, miksi tyyppi ei ole aina oikea valinta.

Var _comparison = ( merkkijono: "merkkijono", int: 99, float: 13.555, objekti: (hei: "hei"), array: new Array(1, 2, 3) ); // Palauttaa taulukon objektin avaimilla var _objKeys = Object.keys(_comparison); for(var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Koodin suorittamisen tulos:

Merkkijono numero numero objektiobjekti

Eikö? - Ei tietenkään. On kaksi ongelmaa. Jokainen niistä kuvataan yksityiskohtaisesti ja ehdotetaan ratkaisua.

Ensimmäinen ongelma: float number, tulosta numerona

Comparison.float ei ole numero, ja numeron tulee olla liukuluku (liukulukuluku) Voit korjata tämän luomalla funktion, jossa on sekoitus alla olevan koodin mukaisesti.

Var_floatNumber = 9,22; var _notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); funktio isFloat(n)( return Number(n) === n && n % 1 !== 0; )

IsFloat()-funktio tarkistaa, että kaikki arvot ovat liukulukuja. Ensin tarkistetaan, onko muuttuja yhtä suuri kuin n numero (Number(n) === n) ja jos kyllä, niin tehdään uusi tarkistus jakojäännöksellä ja jos jäännös on, niin boolen ( totta tai väärä) tulos (n % 1 !== 0).

Yllä olevassa esimerkissä se palaa totta, väärä Ja väärä. Ensimmäinen merkitys on kellua tyyppiä, toinen ei ole - se on tavallinen numero ja viimeinen on vain tyhjä merkkijono, joka ei sovi sääntöihin.

Toinen ongelma: taulukko määriteltiin objektiksi

Ensimmäisessä esimerkissä taulukko näytettiin objektina, ja tämä ei ole kovin hyvä, koska joskus sinun on käytettävä juuri tätä tyyppiä eikä mitään muuta.

On useita tapoja tarkistaa, onko muuttuja jonotyyppinen.

Ensimmäinen vaihtoehto (hyvä vaihtoehto). Tarkistamme, kuuluvatko tiedot taulukkoon, komennolla instanceof().

Var data = new Array("hei", "maailma"); var isArr = Array:n datainstanssi;

Toinen vaihtoehto (hyvä vaihtoehto). Array.isArray()-menetelmä palauttaa loogisen arvon, joka riippuu siitä, onko muuttuja jono vai ei ().

Var data = new Array("hei", "maailma"); var isArr = Array.isArray(data);

Kolmas vaihtoehto (paras, mutta pitkä). Mukavuuden vuoksi voit tehdä tästä menetelmästä toiminnon. Käytämme Objectia. Jos Object.prototype.toString.call(data) tulos ei ole yhtä suuri, muuttuja ei ole taulukko ().

Var data = new Array("hei", "maailma"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

Viimeinen tulos mukavuusfunktion muodossa:

Funktio isArray(data) ( palauttaa Object.prototype.toString.call(data) == "" )

Nyt voit kutsua isArray()-funktioita ja asettaa taulukon tai jotain muuta argumentiksi ja nähdä tuloksen.

Jälkisana

Nauhoitus osoittautui melko suureksi kuin alun perin oli tarkoitettu. Mutta olen tyytyväinen, koska se kuvaa varsin ytimekkäästi ja selkeästi vaikeudet JavaScriptin muuttujien tarkistamisessa ja niiden kiertämisen.

Jos sinulla on vielä kysyttävää, kirjoita ne tämän artikkelin alle. Autan mielelläni.

a = (b > 0) && (c + 1 != d); lippu = !(tila = 0);

Taulukko 14.5. Loogiset operaattorit

Käyttäjän kuvaus

! EI (looginen käännös)

&& JA (looginen kertolasku)

|| TAI (looginen lisäys)

Taulukko 14.6. AND- ja OR-operaattoreiden suorittamisen tulokset

Operandi 1	Operandi 2

Taulukko 14.7. NOT-operaattorin suorittamisen tulokset

get-operaattorin tyyppi

Kirjoita get-operaattori typeof palauttaa merkkijonon, joka kuvaa operandin tietotyyppiä. Operandi, jonka tyypin haluat tietää, sijoitetaan tämän operaattorin jälkeen ja suluissa:

s = typeof("str");

Tämän lausekkeen suorittamisen seurauksena muuttuja s sisältää merkkijonon "string", joka ilmaisee merkkijonotyypin.

Kaikki arvot, jotka operaattorityyppi voi palauttaa, on lueteltu taulukossa. 14.8.

	Taulukko 14.8. Operaattorin tyypin palauttamat arvot

Tietotyyppi		Paluumerkkijono

merkkijono

Numeerinen



		Taulukko 14.8 (loppu)

Tietotyyppi	Paluumerkkijono

Looginen

Tietotyyppien yhteensopivuus ja muuntaminen

On aika pohtia kahta muuta tärkeää asiaa: tietotyyppien yhteensopivuus ja muuntaminen tyypistä toiseen.

Mitä saat, kun lisäät kaksi numeerista arvoa? Aivan oikein - toinen numeerinen arvo. Mitä jos lisäät numeron ja merkkijonon? Vaikea sanoa... Tässä JavaScript kohtaa yhteensopimattomien tietotyyppien ongelman ja yrittää tehdä näistä tyypeistä yhteensopivia muuntamalla yhden niistä toiseksi. Se yrittää ensin muuntaa merkkijonon numeroksi ja jos onnistuu, suorittaa lisäyksen. Jos tämä ei onnistu, numero muunnetaan merkkijonoksi ja tuloksena olevat kaksi merkkijonoa ketjutetaan. Esimerkiksi Web-komentosarjan suorittaminen listauksessa 14.6 muuttaisi b:n arvon numeeriseksi, kun se lisätään a:han; siis muuttuja c sisältää arvon 23.

Listaus 14.6

var a, b, c, d, e, f; a = 11;

b = "12"; c = a + b;

d = "JavaScript"; e = 2;

Mutta koska muuttujan d arvoa ei voida muuntaa luvuksi, e:n arvo muunnetaan merkkijonoksi ja tulokseksi - f:n arvoksi - tulee yhtä suuri kuin

Boolen arvot muunnetaan joko numeerisiksi tai merkkijonoarvoiksi tapauksesta riippuen. Arvo tosi muunnetaan numeroksi 1 tai merkkijonoksi "1" ja arvo false muunnetaan arvoksi 0 tai "0" . Päinvastoin, luku 1 muunnetaan tosi ja luku 0 epätosi. Myös false muunnetaan muotoon

Meillä on arvot nolla ja määrittelemätön.

	Osa III. Web-sivujen käyttäytyminen. Web-skriptit

Voidaan nähdä, että JavaScript kamppailee suorittaakseen oikein jopa huonosti kirjoitettuja lausekkeita. Joskus tämä toimii, mutta useimmiten kaikki ei toimi suunnitellusti, ja lopulta Web-komentosarjan suorittaminen keskeytyy, koska virhe havaitaan täysin eri paikassa, täysin oikealla lauseella. Siksi on parempi välttää tällaisia tapauksia.

Operaattorin etusija

Viimeinen asia, jota tarkastelemme tässä, on operaattorin etusija. Kuten muistamme, ensisijaisuus vaikuttaa järjestykseen, jossa lausekkeen operaattorit suoritetaan.

Olkoon seuraava lauseke:

Tässä tapauksessa ensin c:n arvo lisätään muuttujan b arvoon ja sitten summasta vähennetään 10. Tämän lausekkeen operaattoreilla on sama prioriteetti ja siksi ne suoritetaan tiukasti vasemmalta oikealle.

Mieti nyt tätä ilmaisua:

Tässä arvo c kerrotaan ensin 10:llä ja vasta sitten arvo b lisätään tuloksena olevaan tuotteeseen. Kertolaskuoperaattorilla on korkeampi prioriteetti kuin summausoperaattorilla, joten "tiukasti vasemmalta oikealle" -järjestys rikotaan.

Tehtäväoperaattoreilla on alhaisin prioriteetti. Siksi lauseke itse arvioidaan ensin ja sitten sen tulos määrätään muuttujalle.

SISÄÄN Yleisesti kaikkien operaattoreiden suorittamisen perusperiaate on tämä: ensin suoritetaan operaattorit, joilla on korkeampi prioriteetti, ja vasta sitten operaattorit, joilla on pienempi. Operaattorit, joilla on sama prioriteetti, suoritetaan siinä järjestyksessä, jossa ne näkyvät (vasemmalta oikealle).

SISÄÄN pöytä Kohdassa 14.9 luetellaan kaikki tutkimamme operaattorit prioriteettien mukaan laskevassa järjestyksessä.

		Taulukko 14.9. Operaattorin etusija (laskevassa järjestyksessä)

	Operaattorit	Kuvaus

	++ -- - ~ ! tyyppi	Lisäys, vähennys, etumerkin muutos, looginen EI, tyypin määrittely

		Kerto-, jako-, jakojäännös

		Merkkijonojen yhteen- ja ketjuttaminen, vähennys


		Vertailuoperaattorit
		Vertailuoperaattorit


		Looginen JA

Luku 14. Johdatus Web-ohjelmointiin. JavaScript-kieli

		Taulukko 14.9 (loppu)

Operaattorit	Kuvaus

	Looginen TAI

	Ehdollinen lausunto (katso alla)

= <оператор>=	Tehtävä, yksinkertainen ja monimutkainen

HUOMIO!

Muista tämä taulukko. Lausuntojen virheellinen suoritus voi aiheuttaa vaikeasti havaittavia virheitä, joissa ilmeisen ehdottoman oikea lauseke tuottaa virheellisen tuloksen.

Mutta entä jos meidän on rikottava normaali lauseen suoritusjärjestys? Käytetään sulkeita. Näin kirjoitettuna suluissa olevat lauseet suoritetaan ensin:

a = (b + c) * 10;

Tässä ensin lisätään muuttujien b ja c arvot ja sitten saatu summa kerrotaan 10:llä.

Suluissa olevat operaattorit ovat myös etusijalla. Tästä syystä useita sisäkkäisiä sulkeita käytetään usein:

a = ((b + c) * 10 - d) / 2 + 9;

Tässä operaattorit suoritetaan seuraavassa järjestyksessä:

1. Lisätään b ja c.

2. Kerro saatu summa 10:llä.

3. d:n vähentäminen tulosta.

4. Jaa ero 2:lla.

5. Lisäämällä osamäärään 9.

Jos poistat sulut:

a = b + c*10 - d/2 + 9;

niin operaattoreiden suoritusjärjestys on seuraava:

1. Kerrotaan c ja 10.

2. Jaa d 2:lla.

3. B:n ja c:n ja 10:n tulo.

4. Jakolaskun osamäärä vähennetään saadusta summasta d 2.

5. Lisää 9 saatuun erotukseen.

Siitä tulee täysin erilainen tulos, eikö niin?