Dynamická identifikácia typu

Dynamická identifikácia typu (RTTI) umožňuje určiť typ objektu za behu. Ukazuje sa, že je to užitočné z rôznych dôvodov. Najmä pomocou odkazu na základnú triedu môžete pomerne presne určiť typ objektu, ktorý je k dispozícii z tohto odkazu. Dynamická identifikácia typu vám tiež umožňuje vopred skontrolovať, aký úspešný bude typový prenos, čím sa zabráni neplatnej výnimke typového prenosu. Dynamická identifikácia typu je navyše hlavnou súčasťou odrazu.

Na podporu identifikácie dynamického typu poskytuje C # tri kľúčové slová: is, as a typeof. Každé z týchto kľúčových slov je postupne popísané nižšie.

Je operátor

Konkrétny typ objektu je možné určiť pomocou operátora is. Jeho všeobecná forma je uvedená nižšie:

výraz je typ

kde výraz označuje samostatný výraz opisujúci objekt, ktorého typ sa kontroluje. Ak je výraz kompatibilného typu alebo rovnakého typu ako testovaný typ, potom je výsledok tejto operácie pravdivý, v opačnom prípade je nepravdivý. Výsledok je teda pravdivý, ak má výraz testovateľný typ v tej či onej forme. Operátor is definuje oba typy ako kompatibilné, ak sú rovnakého typu alebo ak je k dispozícii referenčná konverzia, škatuľkovanie alebo rozbalenie.

Nasleduje príklad použitia operátora is:

Použitie systému; priestor názvov ConsoleApplication1 (trieda Add () trieda Sum: Add () trieda Program (statická prázdnota Main () (Add a = new Add (); Sum s = new Sum (); if (a is Add) Console.WriteLine ("Variable a je typu Add "); ak (s je Sum) Console.WriteLine (" Typ s je zdedený z triedy Add "); Console.ReadLine ();)))

Ako operátor

Konverziu typu je niekedy potrebné vykonať za behu, ale nesmie spôsobiť výnimku, ak konverzia zlyhá, čo je pri castingu typov celkom možné. Na tento účel sa používa operátor as, ktorý má nasledujúcu všeobecnú formu:

výraz ako typ

kde výraz označuje jeden výraz, ktorý sa má previesť na určený typ.

Ak je táto konverzia úspešná, vráti sa odkaz na typ; v opačnom prípade prázdny odkaz. Operátor as môže byť použitý iba na referenčnú konverziu, identitu, škatuľkovanie a rozbalenie. V niektorých prípadoch môže operátor as slúžiť ako výhodná alternatíva k operátorovi is. Uvažujme napríklad o nasledujúcom programe:

