Identificarea dinamică a tipului

Identificare dinamică a tipului (RTTI) vă permite să determinați tipul unui obiect în timpul execuției. Se dovedește a fi util din mai multe motive. În special, prin referire la clasa de bază, puteți determina destul de precis tipul de obiect accesibil prin această referință. Identificarea dinamică a tipului vă permite, de asemenea, să verificați în prealabil cât de reușit va fi rezultatul turnării tipului, prevenind o excepție din cauza castingului tip incorec. În plus, identificarea tipului dinamic este o componentă majoră a reflecției.

Pentru a sprijini identificarea tipului dinamic, C# oferă trei Cuvinte cheie a: is, as and typeof. Fiecare dintre aceste cuvinte cheie este discutată pe rând.

este operator

Tipul specific al unui obiect poate fi determinat folosind operatorul is. Mai jos este forma sa generală:

expresia este tip

unde expresie denotă o singură expresie care descrie obiectul al cărui tip este testat. Dacă expresia este compatibilă sau de același tip cu tipul testat, atunci rezultatul acestei operații este adevărat, în caz contrar este fals. Astfel, rezultatul va fi adevărat dacă expresia este de tipul testat într-o formă sau alta. În operatorul is, ambele tipuri sunt definite ca fiind compatibile dacă sunt de același tip sau dacă sunt furnizate conversie de referință, boxing sau unboxing.

Următorul este un exemplu de utilizare a operatorului is:

Utilizarea sistemului; namespace ConsoleApplication1 ( clasa Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); if (a este Add) Console.WriteLine("Variable a este de tip Add"); if (s este Sum) Console.WriteLine("Tipul variabilei s este moștenit de la clasa Add"); Console.ReadLine(); ) ) )

ca operator

Uneori, o conversie de tip trebuie făcută în timpul executării, dar nu aruncată dacă conversia eșuează, ceea ce este perfect posibil cu o distribuție de tip. Operatorul as servește acestui scop și are următoarea formă generală:

expresie ca tip

unde expresie denotă o singură expresie care poate fi convertită în tipul specificat.

Dacă rezultatul unei astfel de conversii este de succes, atunci se returnează o referință la tip, în caz contrar, o referință nulă. Operatorul as poate fi folosit doar pentru conversie de referință, identitate, boxing, unboxing. În unele cazuri, operatorul as poate fi o alternativă convenabilă la operatorul is. Ca exemplu, luați în considerare următorul program:

Utilizarea sistemului; namespace ConsoleApplication1 ( class Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); // Efectuați cast a = s ca Add; if ( a != null) Console.WriteLine("Conversie reușită"); else Console.WriteLine("Eroare la conversie"); Console.ReadLine(); ) ) )

Rezultatul executării acestui program va fi o conversie reușită.

JavaScript sau JS(în scurt timp) nu este un limbaj ușor și dezvoltatorii începători nu vor afla despre el imediat. La început învață elementele de bază și totul pare colorat și frumos. Mergând puțin mai adânc, există Matrice JavaScript, obiecte, apeluri inverse și orice altceva care deseori sufla mintea.

În JavaScript, este important să verificați corect tipul unei variabile. Să presupunem că vrei să știi dacă variabilă matrice sau un obiect? Cum se verifică corect? În acest caz particular, există trucuri în timpul verificării și despre asta va fi vorba în această postare. Să începem imediat.

Verificarea tipului unei variabile

De exemplu, trebuie să verificați dacă o variabilă este un obiect, o matrice, un șir sau un număr. Puteți folosi typeof pentru aceasta, dar nu vă va spune întotdeauna adevărul și vă voi arăta de ce în exemplul de mai jos.

Am scris acest exemplu pentru a ilustra de ce typeof nu este întotdeauna alegerea potrivită.

Var _comparație = ( șir: „șir”, int: 99, float: 13.555, obiect: (bună ziua: „bună ziua”), matrice: nou Array(1, 2, 3) ); // Returnează o matrice cu cheile obiectului var _objKeys = Object.keys(_comparison); pentru(var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Rezultatul executării codului:

