Identificarea dinamică a tipului

Identificare dinamică a tipului (RTTI) vă permite să determinați tipul unui obiect în timpul execuției programului. Se dovedește a fi util din mai multe motive. În special, folosind o referință la o clasă 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 avea o distribuție de tip, prevenind o excepție din cauza unui tip incorect. Î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 mai jos 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 are un tip testat într-o formă sau alta. Operatorul is definește ambele tipuri ca fiind compatibile dacă sunt de același tip sau dacă sunt furnizate conversie de referință, boxing sau unboxing.

Mai jos 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"); dacă (s este Sum) Console.WriteLine("Tipul variabilei s este moștenit de la clasa Add"); Console.ReadLine(); ) ) )

Operator ca

Uneori doriți să efectuați o conversie de tip în timpul execuției, dar nu să aruncați o excepție dacă conversia nu reușește, ceea ce este foarte posibil cu turnarea de tip. Operatorul în calitate servește acestui scop, având următoarea formă generală:

expresie ca tip

unde expresie denotă o singură expresie care se convertește la tipul specificat.

Dacă rezultatul unei astfel de conversii este de succes, atunci se returnează o referință la tip, în caz contrar o referință goală. 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 casting tip a = s ca Add; dacă (a != null) Console.WriteLine("Conversia a avut succes"); else Console.WriteLine("Eroare în timpul conversiei");

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

JavaScript sau JS(abreviat) 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 un pic mai adânc, apar matrice JavaScript, obiecte, apeluri inverse și orice altceva de genul ăsta, ceea ce de multe ori vă surprinde mintea.

În JavaScript, este important să verificați corect tipul unei variabile. Să presupunem că vrei să știi dacă o variabilă este o matrice sau un obiect? Cum să verific asta corect? În acest caz particular, există trucuri în timpul verificării și această postare va fi despre ele. 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 va spune întotdeauna adevărul și în exemplul de mai jos voi arăta de ce.

Am scris acest exemplu pentru a arăta clar 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:

șir număr număr obiect obiect

Corect? - 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 în loc de număr ar trebui să fie un float (număr în virgulă mobilă) 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ă dacă toate valorile sunt în virgulă mobilă. În primul rând, se verifică dacă variabila este egală cu n număr (Număr(n) === n) și dacă da, se face o altă verificare pentru împărțirea cu rest și dacă există un rest, atunci un boolean ( adevărat sau fals) rezultat (n % 1 !== 0).

În exemplul de mai sus revine adevărat, falsŞi fals. Primul sens este plutesc tip, al doilea nu este - 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 a fost afișată ca obiect și acest lucru nu este foarte bun, deoarece uneori trebuie să utilizați exact acest tip și nimic altceva.

Există mai multe moduri de a verifica dacă o variabilă este de tip matrice.

Prima opțiune (opțiune bună). Verificăm 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 opțiune (cea mai bună, dar lungă). 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 sub forma unei funcții 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 altceva ca argument și să vedeți rezultatul.

Postfaţă

Înregistrarea s-a dovedit a fi destul de mare decât era prevăzut inițial. Dar sunt mulțumit de el, deoarece descrie destul de succint și clar dificultățile la verificarea variabilelor în JavaScript și cum să le ocoliți.

Dacă mai aveți întrebări, scrieți-le mai jos la această intrare. Voi fi bucuros să ajut.

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

Sintaxă

Operandul urmează tipul de operator:

Tip de operand

Opțiuni

operand este o expresie care reprezintă un obiect sau o primitivă al cărui tip urmează să fie returnat.

Descriere

Următorul tabel listează valorile posibile de returnare ale tipului de. Mai multe informații despre tipuri și primitive pot fi găsite pe pagină.

Exemple

// Tipul numerelor 37 === „număr”; tip de 3,14 === „număr”; typeof(42) === „număr”; typeof Math.LN2 === „număr”; typeof Infinity === „număr”; tip de NaN === „număr”; // chiar dacă acesta este tipul „Nu-A-Număr” de Number(1) === „număr”; // nu folosiți niciodată această intrare! // Strings typeof "" === "șir"; tipul „bla” === „șir”; tipul „1” === „șir”; // rețineți că numărul din interiorul șirului este încă de tipul șirului typeof (typeof 1) === "șir"; // typeof va returna întotdeauna un șir în acest caz typeof String("abc") === "șir"; // nu folosiți niciodată această intrare! // Tipul booleanului true === "boolean"; tip de fals === „boolean”; tipul boolean (adevărat) === „boolean”; // nu folosiți niciodată această intrare! // 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 diferenția între obiectele obișnuite și matrice typeof === „obiect”; typeof new Date() === „obiect”; // Ceea ce urmează duce la erori și probleme. Nu-l 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 etichetă 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 tipului de tip este inactivă. ()

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); tip de str; // 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 regulate

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

Tipul /s/ === „funcție”; // Chrome 1-12 nu respectă tipul ECMAScript 5.1 de /s/ === „obiect”; // Firefox 5+ Respectă ECMAScript 5.1

Erori legate de zonele moarte temporare