Použitie systému; priestor názvov ConsoleApplication1 (trieda Add () trieda Sum: Add () trieda Program (statická prázdnota Main () (Add a = new Add (); Sum s = new Sum (); // Vykonajte casting a = s ako Add; if ( a! = null) Console.WriteLine („Konverzia bola úspešná“); inak Console.WriteLine („Konverzia zlyhala“); Console.ReadLine ();)))

Výsledkom tohto programu bude úspešná konverzia.

JavaScript alebo Js(skrátene) nie je ľahký jazyk a začínajúci vývojári sa o ňom hneď nedozvedia. Najprv sa naučia základy a všetko sa zdá byť farebné a krásne. Keď ideme trochu hlbšie, objavia sa polia JavaScriptu, objekty, spätné volania a podobne, ktoré mozog často vyberie.

V JavaScripte je dôležité správne skontrolovať typ premennej. Povedzme, že chcete vedieť, či je premenná pole alebo objekt? Ako to správne skontrolovať? V tomto konkrétnom prípade existujú triky počas kontroly a o tom bude tento záznam. Začnime hneď.

Kontrola typu premennej

Napríklad musíte skontrolovať, či je premennou objekt, pole, reťazec alebo číslo. Na to môžete použiť typeof, ale nie vždy to dá pravdu a v nasledujúcom príklade ukážem prečo.

Tento príklad som napísal, aby som ilustroval, prečo nie je typeof vždy tou správnou voľbou.

Var _comparison = (string: "string", int: 99, float: 13.555, object: (hello: "hello"), pole: new Array (1, 2, 3)); // Vráti pole s kľúčmi objektu var _objKeys = Object.keys (_comparison); pre (var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Výsledok spustenia kódu:

Objekt objektu číslo reťazca číslo

Správny? - Samozrejme, že nie. Existujú dva problémy. Každý z nich bude podrobne popísaný a navrhne sa riešenie.

Prvý problém: float number, výstup ako číslo

Comparison.float nie je číslo a namiesto čísla by mal byť float. Ak to chcete vyriešiť, môžete vytvoriť funkciu s overením ako v nižšie uvedenom kóde.

Var _floatNumber = 9,22; var _notFloatNumber = 9; console.log (isFloat (_floatNumber)); console.log (isFloat (_notFloatNumber)); console.log (isFloat ("")); funkcia isFloat (n) (návratové číslo (n) === n && n% 1! == 0;)

Funkcia isFloat () kontroluje všetky hodnoty pre čísla s pohyblivou rádovou čiarkou. Najprv skontroluje, či je premenná rovná nčíslo (Číslo (n) === n) a ak je to tak, vykoná sa ďalšia kontrola na delenie na zvyšok a ak existuje zvyšok, potom na booleovský ( pravda alebo falošný) výsledok (n% 1! == 0).

V príklade vyššie sa vráti pravda, falošný a falošný... Prvý význam je plavák typ, druhý nie je - toto je obyčajné číslo a posledný je len prázdny reťazec, ktorý nevyhovuje pravidlám.

Druhý problém: pole bolo definované ako objekt

V úplne prvom prípade bolo pole zobrazené ako objekt a to nie je príliš dobré, pretože niekedy musíte použiť tento konkrétny typ a nič iné.

Existuje niekoľko spôsobov, ako testovať premennú pre typ poľa.

Prvá možnosť (dobrá možnosť). Pomocou inštancie () skontrolujeme, či údaje patria do poľa.

Údaje Var = nové pole („ahoj“, „svet“); var isArr = dátová inštancia poľa;

Druhá možnosť (dobrá možnosť). Metóda Array.isArray () vracia logickú hodnotu, ktorá bude závisieť od toho, či je premenná pole alebo nie ().

Údaje Var = nové pole („ahoj“, „svet“); var isArr = Array.isArray (údaje);

Tretia možnosť (najlepšia, ale najdlhšia). Z dôvodu pohodlia z toho môžete urobiť funkciu. Používame Object. Ak výsledok Object.prototype.toString.call (údaje) nie je rovnaký, premenná nie je pole ().

Údaje Var = nové pole („ahoj“, „svet“); var isArr = Object.prototype.toString.call (údaje) == ""; console.log (isArr);

Posledný výsledok ako praktická funkcia:

Funkcia isArray (údaje) (návrat Object.prototype.toString.call (data) == "")

Teraz môžete zavolať funkciu isArray () a ako argument nastaviť pole alebo niečo iné a uvidíte výsledok.

Doslov

Záznam sa ukázal byť dosť veľký, ako sa pôvodne predpokladalo. Som s ním však spokojný, pretože stručne a zrozumiteľne popisuje ťažkosti pri kontrole premenných v JavaScripte a spôsob, ako ich obísť.

Ak máte ďalšie otázky, napíšte ich nižšie k tomuto záznamu. Rád pomôžem.

a = (b> 0) && (c + 1! = d); vlajka =! (stav = 0);

Tabuľka 14.5. Logickí operátori

Popis operátora

! NIE (logická inverzia)

&& AND (logické násobenie)

|| ALEBO (logické sčítanie)

Tabuľka 14.6. Výsledky spustenia operátorov AND a OR

Operand 1	Operand 2

Tabuľka 14.7. Výsledky vyhlásenia NOT

Získajte typ operátora

Získajte operátor typu typeof vráti reťazec popisujúci dátový typ operandu. Operand, ktorého typ chcete vedieť, je umiestnený za týmto operátorom a je uzavretý v zátvorkách:

s = typeof ("str");

V dôsledku tohto výrazu bude premenná s obsahovať reťazec „string“ označujúci typ reťazca.

Všetky hodnoty, ktoré môže operátor typeof vrátiť, sú uvedené v tabuľke. 14.8.

	Tabuľka 14.8. Hodnoty vrátené operátorom typeof
Dátový typ		Vrátený reťazec
Reťazec
Numerické

			Tabuľka 14.8 (koniec)
	Dátový typ	Vrátený reťazec
	Logické

Kompatibilita a konverzia dátových typov

Teraz je načase zvážiť dve ďalšie dôležité otázky: kompatibilitu dátového typu a prevod z jedného typu na druhý.

Čo sa stane, keď spojíte dve čísla? Správne - ešte jedna číselná hodnota. A ak pridáte číslo a reťazec? Je ťažké povedať ... Tu je JavaScript konfrontovaný s problémom nekompatibility dátových typov a pokúša sa ich zosúladiť tak, že jeden z nich prevedie na iný. Najprv sa pokúsi previesť reťazec na číslo a v prípade úspechu vykoná sčítanie. V prípade neúspechu sa číslo prevedie na reťazec a dva výsledné reťazce sa spoja. Napríklad spustením webového skriptu v zozname 14.6 sa pri pridaní do a prevádza hodnota b na číselný typ; premenná c bude teda obsahovať hodnotu 23.

Výpis 14.6

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

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

d = "JavaScript"; e = 2;

Pretože však hodnotu d nemožno previesť na číslo, hodnota e sa prevedie na reťazec a výsledok - hodnota f - sa stane

Booleovské hodnoty sa podľa potreby prevedú na číselné alebo reťazcové hodnoty. True bude prevedené na číslo 1 alebo reťazec „1“ a nepravdivé bude prevedené na 0 alebo „0“. Naopak, číslo 1 bude konvertované na true a číslo 0 bude prevedené na false. Tiež sa prevedie hodnota false

hodnoty sú null a nedefinované.

	Časť III. Správanie webových stránok. Webové skripty

Je vidieť, že JavaScript má problémy so správnym vykonaním aj nesprávne napísaných výrazov. Niekedy to funguje, ale častejšie všetko nefunguje podľa plánu a nakoniec sa spustenie webového skriptu preruší z dôvodu zistenia chyby na úplne inom mieste, na úplne správnom operátorovi. Preto je lepšie takéto incidenty nepripúšťať.

Priorita operátora

Posledným problémom, na ktorý sa tu pozrieme, je prednosť operátora. Ako si pamätáme, prednosť ovplyvňuje poradie, v ktorom sa výrazy vykonávajú.

Nech je nasledujúci výraz:

V tomto prípade sa najskôr k hodnote premennej b pripočíta hodnota c a potom sa zo súčtu odčíta 10. Operátory tohto výrazu majú rovnakú prioritu, a preto sa vykonávajú striktne zľava doprava.

Teraz zvážte nasledujúci výraz:

Tu sa najskôr hodnota c vynásobí 10 a až potom sa k výslednému produktu pripočíta hodnota b. Operátor násobenia má prednosť pred operátorom sčítania, takže prísne objednávanie zľava doprava bude mimo prevádzky.

Najnižšiu prioritu majú operátori priradenia. Preto je najskôr vyhodnotený samotný výraz a potom je jeho výsledok priradený k premennej.

V Všeobecne platí, že základný princíp vykonávania všetkých operátorov je nasledujúci: najskôr sa vykonajú operátori s vyššou prioritou a až potom operátori s nižšou prioritou. Operátory s rovnakou prioritou sa vykonávajú v poradí, v akom sa zobrazujú (zľava doprava).

V tab. 14.9 uvádza všetkých operátorov, ktorých sme skúmali, zostupne podľa ich priority.

		Tabuľka 14.9. Prednosť operátora (zostupne)
	Operátori	Popis
	++ - - ~! Typ	Prírastok, úbytok, zmena znamienka, logické NIE, odvodenie typu
		Násobenie, delenie, pričom zvyšok
		Sčítanie a spájanie reťazcov, odčítanie
		Operátori porovnávania
		Logické AND

	Kapitola 14. Úvod do webového programovania. Jazyk JavaScript
			Tabuľka 14.9 (koniec)
	Operátori	Popis
		Logické ALEBO
		Podmienený operátor (pozri nižšie)
	= <оператор>=	Zadanie, jednoduché a zložité

POZOR!

Pamätajte si túto tabuľku. Nesprávny príkaz na vykonanie príkazu môže viesť k ťažko rozpoznateľným chybám, v ktorých zdanlivo absolútne správny výraz dáva nesprávny výsledok.

Ale čo keď potrebujeme prelomiť bežný poriadok vykonávania príkazov? Použime zátvorky. S týmto zápisom sa najskôr vykonajú vyhlásenia uzavreté v zátvorkách:

a = (b + c) * 10;

Tu sa najskôr vykoná sčítanie hodnôt premenných b a c a potom sa výsledný súčet vynásobí 10.

Prednosť majú aj operátori uvedení v zátvorkách. Preto sa často používa viacero vnorených zátvoriek:

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

Tu sa príkazy vykonajú v nasledujúcom poradí:

1. Dodatok b a c.

2. Výslednú sumu vynásobte 10.

3. Odčítanie d z produktu.

4. Rozdelenie rozdielu na 2.

5. Pridajte 9 do kvocientu.

Ak odstránite zátvorky:

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

potom bude poradie vykonávania operátorov nasledovné:

1. Násobenie c a 10.

2. Delenie d na 2.

3. Doplnok b a výrobky c a 10.

4. Odčítanie kvocientu od delenia od výslednej sumy d do 2.

5. K výslednému rozdielu pripočítame 9.

Výsledok je úplne iný, však?

• Nedefinované: "nedefinované"
• Null: "objekt"
• Booleovský: „booleovský“
• Číslo: "číslo"
• Reťazec: "reťazec"
• Funkcia: "funkcia"
• Všetko ostatné: „predmet“

K tejto tabuľke by mali byť pridané nasledujúce poznámky:

1. typeof null === "objekt".

Teoreticky je to jemný bod. V jazykoch so statickým typom nesmie premenná typu objektu obsahovať objekt (NULL, nula, nulový ukazovateľ).

V praxi je to v JavaScripte nepohodlné. Vývojári ES 5.1 teda urobia intuitívnejšiu vec: typeof null === "null".

Ale keďže ES3 zatiaľ máme, nemýlite sa napríklad v tomto:

/ * Funkcia vyhľadá nejaký objekt a vráti ho alebo vráti hodnotu null, ak sa nič nenájde * / funkcia search () () var obj = search (); if (typeof obj === "object") (// skutočne sme našli objekt (FAIL) obj.method ();)

2. Nezabudnite na objekty obalu (typ nového čísla (5) === "objekt").

3. A nezabudnite na právo prehliadačov robiť čokoľvek s hostiteľskými objektmi.

Nenechajte sa prekvapiť, že Safari si tvrdohlavo myslí, že HTMLCollection je typ funkcie, a IE pred verziou 9 uchovával ako objekt našu obľúbenú funkciu alert (). Tiež prehliadač Chrome považoval funkciu RegExp za funkciu, ale teraz sa zdá, že ju vycítil a odpovedal na ňu objektom.

natiahnuť ()

Pokúšať sa zistiť typ hodnoty z výsledku metódy toString () je zbytočné. Vo všetkých „triedach“ je táto metóda predefinovaná na vlastnú.

Metóda je vhodná na zobrazenie informácií o ladení, ale typ premennej ňou nemožno určiť.

Object.prototype.toString ()

Aj keď je toString predefinovaný v rámci konkrétnych „tried“, stále máme jeho pôvodnú implementáciu z Object. Skúsme to použiť:

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

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

Clinton túto záťaž zriedi

Je iróniou, že táto metóda funguje prekvapivo dobre.

Pri skalárnych typoch vráti ,,,.

Vtipné na tom je, že sa vracia aj nové Číslo (5), na ktorom tu typ chyby zlyhal.

Metóda zlyhá v prípade hodnoty null a nedefinovanej. Vracajú sa rôzne prehliadače, niekedy očakávané a niekedy všeobecne. Je však ľahké určiť typ týchto dvoch hodnôt bez neho.

Zábava začína, keď sa dostaneme k objektom (k tým s typeof === „objekt“).

vstavané objekty fungujú prakticky bez problémov:

• {} —
• —
• Dátum -
• Chyba -
• RegExp -

Jediná vec, ktorá vypadne zo zoznamu argumentov, je to, že.
S hostiteľskými objektmi sa veci opäť zhoršujú.

V IE sa objekty DOM začali stávať „normálnymi“ objektmi až od 8. verzie a potom nie celkom do konca. Preto v IE 6-8 sú všetky tieto objekty (HTMLCOllection, DOMElement, TextNode a spolu s dokumentom a oknom) jednoducho prevedené na.

Vo všetkých ostatných prehliadačoch (vrátane IE9) už môžete s výsledkom toString niečo urobiť. Aj keď všetko tiež nie je jednoduché: HTMLCollection teda existuje. okno - potom, potom, potom. Ale už sa môžete pokúsiť z toho niečo vyťažiť.

S DOMElement je to ťažšie: zobrazuje sa ako, - vlastný formát pre každú značku. Ale tu nám pravidelná sezóna pomôže.

Príbeh je približne rovnaký s inými hostiteľskými objektmi (v testoch určovania polohy a navigátora). Všade, okrem IE, je ich možné identifikovať podľa reťazca.

Nevýhody používania Object.prototype.toString ():

1. Táto príležitosť nie je posvätená štandardom. A tu by sme sa mali radšej radovať z toho, že všetko funguje tak dobre, a nie lamentovať nad niektorými chybami.

2. Určenie typu analýzou reťazca vráteného metódou, ktorá vôbec nie je na určenie typu a je tiež volaná na predmet, do ktorého nepatrí, zanecháva v duši určité zvyšky.

3. V starom IE, ako vidíte, hostiteľské objekty zvyčajne nie sú identifikované.

Pri použití v spojení s inými nástrojmi je to však celkom funkčný kus.

Konštruktéri

A nakoniec, konštruktéri. Kto môže lepšie povedať o „triede“ objektu v JS, ak nie je jeho konštruktérom?

Null a undefined nemajú ani wrapper objekty, ani konštruktory.

Ostatné skalárne typy majú obaly, respektíve môžete získať konštruktor:

(5) .constructor === Číslo; (Číslo .NaN) .konštruktor === Číslo; (true) .constructor === Boolean; ("reťazec") .constructor === Reťazec;

(5) .constructor === Číslo; (Number.NaN) .constructor === Number; (true) .constructor === Boolean; ("reťazec"). constructor === Reťazec;

Ale instanceof tu nebude fungovať:

5 inštancia čísla; // falošné číslo .NaN inštancia Number; // false true instance of Boolean; // false "string" instanceof String; // nepravda

5 inštancia čísla; // falošné Number.NaN inštancia Number; // false true instance of Boolean; // false "string" instanceof String; // nepravda

(instanceof bude fungovať pre nové trpezlivé číslo (5))

S funkciami (ktoré sú tiež objektmi) instanceof prejde:

console.log ((function () ()) inštancia funkcie); // true console.log ((function () ()) .constructor === Funkcia); // pravda

console.log ((function () ()) inštancia funkcie); // true console.log ((function () ()). constructor === Funkcia); // pravda

Všetky objekty vstavaných tried sú tiež ľahko identifikovateľné ich konštruktérmi: Array, Date, RegExp, Error.

Jeden problém tu vzniká s argumentmi, ktorých konštruktorom je Object.

A druhý so samotným Objektom, respektíve ako naň odkazovať objekt vytvorený pomocou vlastného konštruktora.

Takto je možné definovať iba základný objekt:

obj instanceof Object;

Ako jeden z variantov definície - iterovať všetky ostatné možné typy (pole, chyba ...) a ak sa žiadny nezhoduje - „objekt“.

Konštruktory a hostiteľské objekty

S hostiteľskými objektmi sa veci zhoršujú.

Začnime s tým, že IE do verzie 7 vrátane ich vôbec nepovažuje za normálne objekty. Jednoducho tam nemajú konštruktérov a prototypy (v každom prípade ich programátor nemôže dosiahnuť).

Ostatné prehliadače sú na tom lepšie. Existujú konštruktory a môžete ich použiť na určenie triedy hodnôt. Len tie sa v rôznych prehliadačoch volajú odlišne. Napríklad pre HTMLCollection bude konštruktor buď HTMLCollection alebo NodeList, alebo dokonca NodeListConstructor.

Mali by ste tiež definovať základný konštruktor pre DOMElement. Vo FF je to napríklad HTMLElement, z ktorého sa už dedí HTMLDivElement a ďalšie.

FireFox pod verziou 10 a Opera pod verziou 11 žartuje. Konštruktérom zbierky je Object.

konštruktér.názov

Konštruktéri majú aj vlastnosť názvu, ktorá môže byť užitočná.

Obsahuje názov funkcie konštruktora, napríklad (5) .constructor.name === "Číslo".

Ale:
1. V IE to vôbec nie je, dokonca ani v 9.
2. Prehliadače opäť vytvarujú všetko do hostiteľských objektov (a často túto vlastnosť vôbec nemajú). V Opere má DOMElement názov konštruktora vo všeobecnom Function.prototype.
3. argumenty je opäť „objekt“.

závery

Žiadna z uvedených metód neposkytuje stopercentnú definíciu typu / triedy hodnoty vo všetkých prehliadačoch. Spoločne vám to však umožňujú.

V blízkej budúcnosti sa pokúsim zhromaždiť všetky údaje v tabuľkách a uviesť príklad definujúcej funkcie.

Operátor Typ vráti reťazec označujúci typ operandu.

Syntax

Operand nasleduje typ operátora:

Typ operand

možnosti

operand je výraz, ktorý predstavuje objekt alebo primitív, ktorého typ má byť vrátený.

Popis

Nasledujúca tabuľka uvádza možné návratové hodnoty typu typeof. Viac informácií o typoch a primitívach je na stránke.

Príklady

// čísla typu 37 === "číslo"; typ 3.14 === "číslo"; typeof (42) === "číslo"; typ matematiky.LN2 === "číslo"; typ nekonečna === "číslo"; typ NaN === "číslo"; // napriek tomu, že ide o typ čísla (1) === "číslo"; // tento záznam nikdy nepoužívajte! // Reťazce typeof "" === "string"; typ "bla" === "reťazec"; typ "1" === "reťazec"; // všimnite si, že číslo v reťazci je stále typu string typeof (typeof 1) === "string"; // typeof v tomto prípade vždy vráti reťazec typeof String ("abc") === "string"; // tento záznam nikdy nepoužívajte! // Booleans typeof true === "boolean"; typeof false === "boolean"; type of Boolean (true) === "boolean"; // tento záznam nikdy nepoužívajte! // Symboly typeof Symbol () === "symbol" typeof Symbol ("foo") === "symbol" typeof Symbol.iterator === "symbol" // Nedefinovaný typof undefined === "undefined"; typeof deklarovanýButUndefinedVariable === "nedefinovaný"; typeof undeclaredVariable === "nedefinované"; // Objekty typeof (a: 1) === "objekt"; // pomocou Array.isArray alebo Object.prototype.toString.call // rozlišujte medzi bežnými objektmi a poľami typeof === "object"; typeof new Date () === "objekt"; // Čo je uvedené nižšie, vedie k chybám a problémom. Nepoužívať! typeof new Boolean (true) === "objekt"; typ nového čísla (1) === "objekt"; typeof new String ("abc") === "objekt"; // Funkcie typeof function () () === "function"; typ triedy C () === "funkcia"; typeof Math.sin === "funkcia";

nulový

// Toto je definované od narodenia JavaScript typeof null === "object";

V prvej implementácii JavaScriptu boli hodnoty reprezentované párom typu značky a hodnoty. Typ značky pre objekty bol 0. null bol reprezentovaný ako nulový ukazovateľ (0x00 na väčšine platforiem). Preto bol typ značky pre null nulový, takže návratová hodnota typeof je falošná. ()

Oprava bola navrhnutá v ECMAScript (prostredníctvom deaktivácie), ale bola odmietnutá. Výsledkom bude typeof null === "null".

Použitie nového operátora

// Všetky funkcie konštruktora vytvorené pomocou "new" budú typu "object" var str = new String ("String"); var num = nové číslo (100); typ str; // Vracia "object" typeof num; // Vráti "objekt" // Existuje však výnimka pre konštruktor funkcií var func = new Function (); typ funkcie; // Vráti "funkciu"

Regulárne výrazy

Volateľné regulárne výrazy boli v niektorých prehliadačoch neštandardným doplnkom.

Typeof / s / === "funkcia"; // Chrome 1-12 Nie je kompatibilný s ECMAScript 5.1 typeof / s / === "objekt"; // Vyhovuje Firefoxu 5+ ECMAScript 5.1

Chyby súvisiace s dočasnými mŕtvymi zónami

Pred ECMAScript 2015 mal operátor typeof zaručenú návratnosť reťazca pre akýkoľvek operand, s ktorým bol volaný. To sa zmenilo pridaním vyhlásení o zdvihu let a const s blokovaným rozsahom. Teraz, ak sú premenné deklarované pomocou let a const a je na ne vyvolaný typeof v bloku deklarácie premenných, ale pred deklaráciou je vyvolané ReferenceError. Správanie sa líši od nedeklarovaných premenných, pre ktoré typeof vráti „nedefinované“. Premenné s rozsahom bloku sú v „dočasnej zóne“, ktorá trvá od začiatku bloku do vyhlásenia premennej. V tejto zóne pokus o prístup k premenným vyvoláva výnimku.

Typeof undeclaredVariable === "nedefinované"; typ newLetVariable; nech newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "ahoj"; // ReferenceError

Výnimky

Všetky aktuálne prehliadače majú neštandardný objekt document.all hostiteľa typu Undefined.

Typeof document.all === "nedefinované";

Aj keď špecifikácia umožňuje názvy vlastných typov pre neštandardné exotické objekty, vyžaduje sa, aby sa tieto názvy líšili od preddefinovaných. Situáciu, kde document.all nie je definovaná, je potrebné považovať za výnimočné porušenie pravidiel.

Špecifikácia

Špecifikácia	Postavenie	Komentáre (1)
Najnovší návrh ECMAScript (ECMA-262)	Návrh
ECMAScript 2015 (6. vydanie, ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné
ECMAScript 5.1 (ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné
3. vydanie ECMAScript (ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné
1. vydanie ECMAScript (ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné	Pôvodná definícia. Implementované v JavaScripte 1.1

Kompatibilita prehliadača

Aktualizujte údaje o kompatibilite na GitHub

	Počítače						Mobilné						Server
	Chrome	Hrana	Firefox	internet Explorer	Opera	Safari	Webview v systéme Android	Chrome pre Android	Firefox pre Android	Opera pre Android	Safari v systéme iOS	Internet Samsung	Node.js
Typ	Chrome Plná podpora 1	Hrana Plná podpora 12	Firefox Plná podpora 1	IE Plná podpora 3	Opera Plná podporaÁno	Safari Plná podporaÁno	WebView Android Plná podpora 1	Chrome Android Plná podpora 18	Firefox pre Android Plná podpora 4	Opera Android Plná podporaÁno	Safari iOS Plná podporaÁno	Internetový telefón Samsung pre Android Plná podpora 1.0	nodejs Plná podporaÁno

Legenda

Plná podpora Plná podpora

Poznámky špecifické pre IE

V IE 6, 7 a 8 sú mnohé hostiteľské objekty objekty, ale nie funkcie. Napríklad.