Obiect obiect număr șir

Dreapta? - Desigur că nu. Sunt două probleme. Fiecare dintre ele va fi descrisă în detaliu și va fi propusă o soluție.

Prima problemă: număr flotant, ieșire ca număr

Comparison.float nu este un număr și trebuie să fie un float în loc de număr. Pentru a remedia acest lucru, puteți crea o funcție cu o verificare ca în codul de mai jos.

Var_floatNumber = 9,22; var_notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); funcția isFloat(n)( returnează Număr(n) === n && n % 1 !== 0; )

Funcția isFloat() verifică toate valorile pentru numere în virgulă mobilă. Mai întâi verificați dacă variabila este egală n număr (Număr(n) === n) și dacă da, se mai face o verificare pentru împărțirea cu rest și dacă există un rest, atunci se returnează un boolean ( Adevărat sau fals) rezultat (n % 1 !== 0).

În exemplul de mai sus, se întoarce Adevărat, falsși fals. Primul sens este pluti tip, al doilea nu este - acesta este un număr obișnuit, iar ultimul este doar un șir gol care nu se potrivește cu regulile.

A doua problemă: matricea a fost definită ca obiect

În primul exemplu, matricea este redată ca obiect, ceea ce nu este foarte bun, deoarece uneori trebuie să utilizați acest tip și nimic altceva.

Există mai multe moduri de a testa o variabilă pentru un tip de matrice.

Prima variantă (opțiune bună). Verificați dacă datele aparțin unui tablou folosind instanceof().

Var date = new Array ("bună ziua", "lumea"); var isArr = data instanceof Array;

A doua opțiune (opțiune bună). Metoda Array.isArray() returnează o valoare booleană care va depinde dacă variabila este o matrice sau nu ().

Var date = new Array ("bună ziua", "lumea"); var isArr = Array.isArray(data);

A treia varianta (cea mai buna, dar lunga). Pentru comoditate, puteți face din această metodă o funcție. Folosind Object facem . Dacă rezultatul Object.prototype.toString.call(data) nu este egal, atunci variabila nu este o matrice ().