Înainte de ECMAScript 2015, operatorul typeof era garantat să returneze un șir pentru orice operand cu care a fost apelat. Acest lucru s-a schimbat odată cu adăugarea declarațiilor let și const fără ridicare în bloc. 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 este aruncată o ReferenceError. Comportamentul diferă de variabilele nedeclarate, pentru care typeof va returna „nedefinit”. Variabilele blocate au o „zonă moartă temporară” care durează de la începutul blocului până când variabila este declarată. Î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 curente, există un obiect gazdă non-standard document.all, care este de tip Nedefinit.

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

Deși specificația permite nume de tip personalizate pentru obiecte exotice non-standard, necesită ca aceste nume 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

Caietul de sarcini	Stare	Comentarii
Ultima versiune ECMAScript (ECMA-262)	Proiect
ECMAScript 2015 (ediția a 6-a, ECMA-262) Definiția „Tipului de operator” este în această specificație.	Standard
ECMAScript 5.1 (ECMA-262) Definiția „Tipului de operator” este în această specificație.	Standard
ECMAScript ediția a treia (ECMA-262) Definiția „Tipului de operator” este în această specificație.	Standard
ECMAScript prima ediție (ECMA-262) Definiția „Tipului de operator” este î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
	Chrome	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	Chrome Sprijin deplin 1	Margine Sprijin deplin 12	Firefox Sprijin deplin 1	I.E. Sprijin deplin 3	Operă Sprijin deplin Da	Safari Sprijin deplin Da	WebView Android Sprijin deplin 1	Chrome Android Sprijin deplin 18	Firefox Android Sprijin deplin 4	Opera Android Sprijin deplin Da	Safari iOS Sprijin deplin Da	Samsung Internet Android Sprijin deplin 1.0	nodejs Sprijin deplin Da

Legendă

Sprijin deplin Sprijin deplin

Note specifice IE

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

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

Tabelul 14.5. Operatori logici

Descrierea operatorului

! NOT (inversie logică)

&& AND (înmulțire logică)

|| SAU (adăugare logică)

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

Operandul 1	Operandul 2

Tabelul 14.7. Rezultatele executării operatorului NOT

tip de operator get

Tastați operatorul get typeof returnează un șir care descrie tipul de date al operandului. Operandul al cărui tip doriți să-l cunoașteți este plasat după acest operator și cuprins între paranteze:

s = tipul("str");

Ca rezultat al executării acestei expresii, variabila s va conține șirul „șir” care indică tipul șirului.

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

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

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

Compatibilitatea tipului de date și conversia

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

Ce obțineți când adăugați două numere? Așa este - o altă valoare numerică. Ce se întâmplă dacă adaugi un număr și un șir? Este greu de spus... Aici JavaScript se confruntă cu problema tipurilor de date incompatibile ș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ă o adunare. 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 lui b într-o valoare numerică atunci când este adăugat la a; 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, în funcție de cazul specific. Valoarea adevărată va fi convertită în numărul 1 sau în șirul „1”, iar valoarea false va fi convertită în 0 sau „0” . În schimb, numărul 1 va fi convertit în adevărat, iar numărul 0 va fi convertit în fals. De asemenea, false va fi convertit în

Avem valorile null și nedefinit.

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

Se poate observa că JavaScript se luptă să execute corect chiar și expresiile prost scrise. Uneori, acest lucru funcționează, dar de cele mai multe ori totul nu funcționează așa cum a fost planificat și, în final, execuția scriptului Web este întreruptă din cauza detectării unei erori într-un loc complet diferit, pe o declarație absolut corectă. Prin urmare, este mai bine să evitați astfel de incidente.

Prioritatea operatorului

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

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 10 din sumă. Operatorii acestei expresii au aceeași prioritate și, prin urmare, sunt executați strict de la stânga la dreapta.

Acum luați în considerare această expresie:

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

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.

ÎN În general, principiul de bază pentru executarea tuturor operatorilor este următorul: operatorii cu o prioritate mai mare sunt executați mai întâi și abia apoi operatorii cu una mai mică. Operatorii cu aceeași prioritate sunt executați în ordinea în care apar (de la stânga la dreapta).

ÎN masă 14.9 listează toți operatorii pe care i-am studiat în ordinea descrescătoare a priorităților lor.

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

	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. Executarea necorespunzătoare a instrucțiunilor poate cauza erori greu de detectat, în care o expresie aparent absolut corectă produce un rezultat incorect.

Dar dacă trebuie să încălcăm ordinea normală de execuție a instrucțiunilor? Să folosim parantezele. Când sunt scrise astfel, instrucțiunile cuprinse între paranteze sunt executate mai întâi:

a = (b + c) * 10;

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

Operatorii încadrați în paranteze sunt, de asemenea, supuși priorității. Acesta este motivul pentru care sunt adesea folosite mai multe paranteze imbricate:

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

Aici operatorii vor fi executați în următoarea secvență:

1. Adunarea lui 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. Adăugând 9 la coeficient.

Dacă eliminați parantezele:

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

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

1. Înmulțind c și 10.

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

3. Adunarea lui b și produsul lui c și 10.

