Dünaamiline tüübituvastus

Dünaamiline tüübituvastus (RTTI) võimaldab teil käitusajal määrata objekti tüübi. See osutub kasulikuks mitmel põhjusel. Eelkõige saate põhiklassile viidates üsna täpselt määrata selle viitega juurdepääsetava objekti tüübi. Dünaamiline tüübituvastus võimaldab ka eelnevalt kontrollida, kui edukas on tüübivalamise tulemus, vältides ebaõigest tüübivalamisest tulenevat erandit. Lisaks on dünaamiline tüübituvastus peegelduse põhikomponent.

Dünaamilise tüübituvastuse toetamiseks pakub C# kolme märksõnad a: is, as ja typeof. Kõiki neid märksõnu käsitletakse omakorda edasi.

on operaator

Objekti konkreetse tüübi saab määrata operaatori is abil. Allpool on selle üldine vorm:

väljend on tüüp

kus avaldis tähistab ühte avaldist, mis kirjeldab objekti, mille tüüpi testitakse. Kui avaldis on testitava tüübiga ühilduvat või sama tüüpi, on selle toimingu tulemus tõene, vastasel juhul on see väär. Seega on tulemus tõene, kui avaldis on ühel või teisel kujul testitavat tüüpi. Operaatoris is määratletakse mõlemad tüübid ühilduvatena, kui need on sama tüüpi või kui on ette nähtud viite teisendamine, kastimine või lahtipakkimine.

Järgmine on operaatori is kasutamise näide:

Süsteemi kasutamine; nimeruum ConsoleApplication1 ( klass Lisa ( ) klass Sum: Lisa ( ) klass Programm ( staatiline void Main() ( Add a = new Add(); Sum s = new Sum(); if (a on Add) Console.WriteLine("Muutuja a on tüüpi Add"); if (s on summa) Console.WriteLine("Muutuja s tüüp on päritud klassist Add"); Console.ReadLine(); ) ) )

operaatorina

Mõnikord tuleb tüübiteisendus teha tööajal, kuid mitte teha erandit, kui teisendamine ebaõnnestub, mis on tüübivalimise korral täiesti võimalik. Operaator as täidab seda eesmärki ja sellel on järgmine üldvorm:

väljendus tüübina

kus avaldis tähistab ühte avaldist, mis on teisendatav määratud tüübiks.

Kui sellise teisenduse tulemus on edukas, tagastatakse viide tüübile, vastasel juhul nullviide. Operaatorit as saab kasutada ainult viite teisendamiseks, identiteediks, kastimiseks, lahtipakkimiseks. Mõnel juhul võib as-operaator olla mugav alternatiiv is-operaatorile. Näiteks kaaluge järgmist programmi:

Süsteemi kasutamine; nimeruum ConsoleApplication1 ( klass Lisa ( ) klass Sum: Lisa ( ) klass Programm ( staatiline void Main() ( Add a = new Add(); Sum s = new Sum(); // Sooritage cast a = s nagu Add; if ( a != null) Console.WriteLine("Konversioon õnnestus"); else Console.WriteLine("Viga teisendamisel"); Console.ReadLine(); ) ) )

Selle programmi käivitamise tulemus on edukas teisendus.

JavaScript või JS(varsti) pole lihtne keel ja algajad arendajad ei õpi sellest kohe. Alguses õpitakse põhitõdesid ja kõik tundub värviline ja ilus. Natuke sügavamale minnes on JavaScripti massiivid, objektid, tagasihelistamised ja kõik muu, mis tihtipeale pähe ajab.

JavaScriptis on oluline muutuja tüüpi õigesti kontrollida. Oletame, et soovite teada, kas massiivi muutuja või objekt? Kuidas seda õigesti kontrollida? Sel konkreetsel juhul on kontrollimise ajal nippe ja sellest see postitus räägibki. Alustame kohe.

Muutuja tüübi kontrollimine

Näiteks peate kontrollima, kas muutuja on objekt, massiiv, string või arv. Selle jaoks saate kasutada typeof, kuid see ei ütle teile alati tõtt ja ma näitan teile, miks allolevas näites.

Kirjutasin selle näite, et illustreerida, miks tüüp ei ole alati õige valik.

Var _comparison = ( string: "string", int: 99, float: 13.555, objekt: (tere: "tere"), array: new Array(1, 2, 3) ); // Tagastab massiivi objekti võtmetega var _objKeys = Objekti võtmed(_võrdlus); for(var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Koodi täitmise tulemus:

String number objekti objekt

eks? - Muidugi mitte. Probleeme on kaks. Kõiki neist kirjeldatakse üksikasjalikult ja pakutakse välja lahendus.

Esimene probleem: ujukarv, väljund numbrina

Comparison.float ei ole arv ja see peab olema numbri asemel ujuk. Selle parandamiseks saate luua funktsiooni, millel on märk allolevas koodis.

Var_floatArv = 9,22; var_notFloatNumber = 9; konsool.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); funktsioon isFloat(n)( return Number(n) === n && n % 1 !== 0; )

Funktsioon isFloat() kontrollib kõiki ujukomaarvude väärtusi. Kõigepealt kontrollige, kas muutuja on võrdne n arv (Number(n) === n) ja kui jah, siis tehakse veel üks kontroll jäägiga jagamiseks ja kui jääk on, siis tagastatakse tõeväärtus ( tõsi või vale) tulemus (n % 1 !== 0).

Ülaltoodud näites naaseb see tõsi, vale ja vale. Esimene tähendus on ujuk tüüp, teine ​​ei ole - see on tavaline arv ja viimane on lihtsalt tühi string, mis ei vasta reeglitele.

Teine probleem: massiiv määratleti objektina

Kõige esimeses näites renderdatakse massiiv objektina, mis pole kuigi hea, sest vahel on vaja seda tüüpi kasutada ja mitte midagi muud.

Massiivitüübi muutuja testimiseks on mitu võimalust.

Esimene variant (hea variant). Kontrollige, kas andmed kuuluvad massiivi, kasutades instanceof().

Var data = new Array("tere", "maailm"); var isArr = massiivi andmeeksemplar;

Teine variant (hea variant). Meetod Array.isArray() tagastab tõeväärtuse, mis sõltub sellest, kas muutuja on massiiv või mitte ().

Var data = new Array("tere", "maailm"); var isArr = Massiiv.isArray(andmed);

Kolmas variant (parim, aga pikk). Mugavuse huvides saate selle meetodi funktsiooniks muuta. Kasutades objekti teeme . Kui objekti Object.prototype.toString.call(data) tulemus ei ole võrdne, ei ole muutuja massiiv ().

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

Viimane tulemus mugavusfunktsioonina:

Funktsioon isArray(data) (tagasi Object.prototype.toString.call(data) == "" )

Nüüd saate kutsuda funktsioone isArray() ja seada argumendiks massiivi või midagi ning tulemust näha.

Järelsõna

Plaat osutus päris mahukaks, kui algselt mõeldud oli. Kuid ma olen sellega rahul, sest see on piisavalt lühike ja selge, et kirjeldada JavaScripti muutujate valideerimise raskusi ja nendest möödahiilimist.

Kui teil on küsimusi, postitage need selle postituse alla. Aitan hea meelega.

a = (b > 0) && (c + 1 != d); lipp = !(olek = 0);

Tabel 14.5. Loogilised operaatorid

Operaatori kirjeldus

! EI (loogiline inversioon)

&& JA (tõve korrutis)

|| VÕI (loogiline lisamine)

Tabel 14.6. AND- ja OR-operaatorite käivitamise tulemused

Operand 1	Operand 2

Tabel 14.7. NOT-lause täitmise tulemused

hankige operaatori tüüp

Hangi tüübioperaator typeof tagastab stringi, mis kirjeldab operandi andmetüüpi. Operaand, mille tüüp tuleb leida, asetatakse selle operaatori järele ja sulgudes:

s = typeof("str");

Selle avaldise tulemusena sisaldab muutuja s stringi "string" , mis tähistab stringi tüüpi.

Kõik väärtused, mida operaatori tüüp saab tagastada, on loetletud tabelis 1. 14.8.

	Tabel 14.8. Väärtused, mille on tagastanud operaatori tüüp
Andmetüüp		Tagastusstring
String
Numbriline

			Tabel 14.8 (lõpp)
	Andmetüüp	Tagastusstring
	Loogiline

Ühilduvus ja andmetüübi teisendamine

On aeg mõelda veel kahele olulisele küsimusele: andmetüüpide ühilduvus ja ühelt tüübilt teisele teisendamine.

Mis juhtub, kui liidate kaks numbrit kokku? Täpselt nii – veel üks arvväärtus. Mis siis, kui lisate numbri ja stringi? Raske öelda... Siin puutub JavaScript kokku andmetüüpide ühildamatuse probleemiga ja proovib need tüübid ühilduvaks muuta, teisendades ühe neist teiseks. Esmalt proovib see stringi arvuks teisendada ja kui see õnnestub, siis lisab. Kui see ei õnnestu, teisendatakse arv stringiks ja kaks saadud stringi aheldatakse. Näiteks loendis 14-6 olev veebiskript teisendab muutujale a lisamisel muutuja b väärtuse numbriliseks tüübiks; seega sisaldab muutuja c väärtust 23.

Nimekiri 14.6

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

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

d="JavaScript"; e = 2;

Kuid kuna muutuja d väärtust ei saa arvuks teisendada, teisendatakse e väärtus stringiks ja tulemus - f väärtus - võrdub

Tõeväärtused teisendatakse vastavalt vajadusele kas numbrilisteks või stringiväärtusteks. Tõene teisendatakse arvuks 1 või stringiks "1" ja Väär väärtuseks 0 või "0" . Ja vastupidi, arv 1 teisendatakse tõeseks ja arv 0 vääraks. Samuti teisendatakse false

me oleme tühised ja määratlemata .

	III osa. Veebilehe käitumine. Veebiskriptid

On näha, et JavaScriptil on raskusi isegi valesti kirjutatud väljendite korrektse täitmisega. Mõnikord see toimib, kuid sagedamini ei lähe kõik plaanipäraselt ja lõpuks katkeb veebiskript, kuna skripti täiesti teises kohas, täiesti õigel väitel leitakse viga. Seetõttu on parem selliseid juhtumeid vältida.

Operaatori eelistus

Viimane probleem, mida siin käsitleme, on operaatori prioriteet. Nagu mäletame, mõjutab ülimuslikkus avaldise operaatorite täitmise järjekorda.

Olgu siin järgmine väljend:

Sel juhul liidetakse esmalt muutuja b väärtusele c väärtus ja seejärel lahutatakse summast 10. Selle avaldise operaatoritel on sama prioriteet ja seetõttu täidetakse neid rangelt vasakult paremale.

Nüüd kaaluge seda väljendit:

Siin korrutatakse kõigepealt väärtus c 10-ga ja alles siis lisatakse saadud korrutisele väärtus b. Korrutustehter on kõrgem kui liitmistehter, seega rikutakse järjekorda "rangelt vasakult paremale".

Määramise operaatoritel on madalaim prioriteet. Seetõttu hinnatakse kõigepealt avaldist ennast ja seejärel määratakse selle tulemus muutujale.

V Üldiselt on kõigi lausete täitmise põhiprintsiip järgmine: esiteks laused, millel on rohkem kui kõrge prioriteet, ja alles siis - operaatorid madalamaga. Sama tähtsusega operaatorid täidetakse nende ilmumise järjekorras (vasakult paremale).

V sakk. 14.9 loetleb kõik meie uuritud operaatorid nende tähtsuse kahanevas järjekorras.

		Tabel 14.9. Operaatori prioriteetsus (kahanevas järjekorras)
	Operaatorid	Kirjeldus
	++ -- - ~ ! tüüp	Suurendamine, vähendamine, märgi muutmine, loogiline EI, tüübi järeldus
		Korrutamine, jagamine, jääk
		Stringide liitmine ja ühendamine, lahutamine
		Võrdlusoperaatorid
		loogiline JA

	Peatükk 14. Sissejuhatus veebiprogrammeerimisse. JavaScripti keel
			Tabel 14.9 (lõpp)
	Operaatorid	Kirjeldus
		Loogiline VÕI
		Tingimuslik operaator (vt allpool)
	= <оператор>=	Ülesanne, lihtne ja keeruline

TÄHELEPANU!

Pidage meeles seda tabelit. Lausete vale täitmise järjekord võib põhjustada raskesti tuvastatavaid vigu, mille puhul näiliselt absoluutselt õige avaldis annab vale tulemuse.

Aga mis siis, kui meil on vaja rikkuda avalduste tavalist täitmise järjekorda? Kasutame sulgusid. Selles tähistuses täidetakse kõigepealt sulgudes olevad avaldused:

a = (b + c) * 10;

Siin liidetakse kõigepealt muutujate b ja c väärtused ning seejärel korrutatakse saadud summa 10-ga.

Sulgudes olevad operaatorid on samuti ülimuslikud. Seetõttu kasutatakse sageli mitut pesastatud sulgu:

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

Siin täidetakse avaldused järgmises järjekorras:

1. Lisage b ja c.

2. Korrutage saadud summa 10-ga.

3. Korrutisest d lahutamine.

4. Jagage vahe 2-ga.

5. Jagatisele 9 liitmine.

Kui eemaldate sulgud:

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

siis on operaatorite täitmise järjekord järgmine:

1. Korrutage c ja 10.

2. Jagage d 2-ga.

3. B liitmine ning c ja 10 korrutamine.

4. Jagamise jagatise saadud summast lahutamine d kuni 2.

5. Lisades saadud erinevusele 9.

Selgub, et tulemus on täiesti erinev, eks?

• määramata: "määratlemata"
• Null: "objekt"
• Boolean: "tõve"
• Number: "number"
• String: "string"
• Funktsioon: "funktsioon"
• Kõik muu: "objekt"

Sellesse tabelisse tuleks lisada järgmised märkused:

1. typeof null === "objekt" .

Teoreetiliselt on siin peen point. Staatiliselt trükitud keeltes ei tohi objektitüübi muutuja objekti sisaldada (NULL, nil, null pointer).

Praktiliselt – JavaScriptis on see ebamugav. Nii et ES 5.1 arendajad teevad midagi intuitiivsemat: typeof null === "null" .

Kuid kuna oleme endiselt ES3 ümber, ärge tehke viga näiteks selles:

/* Funktsioon otsib mingit objekti ja tagastab selle või nulli, kui midagi ei leitud */ funktsioon otsing() () var obj = otsing(); if (objekti tüüp === "objekt") ( // kas me tõesti leidsime objekti (FAIL) obj.method(); )

2. Ärge unustage ümbrisobjekte (typeof new Number(5) === "objekt").

3. Ja ärge unustage brauserite õigust host-objektidega midagi ette võtta.

Ärge imestage, et Safari käsitleb kangekaelselt HTMLCollectionit funktsioonitüübina ja 9. eelne IE säilitab meie lemmikfunktsiooni Alert() objektina . Samuti pidas Chrome varem RegExpi funktsiooniks, kuid nüüd tundub, et see tuleb mõistusele ja vastab sellele objektiga.

toString()

Püüdes selle meetodi toString() tulemusest väärtuse tüüpi välja selgitada on mõttetu. Kõikides "klassides" määratletakse see meetod uuesti omaks.

Meetod on hea silumisinfo kuvamiseks, kuid muutuja tüüpi ei saa selle järgi määrata.

Object.prototype.toString()

Kuigi konkreetsetes "klassides" on toString üle kirjutatud, on meil siiski selle esialgne rakendus Objectist. Proovime seda kasutada:

console.log ( Object .prototype .toString .call (väärtus) ) ;

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

Clinton lahjendab seda koormat

Kummalisel kombel töötab see meetod üllatavalt hästi.

Sest skalaarsed tüübid tagastab , , , .

Naljakas on see, et isegi uus Number(5), mille tüüp siin ebaõnnestus, tagastab .

Nulli ja määramata korral meetod ebaõnnestub. Erinevad brauserid tagastavad kas oodatud ja , või või isegi . Kuid ilma selleta on nende kahe väärtuse tüüpi lihtne kindlaks teha.

Huvitavad asjad saavad alguse siis, kui jõuame objektideni (need, mille tüüp on === "objekt").

sisseehitatud objektid töötavad praktiliselt pauguga:

• {} —
• —
• kuupäev-
• viga-
• regexp-

Ainus asi, mis argumentide loendist välja langeb, on kas , või .
Host-objektide puhul on kõik jälle hullem.

IE-s hakkasid DOM-objektid "tavalisteks" objektideks saama alles 8. versioonist ja siis mitte päris lõpuni. Seetõttu kantakse IE 6-8 puhul kõik need objektid (HTMLCOllection, DOMElement, TextNode, aga ka dokument ja aken) lihtsalt üle .

Kõigis teistes brauserites (sh IE9) saab toString tulemusega juba midagi ette võtta. Kuigi kõik pole samuti lihtne: HTMLCollection seal , siis . aken - siis , siis , siis . Kuid võite juba proovida sellest midagi saada.

DOMElementiga on see keerulisem: see kuvatakse iga sildi jaoks erineva vorminguna. Aga siin aitab meid tavahooaeg.

Teiste hostobjektidega (asukoha ja navigaatori testides) on lugu umbes sama. Kõikjal, välja arvatud IE, saab neid identifitseerida stringi järgi.

Object.prototype.toString() kasutamise miinustest:

1. See võimalus ei ole standardiga pühitsetud. Ja me peaksime siin pigem rõõmustama, et kõik nii hästi toimib, mitte hädaldama mõne vea pärast.

2. Tüübi määramine stringi parsimise teel, mis on tagastatud meetodi abil, mis ei ole sugugi tüübi määramiseks, ja kutsutakse isegi objektile, mille kohta see ei kehti, jätab hinge veidi setteid.

3. Nagu näete, ei tuvastata vanas IE-s tavaliselt hostobjekte.

Siiski on see üsna töötav asi, kui seda kasutada koos teiste tööriistadega.

Konstruktorid

Ja lõpuks konstruktorid. Kes oskaks JS-is objekti "klassi" kohta paremini öelda kui selle konstruktor?

nullil ja undefinedil pole ümbrisobjekte ega konstruktoreid.

Ülejäänud skalaaritüüpidel on ümbrised, nii et saate konstruktori:

(5) .konstruktor === Arv ; (Arv .NaN ) .konstruktor === Arv ; (tõene ) .constructor === Boolean ; ("string") .constructor === String ;

(5).konstruktor === Arv; (Arv.NaN).konstruktor === Arv; (tõene).konstruktor === Boolean; ("string").konstruktor === String;

Kuid näide siin ei tööta:

5 instanceofNumber ; // false Number .NaN instanceof Number ; // Boole'i ​​vale tõene eksemplar ; // String vale "string" eksemplar ; // vale

5 instanceofNumber; // vale Number.NaN instanceof Number; // Boole'i ​​vale tõene eksemplar; // vale "string" eksemplar String; // vale

(näiteks töötab kauakannatanud uue numbri jaoks(5))

Funktsioonidega (mis on ka objektid) teeb instanceof järgmist:

konsool. logi ( (funktsioon () ( ) ) Funktsiooni eksemplar ) ; // tõene konsool. logi ( (funktsioon () ( ) ) .konstruktor === Funktsioon ); // tõsi

console.log((funktsioon () ()) Funktsiooni eksemplar); // tõene konsool.log((funktsioon () ()).konstruktor === Funktsioon); // tõsi

Kõik sisseehitatud klasside objektid on hõlpsasti tuvastatavad ka konstruktorite poolt: Array , Date , RegExp , Error .

Üks probleem tekib siin argumentidega, mille konstruktoriks on objekt.

Ja teine ​​objekti endaga või õigemini, kuidas viidata sellele kohandatud konstruktori kaudu loodud objektile.

Ainult põhiobjekti saab määratleda järgmiselt:

obj instanceofObject;

Ühe määratlusvalikuna itereerige üle kõik muud võimalikud tüübid (Array , Error ...) ja kui ükski neist ei kuulu - "objekt".

Konstruktorid ja hostobjektid

Hostobjektidega läheb asi hullemaks.

Alustame sellest, et IE kuni 7. versioonini (kaasa arvatud) ei pea neid üldse normaalseteks objektideks. Neil lihtsalt ei ole seal konstruktoreid ja prototüüpe (igatahes ei saa programmeerija neile ligi).

Teistes brauserites on asjad paremini. Konstruktorid on olemas ja nende järgi saab määrata väärtusklassi. Ainult neid nimetatakse erinevates brauserites erinevalt. Näiteks HTMLCollectioni puhul on konstruktor kas HTMLCollection või NodeList või isegi NodeListConstructor .

Samuti peaksite määratlema DOMElementi baaskonstruktori. FF-is on selleks näiteks HTMLElement , millest HTMLDivElement ja teised juba pärivad.

Triki viskab FireFox alla versiooni 10 ja Opera alla versiooni 11. Seal on kogu konstrueerijaks Object .

konstruktor.nimi

Konstruktoril on ka nimiomadus, mis võib olla kasulik.

See sisaldab konstruktorifunktsiooni nime, näiteks (5).constructor.name === "Arv" .

Aga:
1. IE-s pole seda üldse, isegi 9.-s.
2. Host-objektides vormivad brauserid jälle kõike, mis on palju (ja sageli pole neil seda omadust üldse). Operas on DOMElementil konstruktori nimi Function.prototype .
3. argumendid jälle "objekt".

järeldused

Ükski esitatud meetoditest ei anna kõigis brauserites väärtuse tüübi / klassi 100% määratlust. Kuid koos võimaldavad need teil seda teha.

Lähiajal püüan kõik andmed tabelitesse koguda ja tuua näite defineeriva funktsiooni kohta.

Operaator tüüp tagastab stringi, mis näitab operandi tüüpi.

Süntaks

Operand järgib operaatori tüüpi:

tüüp operand

Parameetrid

operand on avaldis, mis esindab objekti või primitiivi, mille tüüp tagastatakse.

Kirjeldus

Järgmises tabelis on loetletud tüübi võimalikud tagastusväärtused. Lisainformatsioon tüüpide ja primitiivide kohta on lehel.

Näited

// Numbers typeof 37 === "number"; typeof 3.14 === "arv"; typeof(42) === "arv"; typeof Math.LN2 === "arv"; typeof Infinity === "arv"; tüüp NaN === "arv"; // kuigi see on "Not-A-Number" tüüpi Number(1) === "number"; // ära kasuta seda tähistust! // Stringi tüüp "" === "string"; "bla" tüüp === "string"; tüüp "1" === "string"; // pane tähele, et stringi sees olev arv on endiselt tüüpi string typeof (typeof 1) === "string"; // typeof tagastab sel juhul alati stringi typeof String("abc") === "string"; // ära kasuta seda tähistust! // Booleans typeof true === "tõve"; typeof false === "tõve"; Boolean(tõene) === "tõeväärtus"; // ära kasuta seda tähistust! // Symbols typeof Symbol() === "symbol" typeof Symbol("foo") === "symbol" typeof Symbol.iterator === "symbol" // Undefined typeof undefined === "määratlemata"; typeof deklareeritudButUndefinedVariable === "määratlemata"; typeof undeclaredVariable === "määratlemata"; // Objektide tüüpof(a: 1) === "objekt"; // kasutage Array.isArray või Object.prototype.toString.call // tavaobjektide ja massiivide eristamiseks === "objekt"; typeof new Date() === "objekt"; // Kõik allpool olevad asjad põhjustavad vigu ja probleeme. Ära kasuta! typeof new Boolean(true) === "objekt"; typeof new Number(1) === "objekt"; typeof new String("abc") === "objekt"; // Funktsioonid typeof function() () === "funktsioon"; klassi tüüp C() === "funktsioon"; typeof Math.sin === "funktsioon";

null

// Seda on defineeritud alates JavaScripti typeof null === "object" sünnist;

JavaScripti esimeses juurutamises tähistati väärtusi sildi tüübi ja väärtuste paariga. Objektide sildi tüüp oli 0. null esitati null-osutajana (enamikul platvormidel 0x00). Seetõttu oli null sildi tüüp null, seega on typeof tagastusväärtus võlts. ()

ECMAScriptis on pakutud parandus (keelamise kaudu), kuid see lükati tagasi. Selle tulemuseks oleks typeof null === "null" .

Uue operaatori kasutamine

// Kõik "new"-ga loodud konstruktorifunktsioonid on tüüpi "object" var str = new String("String"); var num = new Number(100); typeofstr; // Tagastab "objekti" typeof num; // Tagastab "objekti" // Funktsiooni konstruktori puhul on aga erand var func = new Function(); funktsiooni tüüp; // Tagastab "funktsiooni"

Regulaaravaldised

Nimetatud regulaaravaldised olid mõnes brauseris ebastandardsed lisad.

Tüüp /s/ === "funktsioon"; // Chrome 1-12 Ei ühildu ECMAScript 5.1-ga /s/ === "objekt"; // Firefox 5+ Ühildub ECMAScript 5.1-ga

Ajutiste surnud tsoonidega seotud vead

Enne ECMAScript 2015 tagati, et operaatori tüüp tagastab stringi mis tahes operandi jaoks, millega seda kutsuti. See muutus, kui lisandusid mittetõstevad ploki ulatusega let ja const deklaratsioonid. Nüüd, kui muutujad on deklareeritud parameetritega let ja const ning typeof kutsutakse neile muutuja deklaratsiooniplokis, kuid enne deklaratsiooni, siis visatakse välja ReferenceError. Käitumine erineb deklareerimata muutujatest, mille tüüp tagastab "määratlemata". Ploki ulatusega muutujad on "ajutises surnud tsoonis", mis kestab ploki algusest kuni muutujate deklareerimise hetkeni. Selles tsoonis loob muutujatele juurdepääsu katse erandi.

Typeof undeclaredVariable === "määratlemata"; typeof newLetVariable; let newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "tere"; // ReferenceError

Erandid

Kõigis praegustes brauserites on mittestandardne document.all hostobjekt, mille tüüp on Undefined.

Dokumendi tüüp.all === "määratlemata";

Kuigi spetsifikatsioon lubab mittestandardsete eksootiliste objektide jaoks kohandatud tüübinimesid, peavad need nimed eeldefineeritud nimedest erinema. Olukorda, kus document.all on tüüpi undefined, tuleks lugeda erandlikuks reeglite rikkumiseks.

Tehnilised andmed

Spetsifikatsioon	Olek	Kommentaarid
ECMAScripti uusim mustand (ECMA-262)	Mustand
ECMAScript 2015 (6. väljaanne, ECMA-262) "Operaatori tüübi" määratlus selles spetsifikatsioonis.	Standard
ECMAScript 5.1 (ECMA-262) "Operaatori tüübi" määratlus selles spetsifikatsioonis.	Standard
ECMAScript 3rd Edition (ECMA-262) "Operaatori tüübi" määratlus selles spetsifikatsioonis.	Standard
ECMAScript 1. väljaanne (ECMA-262) "Operaatori tüübi" määratlus selles spetsifikatsioonis.	Standard	Esialgne määratlus. Rakendatud JavaScriptis 1.1

Brauseri ühilduvus

Värskendage GitHubi ühilduvusandmeid

	Arvutid						Mobiilne						server
	Chrome	serv	Firefox	Internet Explorer	Ooper	safari	android veebivaade	Chrome Androidile	Firefox Androidile	Opera Androidile	Safari iOS-is	Samsungi Internet	Node.js
tüüp	Chrome Täielik tugi 1	serv Täielik tugi 12	Firefox Täielik tugi 1	IE Täielik tugi 3	Ooper Täielik tugi Jah	safari Täielik tugi Jah	veebivaade android Täielik tugi 1	Chrome Android Täielik tugi 18	Firefox Android Täielik tugi 4	OperaAndroid Täielik tugi Jah	Safari iOS Täielik tugi Jah	Samsung Internet Android Täielik tugi 1.0	nodejs Täielik tugi Jah

Legend

Täielik tugi Täielik tugi

IE-spetsiifilised märkused

IE 6, 7 ja 8 puhul on paljud hostobjektid objektid, mitte funktsioonid. Näiteks.