Var date = new Array ("bună ziua", "lumea"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

Ultimul rezultat ca funcție de confort:

Funcția isArray(data) ( return Object.prototype.toString.call(data) == "" )

Acum puteți apela funcțiile isArray() și puteți seta o matrice sau ceva ca argument și să vedeți rezultatul.

Postfaţă

Recordul s-a dovedit a fi destul de mare decât era intenționat inițial. Dar sunt mulțumit de el, deoarece este suficient de concis și clar pentru a descrie dificultățile de validare a variabilelor în JavaScript și cum să le ocoliți.

Dacă aveți întrebări, vă rugăm să le postați sub această postare. Voi fi bucuros să vă ajut.

a = (b > 0) && (c + 1 != d); flag = !(starea = 0);

Tabelul 14.5. Operatori logici

Descrierea operatorului

! NOT (inversie logică)

&& AND (înmulțire booleană)

|| SAU (adăugare logică)

Tabelul 14.6. Rezultatele executării operatorilor AND și OR

Operandul 1	Operandul 2

Tabelul 14.7. Rezultatele executării instrucțiunii NOT

obține tipul operatorului

Obțineți operator de tip typeof returnează un șir care descrie tipul de date al operandului. Operandul al cărui tip trebuie găsit este plasat după acest operator și inclus în paranteze:

s = tipul("str");

Ca rezultat al acestei expresii, variabila s va conține șirul „șir” , indicând tipul șirului.

Toate valorile pe care tipul de operator le poate returna sunt enumerate în Tabelul 1. 14.8.

	Tabelul 14.8. Valori returnate de tipul operatorului
Tip de date		șir de returnare
Şir
Numeric

			Tabelul 14.8 (sfârșit)
	Tip de date	șir de returnare
	Logic

Compatibilitate și conversie tip de date

Este timpul să luăm în considerare încă două aspecte importante: compatibilitatea tipurilor de date și conversia de la un tip la altul.

Ce se întâmplă când adunăm două numere? Așa este - o altă valoare numerică. Ce se întâmplă dacă adaugi un număr și un șir? E greu de spus... Aici JavaScript se confruntă cu problema incompatibilității tipurilor de date și încearcă să facă aceste tipuri compatibile prin conversia unuia dintre ele în altul. Mai întâi încearcă să convertească șirul într-un număr și, dacă reușește, efectuează adunarea. Dacă nu reușește, numărul va fi convertit într-un șir și cele două șiruri rezultate vor fi concatenate. De exemplu, scriptul Web din Lista 14-6 ar converti valoarea variabilei b atunci când este adăugată variabilei a într-un tip numeric; astfel variabila c va conține valoarea 23.

Lista 14.6

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

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

d="JavaScript"; e = 2;

Dar, deoarece valoarea variabilei d nu poate fi convertită într-un număr, valoarea lui e va fi convertită într-un șir, iar rezultatul - valoarea lui f - va deveni egal cu

Valorile booleene sunt convertite fie în valori numerice, fie în șir, după caz. True va fi convertit la numărul 1 sau șirul „1” și false la 0 sau „0” . În schimb, numărul 1 va fi convertit în adevărat și numărul 0 în fals. De asemenea, falsul va fi convertit

suntem nuli si nedefiniti.

	Partea a III-a. Comportamentul paginii web. Scripturi web

Se poate observa că JavaScript se luptă să execute corect chiar și expresiile scrise incorect. Uneori funcționează, dar de cele mai multe ori, lucrurile nu merg așa cum a fost planificat și, în cele din urmă, scriptul Web este avortat din cauza unei erori găsite într-un loc complet diferit în script, pe declarația absolut corectă. Prin urmare, este mai bine să evitați astfel de incidente.

Prioritatea operatorului

Ultima problemă de care ne vom ocupa aici este prioritatea operatorului. După cum ne amintim, precedența afectează ordinea în care operatorii dintr-o expresie sunt executați.

Să fie următoarea expresie:

În acest caz, mai întâi se va adăuga valoarea lui c la valoarea variabilei b, iar apoi se va scădea din sumă 10. Operatorii acestei expresii au aceeași prioritate și de aceea sunt executați strict de la stânga la dreapta.

Acum luați în considerare această expresie:

Aici, mai întâi, valoarea c va fi înmulțită cu 10 și abia apoi valoarea b va fi adăugată la produsul rezultat. Operatorul de multiplicare are o prioritate mai mare decât operatorul de adunare, astfel încât ordinea „strict de la stânga la dreapta” va fi încălcată.

Operatorii de atribuire au cea mai mică prioritate. De aceea expresia în sine este evaluată mai întâi, iar apoi rezultatul ei este atribuit unei variabile.

V În general, principiul de bază al executării tuturor instrucțiunilor este următorul: în primul rând, instrucțiunile cu mai mult decât prioritate ridicată, și numai atunci - operatori cu unul inferior. Operatorii cu aceeași prioritate sunt executați în ordinea în care apar (de la stânga la dreapta).

V fila. 14.9 listează toți operatorii pe care i-am studiat în ordinea descrescătoare a priorității lor.

		Tabelul 14.9. Precedența operatorului (în ordine descrescătoare)
	Operatori	Descriere
	++ -- - ~ ! tip de	Creștere, descreștere, schimbare de semn, NOT logic, inferență de tip
		Înmulțire, împărțire, rest
		Adunarea și concatenarea șirurilor, scăderea
		Operatori de comparare
		logic ŞI

	Capitolul 14. Introducere în Programarea Web. limbaj JavaScript
			Tabelul 14.9 (sfârșit)
	Operatori	Descriere
		SAU logic
		Operator condiționat (vezi mai jos)
	= <оператор>=	Misiunea, simplă și complexă

ATENŢIE!

Amintiți-vă acest tabel. Ordinea incorectă de execuție a instrucțiunilor poate provoca erori greu de detectat, în care o expresie aparent absolut corectă dă un rezultat incorect.

Dar dacă trebuie să încălcăm ordinea normală de execuție a instrucțiunilor? Să folosim paranteze. În această notație, instrucțiunile între paranteze sunt executate mai întâi:

a = (b + c) * 10;

Aici, valorile variabilelor b și c vor fi adăugate mai întâi, iar apoi suma rezultată va fi înmulțită cu 10.

Operatorii încadrați în paranteze sunt, de asemenea, supuși priorității. Prin urmare, sunt adesea folosite mai multe paranteze imbricate:

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

Aici instrucțiunile vor fi executate în următoarea ordine:

1. Adăugați b și c.

2. Înmulțiți suma rezultată cu 10.

3. Scăderea d din produs.

4. Împărțiți diferența la 2.

5. Adunarea lui 9 la coeficient.

Dacă scoateți parantezele:

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

atunci ordinea de executare a operatorilor va fi următoarea:

1. Înmulțiți c și 10.

2. Împărțiți d la 2.

3. Adunând b și înmulțind c și 10.

4. Scăderea din suma rezultată a câtului din împărțire d la 2.

5. Adăugând 9 la diferența rezultată.

Se dovedește un rezultat complet diferit, nu?

• nedefinit nedefinit"
• Null: „obiect”
• Boolean: „boolean”
• Număr: „număr”
• Șir: "șir"
• Funcție: „funcție”
• Orice altceva: „obiect”

Următoarele observații ar trebui adăugate la acest tabel:

1. typeof null === „obiect” .

Teoretic, există un punct subtil aici. În limbajele tipizate static, o variabilă de tip obiect nu poate conține un obiect (NULL, nil, pointer nul).

Practic - în JavaScript este incomod. Deci, dezvoltatorii ES 5.1 vor face ceva mai intuitiv: typeof null === "null" .

Dar, din moment ce suntem încă în preajma ES3, nu vă înșelați, de exemplu, în privința asta:

/* Funcția caută un obiect și îl returnează sau null dacă nu se găsește nimic */ function search() () var obj = search(); if (typeof obj === „obiect”) ( // am găsit cu adevărat obiectul (FAIL) obj.method(); )

2. Nu uitați de obiectele wrapper (typeof new Number(5) === „obiect”).

3. Și nu uitați de dreptul browserelor de a face orice cu obiectele-gazdă.

Nu fi surprins că Safari tratează cu încăpățânare HTMLCollection ca pe un tip de funcție, iar IE anterioară a 9-a menține funcția noastră favorită alert() ca obiect. De asemenea, Chrome obișnuia să considere RegExp o funcție, dar acum pare să-și vină în fire și îi răspunde cu un obiect.

toString()

Încercarea de a afla tipul unei valori din rezultatul metodei sale toString() este inutilă. În toate „clasele” această metodă este redefinită la propria sa.

Metoda este bună pentru afișarea informațiilor de depanare, dar tipul variabilei nu poate fi determinat din aceasta.

Object.prototype.toString()

Chiar dacă toString este suprascris în interiorul „claselor” concrete, încă avem implementarea sa inițială din Object. Să încercăm să-l folosim:

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

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

Clinton diluează această povară

Destul de ciudat, această metodă funcționează surprinzător de bine.

Pentru tipuri scalare se intoarce , , , .

Lucrul amuzant este că chiar și noul Number(5) la care tip de eșuat aici revine.

Pe null și nedefinit metoda va eșua. Diferitele browsere returnează fie așteptate și , fie , sau chiar . Cu toate acestea, este ușor să determinați tipul acestor două valori fără acest lucru.

Lucrurile interesante încep când ajungem la obiecte (cele cu typeof === „obiect”).

obiectele încorporate funcționează, practic, cu un bang:

• {} —
• —
• Data-
• eroare-
• expresie regulată-

Singurul lucru care iese din lista de argumente, care este fie , fie .
Cu obiectele gazdă, totul este din nou mai rău.

În IE, obiectele DOM au început să devină obiecte „normale” abia din versiunea a 8-a, și apoi nu chiar până la sfârșit. Prin urmare, în IE 6-8 toate aceste obiecte (HTMLCOllection, DOMElement, TextNode, precum și document și window) sunt pur și simplu turnate în .

În toate celelalte browsere (inclusiv IE9), puteți deja să faceți ceva cu rezultatul toString. Deși totul nu este, de asemenea, ușor: HTMLCollection acolo , apoi . fereastra - apoi , apoi , apoi . Dar poți încerca deja să scoți ceva din asta.

Este mai dificil cu DOMElement: este afișat ca , un format diferit pentru fiecare etichetă. Dar aici sezonul regulat ne va ajuta.

Cu alte obiecte gazdă (în testele de locație și navigator), povestea este cam aceeași. Peste tot, cu excepția IE, ele pot fi identificate printr-un șir.

Dintre minusurile utilizării Object.prototype.toString():

1. Această posibilitate nu este consacrată de standard. Și noi aici ar trebui mai degrabă să ne bucurăm că totul funcționează atât de bine și să nu ne plângem de unele defecte.

2. Determinarea unui tip prin parsarea unui șir returnat printr-o metodă care nu este deloc pentru determinarea tipului, și chiar apelat la un obiect căruia nu se aplică, lasă ceva sediment pe suflet.

3. În vechiul IE, după cum puteți vedea, obiectele gazdă nu sunt identificate în mod normal.

Cu toate acestea, este un lucru destul de funcțional atunci când este utilizat împreună cu alte instrumente.

Constructorii

Și în sfârșit, constructori. Cine poate spune mai bine despre „clasa” unui obiect în JS decât constructorul său?

null și nedefinit nu au nici obiecte wrapper, nici constructori.

Restul tipurilor scalare au wrapper-uri, așa că puteți obține un constructor:

(5) .constructor === Număr ; (Număr .NaN ) .constructor === Număr ; (adevărat) .constructor === Boolean ; ("șir") .constructor === String ;

(5).constructor === Număr; (Număr.NaN).constructor === Număr; (adevărat).constructor === Boolean; ("șir").constructor === șir;

Dar instanceof nu va funcționa aici:

5 instanceofNumber ; // false Number .NaN instanceof Number ; // false adevărată instanță booleană; // instanță „șir” falsă a String ; // fals

5 instanceofNumber; // false Number.NaN instanceof Number; // false adevărată instanță booleană; // "șir" fals instanță de șir; // fals

(instanceof va funcționa pentru noul număr (5) de multă suferință)

Cu funcții (care sunt și obiecte), instanceof va face:

console.log ( (funcție () ( ) ) instanță de Funcție); // adevărată consolă.log ( (funcție () ( ) ) .constructor === Funcție ) ; // Adevărat

console.log((funcția () ()) instanceof Funcție); // true console.log((funcție () ()).constructor === Funcție); // Adevărat

Toate obiectele claselor încorporate sunt de asemenea ușor identificate de către constructori: Array , Date , RegExp , Error .

O problemă apare aici cu argumentele, al căror constructor este Object.

Și al doilea cu Obiectul în sine, sau mai degrabă, cum să ne referim la el un obiect creat printr-un constructor personalizat.

Numai obiectul de bază poate fi definit astfel:

obj instanceofObject;

Ca una dintre opțiunile de definire, repetați peste toate celelalte tipuri posibile (Matrice , Eroare ...) și dacă niciunul nu se încadrează sub - „obiect”.

Constructori și obiecte gazdă

Lucrurile se înrăutățesc cu obiectele gazdă.

Să începem cu faptul că IE până la versiunea a 7-a inclusiv nu le consideră deloc obiecte normale. Pur și simplu nu au constructori și prototipuri acolo (în orice caz, programatorul nu le poate ajunge).

Lucrurile sunt mai bune în alte browsere. Există constructori și puteți determina clasa de valoare din aceștia. Numai că acestea sunt numite diferit în browsere diferite. De exemplu, pentru o HTMLCollection, constructorul va fi fie o HTMLCollection, fie o NodeList, fie chiar un NodeListConstructor.

De asemenea, ar trebui să definiți un constructor de bază pentru DOMElement. În FF, acesta este, de exemplu, HTMLElement , de la care HTMLDivElement și alții moștenesc deja.

Trucul este aruncat de FireFox sub versiunea 10 și Opera sub versiunea 11. Acolo, constructorul colecției este Object .

constructor.nume

Constructorii au, de asemenea, o proprietate de nume care poate fi utilă.

Conține numele funcției de constructor, de exemplu, (5).constructor.name === „Număr” .

Dar:
1. În IE nu este deloc, nici măcar în al 9-lea.
2. În obiectele gazdă, browserele modelează din nou tot ceea ce este mult (și adesea nu au această proprietate deloc). În Opera, DOMElement are un nume de constructor în general Function.prototype .
3. argumente din nou „obiect”.

concluzii

Niciuna dintre metodele prezentate nu oferă o definiție 100% a tipului/clasei valorii în toate browserele. Cu toate acestea, împreună vă permit să faceți acest lucru.

În viitorul apropiat voi încerca să colectez toate datele în tabele și să dau un exemplu de funcție definitorie.

Operator tip de returnează un șir care indică tipul operandului.

Sintaxă

Operandul urmează tipul operatorului:

tip de operand

Parametrii

operand este o expresie care reprezintă obiectul sau primitivul al cărui tip urmează să fie returnat.

Descriere

Următorul tabel listează valorile posibile de returnare ale tipului de . Informații suplimentare despre tipuri și primitive este pe pagină.

Exemple

// Tipul numerelor 37 === „număr”; tip de 3,14 === „număr”; typeof(42) === „număr”; typeof Math.LN2 === „număr”; tip de infinit === „număr”; tip de NaN === „număr”; // chiar dacă este tipul „Nu-A-Număr” de Număr(1) === „număr”; // nu utilizați niciodată această notație! // Strings typeof "" === "șir"; tipul „bla” === „șir”; tipul „1” === „șir”; // rețineți că numărul din interiorul șirului este încă de tip șir typeof (typeof 1) === "șir"; // typeof va returna întotdeauna un șir în acest caz typeof String("abc") === "șir"; // nu utilizați niciodată această notație! // Tipul booleanului adevărat === „boolean”; tip de fals === „boolean”; tipul boolean (adevărat) === „boolean”; // nu utilizați niciodată această notație! // Simboluri tip de Simbol() === "simbol" tip de Simbol("foo") === "simbol" tip de Simbol.iterator === "simbol" // Tip nedefinit de nedefinit === "nedefinit"; typeof declaredButUndefinedVariable === „nedefinit”; typeof undeclaredVariable === „nedefinit”; // Objects typeof(a: 1) === „obiect”; // folosiți Array.isArray sau Object.prototype.toString.call // pentru a distinge între obiectele obișnuite și matrice typeof === „obiect”; typeof new Date() === „obiect”; // Orice de mai jos duce la erori și probleme. Nu folosi! tip de boolean nou (adevărat) === „obiect”; typeof new Number(1) === „obiect”; typeof new String("abc") === "obiect"; // Funcții typeof function() () === „funcție”; tipul clasei C() === „funcție”; typeof Math.sin === „funcție”;

nul

// Aceasta a fost definită de la nașterea tipului JavaScript de null === „obiect”;

În prima implementare a JavaScript, valorile erau reprezentate de un tip de etichetă și o pereche de valori. Tipul de tag pentru obiecte a fost 0. null a fost reprezentat ca un pointer nul (0x00 pe majoritatea platformelor). Prin urmare, tipul etichetei pentru null a fost nul, deci valoarea returnată a typeof este falsă. ()

O remediere a fost propusă în ECMAScript (prin dezactivare), dar a fost respinsă. Acest lucru ar avea ca rezultat tipul null === „null” .

Folosind noul operator

// Toate funcțiile de constructor create cu "new" vor fi de tipul "object" var str = new String("String"); var num = new Number(100); typeofstr; // Returnează tipul „obiect” de num; // Returnează „obiect” // Dar există o excepție pentru constructorul Funcție var func = new Function(); tip de funcție; // Returnează „funcție”

Expresii obisnuite

Expresiile regulate numite au fost o adăugare non-standard în unele browsere.

Tipul /s/ === „funcție”; // Chrome 1-12 Nu este compatibil cu ECMAScript 5.1 tip de /s/ === „obiect”; // Firefox 5+ Respectă ECMAScript 5.1

Bug-uri legate de zonele moarte temporare

Înainte de ECMAScript 2015, operatorul typeof era garantat să returneze un șir pentru orice operand cu care era apelat. Acest lucru s-a schimbat odată cu adăugarea declarațiilor let și const care nu au ca obiect de ridicare. Acum, dacă variabilele sunt declarate cu let și const și typeof este apelat pe ele în blocul de declarare a variabilelor, dar înainte de declarație, atunci se aruncă o ReferenceError. Comportamentul este diferit de variabilele nedeclarate, pentru care typeof va returna „nedefinit”. Variabilele blocate se află într-o „zonă moartă temporară”, care durează de la începutul blocului până în momentul în care variabilele sunt declarate. În această zonă, o încercare de a accesa variabile aruncă o excepție.

Typeof undeclaredVariable === „nedefinit”; typeof newLetVariable; let newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "bună ziua"; // ReferenceError

Excepții

În toate browserele actuale, există un obiect gazdă document.all non-standard, care este de tip Nedefinit.

Tip de document.all === „nedefinit”;

Deși specificația permite nume de tip personalizate pentru obiecte exotice non-standard, aceste nume trebuie să fie diferite de cele predefinite. Situația în care document.all este de tip nedefinit ar trebui considerată o încălcare excepțională a regulilor.

Specificații

Specificație	stare	Comentarii
Ultima versiune ECMAScript (ECMA-262)	Proiect
ECMAScript 2015 (ediția a 6-a, ECMA-262) Definiția „Tipului de operator” în această specificație.	Standard
ECMAScript 5.1 (ECMA-262) Definiția „Tipului de operator” în această specificație.	Standard
ECMAScript a treia ediție (ECMA-262) Definiția „Tipului de operator” în această specificație.	Standard
ECMAScript prima ediție (ECMA-262) Definiția „Tipului de operator” în această specificație.	Standard	Definiție inițială. Implementat în JavaScript 1.1

Compatibilitate browser

Actualizați datele de compatibilitate pe GitHub

	Calculatoare						Mobil						Server
	Crom	margine	Firefox	Internet Explorer	Operă	safari	vizualizare web Android	Chrome pentru Android	Firefox pentru Android	Opera pentru Android	Safari pe iOS	Samsung Internet	Node.js
tip de	Crom Suport complet 1	margine Suport complet 12	Firefox Suport complet 1	IE Suport complet 3	Operă Suport complet da	safari Suport complet da	Webview Android Suport complet 1	Chrome Android Suport complet 18	Firefox Android Suport complet 4	OperaAndroid Suport complet da	Safari iOS Suport complet da	Samsung Internet Android Suport complet 1.0	nodejs Suport complet da

Legendă

Suport complet Suport complet

Note specifice IE

În IE 6, 7 și 8, multe obiecte gazdă sunt obiecte, nu funcții. De exemplu.