4. Scăzând câtul din împărțire din suma rezultată d cu 2.

5. Adăugați 9 la diferența rezultată.

Se dovedește un rezultat complet diferit, nu-i așa?

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

Următoarele note 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).

În practică, acest lucru este incomod în JavaScript. Deci, dezvoltatorii ES 5.1 vor face ceva mai intuitiv: typeof null === "null" .

Dar, din moment ce încă avem ES3 peste tot, nu vă înșelați, de exemplu, cu 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 de înveliș (typeof new Number(5) === „obiect”).

3. Și nu uitați de dreptul browserelor de a face tot ce doresc cu obiectele gazdă.

Nu fi surprins că Safari consideră că HTMLCollection este un tip de funcție, iar IE, mai devreme decât versiunea 9, păstrează 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 să îi răspundă cu obiect.

toString()

Încercarea de a afla tipul unei valori din rezultatul metodei sale toString() este inutilă. În toate „clasele” această metodă este înlocuită cu propria ei.

Metoda este bună pentru afișarea informațiilor de depanare, dar nu poate fi folosită pentru a determina tipul unei variabile.

Object.prototype.toString()

Deși toString este suprascris în anumite „clase”, î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 ușurează această oboseală

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

Pentru tipurile scalare, returnează , , , .

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

Metoda eșuează pe null și nedefinit. Se întorc diferite browsere, uneori de așteptat și alteori, uneori în general. Cu toate acestea, puteți determina cu ușurință tipul acestor două valori fără acest lucru.

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

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

• {} —
• —
• Data -
• Eroare -
• RegExp -

Singurul lucru este că iese din lista de argumente, care este fie .
Lucrurile se înrăutățesc din nou cu obiectele gazdă.

În IE, obiectele DOM au început să devină obiecte „normale” doar din versiunea 8 și chiar și atunci nu complet. Prin urmare, în IE 6-8, toate aceste obiecte (HTMLCOllection, DOMElement, TextNode, precum și document și window) sunt pur și simplu reduse la .

Î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 este acolo, atunci . fereastra - apoi, apoi, atunci. Dar poți încerca deja să scoți ceva din asta.

Este mai complicat cu DOMElement: este afișat sub formă, - un format diferit pentru fiecare etichetă. Dar sezonul regulat ne va ajuta și aici.

Povestea este aproximativ aceeași cu alte obiecte gazdă (în testele de locație și navigator). Peste tot, cu excepția IE, ele pot fi identificate prin linie.

Dezavantaje ale utilizării Object.prototype.toString():

1. Această posibilitate nu este acoperită de standard. Și aici ar trebui mai degrabă să fim fericiți că totul funcționează atât de bine, decât să ne plângem de unele dintre deficiențe.

2. Determinarea unui tip prin parsarea unui șir returnat printr-o metodă care nu este folosită deloc pentru a determina un tip, și este numită și pe un obiect căruia nu se aplică, lasă niște sedimente în suflet.

3. În vechiul IE, după cum puteți vedea, este normal să nu identificați obiectele gazdă.

Cu toate acestea, acesta este un lucru complet funcțional atunci când este utilizat împreună cu alte mijloace.

Constructorii

Și în sfârșit, designerii. 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.

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

(5).constructor === Număr;

(Număr .NaN ) .constructor === Număr ;

(adevărat).constructor === Boolean;

5 instanță de Număr;

// false Number .NaN instanceof Number ;

// false adevărată instanță booleană;

// instanță „șir” falsă a String ;

// fals

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

(instanceof va funcționa pentru noul îndelungat număr (5))

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

console.log ( (funcție () ( ) ) instanceof Funcție );

// true console.log ( (funcție () ( ) ).constructor === Funcție ) ;

// adevărat

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

Toate obiectele claselor încorporate sunt, de asemenea, ușor identificate de constructorii lor: Array, Date, RegExp, Error.

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

Și al doilea este cu Object în sine, sau mai degrabă, cum să îi atribui un obiect creat printr-un constructor personalizat.

Astfel, puteți defini doar obiectul de bază: obj instanceof Object; Una dintre opțiunile de definire este să parcurgeți toate celelalte tipuri posibile (Matrice, Eroare...) și dacă niciunul nu se potrivește - „obiect”.

Constructori și obiecte gazdă

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

Să începem cu faptul că IE până la versiunea 7 inclusiv nu le consideră deloc obiecte normale. Pur și simplu nu au designeri și prototipuri acolo (cel puțin un programator nu poate ajunge la ei).

Lucrurile sunt mai bune în alte browsere. Există constructori și îi puteți folosi pentru a determina clasa unei valori. Sunt chemați doar

browsere diferite

diferit. De exemplu, pentru HTMLCollection, constructorul va fi fie HTMLCollection, fie NodeList, fie chiar 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 la FireFox sub versiunea 10 și Opera sub 11. Constructorul de colecții este Object .
constructor.nume

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

Niciuna dintre metodele prezentate nu oferă o determinare 100% a tipului/clasei unei valori în toate browserele. Cu toate acestea, luate împreună, fac posibil acest lucru.

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