Dinamiskā tipa identifikācija

Dinamiskā tipa identifikācija (RTTI)ļauj noteikt objekta veidu izpildes laikā. Tas izrādās noderīgs dažādu iemeslu dēļ. Jo īpaši, atsaucoties uz bāzes klasi, jūs varat diezgan precīzi noteikt objekta veidu, kas pieejams no šīs saites. Dinamiskā tipa identifikācija ļauj arī iepriekš pārbaudīt, cik veiksmīga būs tipa apraide, novēršot nederīgu tipa apraides izņēmumu. Turklāt dinamiskā tipa identifikācija ir galvenā refleksijas sastāvdaļa.

Lai atbalstītu dinamisko tipu identificēšanu, C # nodrošina trīs atslēgvārdus: is, as un typeof. Katrs no šiem atslēgvārdiem ir apskatīts tālāk pēc kārtas.

Ir operators

Konkrēto objekta veidu var noteikt, izmantojot operatoru is. Tās vispārīgā forma ir parādīta zemāk:

izteiksme ir veids

kur izteiksme apzīmē atsevišķu izteiksmi, kas apraksta objektu, kura tips tiek pārbaudīts. Ja izteiksme ir saderīga tipa vai tāda paša veida kā pārbaudāmais veids, šīs darbības rezultāts ir patiess, pretējā gadījumā tas ir nepatiess. Tādējādi rezultāts ir patiess, ja izteiksmei vienā vai otrā formā ir pārbaudāms veids. Operators is definē abus veidus kā saderīgus, ja tie ir viena tipa vai ja tiek nodrošināta atsauces pārveidošana, iepakošana vai atstādīšana.

Tālāk ir sniegts operatora is izmantošanas piemērs:

Sistēmas izmantošana; nosaukumvieta ConsoleApplication1 (klase Pievienot () klase Summa: Pievienot () klase Programma (statiskā tukšums Galvenais () (Pievienot a = jauns Pievienot (); Sum s = jauns Sum (); ja (a ir Pievienot) Console.WriteLine ("Mainīgais a ir tipa Add "); if (s ir summa) Console.WriteLine (" S tips ir mantots no Add klases "); Console.ReadLine ();)))

Kā operators

Dažreiz tipa pārveidošana ir jāveic izpildlaikā, bet neveiciet izņēmumu, ja konvertēšana neizdodas, kas ir pilnīgi iespējams ar tipa apraidi. Šim nolūkam kalpo kā operators, kuram ir šāda vispārīgā forma:

izteiksme kā veids

kur izteiksme apzīmē vienu izteiksmi, kas jāpārvērš norādītajā tipā.

Ja šī pārveidošana ir veiksmīga, tiek atgriezta atsauce uz veidu; pretējā gadījumā - tukša atsauce. Operatoru kā var izmantot tikai atsauces pārveidošanai, identitātei, boksēšanai, atslēgšanai. Dažos gadījumos as operators var kalpot kā ērta alternatīva operatoram is. Kā piemēru apsveriet šādu programmu:

Sistēmas izmantošana; nosaukumvieta ConsoleApplication1 (klase Pievienot () klase Summa: Pievienot () klase Programma (static tukšums Galvenā () (Pievienot a = jauns Pievienot (); Sum s = new Sum ();) // Veikt tipa apraidi a = s kā Add; if ( a! = null) Console.WriteLine ("Reklāmguvums bija veiksmīgs"); cits Console.WriteLine ("Reklāmguvums neizdevās"); Console.ReadLine ();)))

Šīs programmas rezultāts būs veiksmīga konversija.

JavaScript vai Js(saīsināti) nav viegla valoda, un iesācēju izstrādātāji par to neuzzina uzreiz. Sākumā viņi apgūst pamatus un viss šķiet krāsains un skaists. Nedaudz iedziļinoties, parādās JavaScript masīvi, objekti, atzvani un tamlīdzīgi, ko smadzenes bieži vien izņem.

JavaScript ir svarīgi pareizi pārbaudīt mainīgā veidu. Pieņemsim, ka vēlaties uzzināt, vai mainīgais ir masīvs vai objekts? Kā to pareizi pārbaudīt? Šajā konkrētajā gadījumā pārbaudes laikā ir triki un par to arī būs šis ieraksts. Sāksim uzreiz.

Mainīgā veida pārbaude

Piemēram, jums ir jāpārbauda, ​​vai mainīgais ir objekts, masīvs, virkne vai skaitlis. Šim nolūkam varat izmantot typeof, taču tas ne vienmēr sniegs patiesību, un zemāk esošajā piemērā es parādīšu, kāpēc.

Es uzrakstīju šo piemēru, lai ilustrētu, kāpēc veids ne vienmēr ir pareizā izvēle.

Var _comparison = (virkne: "virkne", int: 99, float: 13.555, objekts: (sveiki: "sveiki"), masīvs: jauns masīvs (1, 2, 3)); // Atgriež masīvu ar objektu atslēgām var _objKeys = Object.keys (_comparison); for (var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Koda izpildes rezultāts:

Virknes numurs numurs objekta objekts

Taisnība? - Protams, nē. Ir divas problēmas. Katrs no tiem tiks detalizēti aprakstīts un piedāvāts risinājums.

Pirmā problēma: peldošais skaitlis, izvade kā skaitlis

Comparison.float nav skaitlis, un tam ir jābūt peldošam, nevis skaitlim. Lai to labotu, varat izveidot funkciju ar validāciju, kā norādīts tālāk norādītajā kodā.

Var _floatNumber = 9,22; var _notFloatNumber = 9; console.log (isFloat (_floatNumber)); console.log (isFloat (_notFloatNumber)); console.log (isFloat ("")); funkcija isFloat (n) (atgriež Skaitlis (n) === n && n% 1! == 0;)

Funkcija isFloat () pārbauda visas peldošā komata skaitļu vērtības. Pirmkārt, tas pārbauda, ​​vai mainīgais ir vienāds ar n skaitlis (numurs (n) === n) un ja tā, tad tiek veikta vēl viena pārbaude dalīšanai ar atlikumu, un, ja ir atlikums, tad Būla ( taisnība vai viltus) rezultāts (n% 1! == 0).

Iepriekš minētajā piemērā tas atgriežas taisnība, viltus un viltus... Pirmā nozīme ir peldēt tipa, otrais nav - tas ir parasts skaitlis, un pēdējais ir tikai tukša virkne, kas neatbilst noteikumiem.

Otrā problēma: masīvs tika definēts kā objekts

Pirmajā piemērā masīvs tika parādīts kā objekts, un tas nav īpaši labi, jo dažreiz jums ir jāizmanto šis konkrētais veids un nekas cits.

Ir vairāki veidi, kā pārbaudīt mainīgo masīva tipam.

Pirmais variants (labs variants). Mēs pārbaudām, vai dati pieder masīvam, izmantojot instanceof ().

Var dati = jauns masīvs ("sveiki", "pasaule"); var isArr = masīva datu instance;

Otrais variants (labs variants). Metode Array.isArray () atgriež Būla vērtību, kas būs atkarīga no tā, vai mainīgais ir masīvs vai nav ().

Var dati = jauns masīvs ("sveiki", "pasaule"); var isArr = Array.isArray (dati);

Trešais variants (labākais, bet garākais). Ērtības labad varat to padarīt par funkciju. Izmantojot objektu, mēs to darām. Ja objekta Object.prototype.toString.call (dati) rezultāts nav vienāds, mainīgais nav masīvs ().

Var dati = jauns masīvs ("sveiki", "pasaule"); var isArr = Object.prototype.toString.call (data) == ""; console.log (isArr);

Pēdējais rezultāts kā ērtības funkcija:

Funkcija isArray (data) (atgriezt Object.prototype.toString.call (data) == "")

Tagad jūs varat izsaukt funkciju isArray () un iestatīt masīvu vai kaut ko citu kā argumentu un redzēt rezultātu.

Pēcvārds

Ieraksts izrādījās diezgan liels, nekā sākotnēji bija paredzēts. Bet es esmu apmierināts ar to, jo tajā īsi un skaidri aprakstītas grūtības, pārbaudot mainīgos JavaScript un kā tās apiet.

Ja jums joprojām ir kādi jautājumi - rakstiet tos zem šī ieraksta. Es labprāt palīdzēšu.

a = (b> 0) && (c + 1! = d); karogs =! (statuss = 0);

14.5. tabula. Loģiskie operatori

Operatora apraksts

! NAV (loģiskā inversija)

&& UN (loģiskā reizināšana)

|| VAI (loģisks papildinājums)

14.6. tabula. UN un OR operatoru izpildes rezultāti

Operands 1	Operands 2

14.7. tabula. Paziņojuma NOT rezultāti

Iegūstiet operatora veidu

Get Type Operator typeof atgriež virkni, kas apraksta operanda datu tipu. Operands, kura veidu vēlaties uzzināt, ir novietots aiz šī operatora un ievietots iekavās:

s = typeof ("str");

Šīs izteiksmes rezultātā mainīgajā s būs virkne "string", kas apzīmē virknes veidu.

Visas vērtības, kuras var atgriezt operatora veids, ir norādītas tabulā. 14.8.

	14.8. tabula. Operatora veida atgrieztās vērtības
Datu tips		Atgriezta virkne
Stīga
Skaitlisks

			14.8. tabula (beigas)
	Datu tips	Atgriezta virkne
	Loģiski

Datu tipu saderība un konvertēšana

Tagad ir pienācis laiks apsvērt vēl divus svarīgus jautājumus: datu tipu saderību un pārveidošanu no viena veida uz citu.

Kas notiek, ja pievienojat divus skaitļus? Tieši tā – vēl viena skaitliska vērtība. Un ja pievienojat skaitli un virkni? Grūti pateikt... Šeit JavaScript saskaras ar datu tipu nesaderības problēmu un mēģina šos tipus padarīt saderīgus, pārvēršot vienu no tiem citā. Vispirms tas mēģina pārvērst virkni par skaitli un, ja tas izdodas, veic pievienošanu. Ja tas neizdodas, skaitlis tiks pārveidots par virkni un abas iegūtās virknes tiks savienotas. Piemēram, izpildot Web skriptu sarakstā 14.6, b vērtība tiks pārveidota par ciparu tipu, kad tā tiks pievienota a; tādējādi mainīgais c saturēs vērtību 23.

Uzskaitījums 14.6

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

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

d = "JavaScript"; e = 2;

Bet tā kā d vērtību nevar pārvērst par skaitli, e vērtība tiks pārvērsta virknē, un rezultāts - f vērtība - kļūs

Būla vērtības pēc vajadzības tiek pārveidotas par skaitliskām vai virknes vērtībām. True tiks pārveidots par skaitli 1 vai virkni "1", un false tiks pārveidots par 0 vai "0". Un otrādi, skaitlis 1 tiks pārvērsts par patiesu, un skaitlis 0 tiks pārvērsts par nepatiesu. Tiks pārveidots arī false

vērtības ir nulles un nenoteiktas.

	III daļa. Web lapu uzvedība. Tīmekļa skripti

Var redzēt, ka JavaScript cīnās, lai pareizi izpildītu pat nepareizi rakstītās izteiksmes. Dažreiz tas darbojas, bet biežāk viss nedarbojas kā plānots, un galu galā Web skripta izpilde tiek pārtraukta, jo tiek atklāta kļūda pilnīgi citā vietā, pie absolūti pareizā operatora. Tāpēc labāk šādus incidentus nepieļaut.

Operatora prioritāte

Pēdējais jautājums, ko mēs šeit aplūkosim, ir operatora prioritāte. Kā mēs atceramies, prioritāte ietekmē paziņojumu izpildes secību izteiksmē.

Lai ir šāda izteiksme:

Šajā gadījumā vispirms mainīgā b vērtībai tiks pievienota c vērtība, bet pēc tam no summas tiks atņemta 10. Šīs izteiksmes operatoriem ir vienāda prioritāte, un tāpēc tie tiek izpildīti stingri no kreisās uz labo pusi.

Tagad apsveriet šādu izteicienu:

Šeit, pirmkārt, c vērtība tiks reizināta ar 10, un tikai pēc tam vērtība b tiks pievienota iegūtajam reizinājumam. Reizināšanas operatoram ir prioritāte pār saskaitīšanas operatoru, tāpēc stingra secība no kreisās uz labo pusi nedarbosies.

Piešķiršanas operatoriem ir viszemākā prioritāte. Tāpēc vispirms tiek novērtēta pati izteiksme un pēc tam tās rezultāts tiek piešķirts mainīgajam.

V Kopumā visu operatoru izpildes pamatprincips ir šāds: vispirms tiek izpildīti operatori ar augstāku prioritāti un tikai pēc tam operatori ar zemāku prioritāti. Operatori ar vienādu prioritāti tiek izpildīti tādā secībā, kādā tie parādās (no kreisās uz labo).

V cilne. 14.9 ir uzskaitīti visi operatori, kurus mēs pētījām, dilstošā secībā pēc to prioritātes.

		14.9. tabula. Operatora prioritāte (dilstošā secībā)
	Operatori	Apraksts
	++ - - ~! veids	Pieaugums, samazinājums, zīmes maiņa, loģiskais NAV, tipa secinājums
		Reizināšana, dalīšana, ņemot atlikumu
		Virkņu saskaitīšana un savienošana, atņemšana
		Salīdzināšanas operatori
		Loģiski UN

	14. nodaļa. Ievads tīmekļa programmēšanā. JavaScript valoda
			14.9. tabula (beigas)
	Operatori	Apraksts
		Loģiski VAI
		Nosacīts operators (skatīt zemāk)
	= <оператор>=	Uzdevums, vienkāršs un sarežģīts

UZMANĪBU!

Atcerieties šo tabulu. Nepareiza paziņojuma izpildes secība var novest pie grūti pamanāmām kļūdām, kurās šķietami absolūti pareiza izteiksme dod nepareizu rezultātu.

Bet ko darīt, ja mums ir nepieciešams pārkāpt parasto paziņojumu izpildes kārtību? Izmantosim iekavas. Izmantojot šo apzīmējumu, iekavās pievienotie paziņojumi tiek izpildīti vispirms:

a = (b + c) * 10;

Šeit vispirms tiks veikta mainīgo b un c vērtību saskaitīšana, un pēc tam iegūtā summa tiks reizināta ar 10.

Iekavās ievietotajiem operatoriem arī ir prioritāte. Tāpēc bieži tiek izmantotas vairākas ligzdotas iekavas:

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

Šeit paziņojumi tiks izpildīti šādā secībā:

1. Papildinājums b un c.

2. Iegūto summu reiziniet ar 10.

3. d atņemšana no reizinājuma.

4. Dalot starpību ar 2.

5. Pievienojiet koeficientam 9.

Ja noņemat kronšteinus:

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

tad operatoru izpildes secība būs šāda:

1. C un 10 reizināšana.

2. d dalīšana ar 2.

3. Papildinājums b un produkti c un 10.

4. Dalīšanas koeficienta atņemšana no iegūtās summas d pa 2.

5. Iegūtajai starpībai pievienojot 9.

Rezultāts ir pavisam cits, vai ne?

• Nedefinēts: "nedefinēts"
• Null: "objekts"
• Būla: "būla"
• Skaitlis: "numurs"
• Virkne: "string"
• Funkcija: "funkcija"
• Viss pārējais: "objekts"

Šai tabulai jāpievieno šādas piezīmes:

1. typeof null === "objekts".

Teorētiski tas ir smalks punkts. Statiski drukātajās valodās objekta tipa mainīgais nedrīkst saturēt objektu (NULL, nil, null pointer).

Praksē tas ir neērti JavaScript. Tāpēc ES 5.1 izstrādātāji gatavojas darīt intuitīvāku darbību: typeof null === "null".

Bet, tā kā mums līdz šim ir ES3, nekļūdieties, piemēram, šajā:

/ * Funkcija meklē kādu objektu un atgriež to vai nulli, ja nekas netiek atrasts * / funkcija meklēt () () var obj = meklēt (); if (obj tips === "objekts") (// vai mēs tiešām atradām objektu (FAIL) obj.method ();)

2. Neaizmirstiet par iesaiņojuma objektiem (jaunā numura veids (5) === "objekts").

3. Un neaizmirstiet par pārlūkprogrammu tiesībām darīt jebko ar resursdatora objektiem.

Nebrīnieties, ka Safari spītīgi domā, ka HTMLCollection ir funkcijas veids, un IE pirms 9. versijas saglabāja mūsu iecienītāko brīdinājuma () funkciju kā objektu. Arī pārlūks Chrome agrāk uzskatīja RegExp kā funkciju, bet tagad šķiet, ka tas to ir sajutis un reaģē uz to ar objektu.

toString ()

Mēģinājums noskaidrot vērtības veidu no tās metodes toString () rezultāta ir bezjēdzīgs. Visās "klasēs" šī metode tiek definēta no jauna.

Metode ir piemērota atkļūdošanas informācijas parādīšanai, taču ar to nevar noteikt mainīgā veidu.

Object.prototype.toString ()

Lai gan toString ir pārdefinēts konkrētās "klasēs", mums joprojām ir tā sākotnējā ieviešana no Object. Mēģināsim to izmantot:

console.log (Object .prototype .toString .call (vērtība));

console.log (Object.prototype.toString.call (vērtība));

Klintone šo slogu mazina

Ironiski, šī metode darbojas pārsteidzoši labi.

Skalārajiem veidiem atgriež,,,.

Smieklīgākais ir tas, ka atgriežas pat jauns numurs (5), kura veids šeit neizdevās.

Metode neizdodas nulles un nenoteiktas vērtības gadījumā. Atgriežas dažādas pārlūkprogrammas, dažreiz gaidītas un dažreiz vispār. Tomēr bez tā ir viegli noteikt šo divu vērtību veidu.

Jautrība sākas, kad mēs nonākam pie objektiem (tiem, kuru tips === "objekts").

iebūvētie objekti praktiski izdodas ar triecienu:

• {} —
• —
• Datums -
• Kļūda -
• RegExp —

Vienīgais, kas izkrīt no argumentu saraksta, ir tas, ka tad.
Ar saimniekobjektiem viss atkal kļūst sliktāks.

IE vidē DOM objekti sāka kļūt par "parastiem" objektiem tikai no 8. versijas, un tad ne līdz galam. Tāpēc IE 6-8 visi šie objekti (HTMLCOllection, DOMElement, TextNode un kopā ar dokumentu un logu) tiek pārveidoti vienkārši.

Visās citās pārlūkprogrammās (ieskaitot IE9) jau var kaut ko darīt ar toString rezultātu. Lai gan arī viss nav viegli: tad ir HTMLCollection. logs - tad, tad, tad. Bet jūs jau varat mēģināt kaut ko no tā iegūt.

Ar DOMElement tas ir grūtāk: tas tiek parādīts kā, - katram tagam savs formāts. Bet šeit mums palīdzēs regulārā sezona.

Stāsts ir apmēram tāds pats ar citiem resursdatora objektiem (atrašanās vietas un navigatora testos). Visur, izņemot IE, tos var identificēt pēc virknes.

No Object.prototype.toString lietošanas mīnusiem ():

1. Šī iespēja netiek svētīta ar standartu. Un te drīzāk jāpriecājas, ka viss darbojas tik labi, nevis jāžēlojas par kādiem trūkumiem.

2. Tipa noteikšana, parsējot virkni, kas atgriezta ar metodi, kas nepavisam nav paredzēta tipa noteikšanai, un tiek izsaukta arī objektā, kuram tas nepieder, atstāj zināmu atlikumu dvēselē.

3. Vecajā IE, kā redzat, resursdatora objekti parasti netiek identificēti.

Tomēr, ja to izmanto kopā ar citiem instrumentiem, tas ir diezgan kvalitatīvs.

Konstruktori

Un visbeidzot, konstruktori. Kurš gan labāk lai saka par objekta "klasi" JS, ja ne tā konstruktors?

Null un undefined nav ne iesaiņojuma objektu, ne konstruktoru.

Pārējiem skalārajiem veidiem ir iesaiņojumi, attiecīgi, jūs varat iegūt konstruktoru:

(5) .constructor === Skaitlis; (Numurs .NaN) .konstruktors === Skaitlis; (patiess) .constructor === Būla; ("virkne") .constructor === Virkne;

(5) .constructor === Skaitlis; (Numurs.NaN) .constructor === Skaitlis; (patiess) .constructor === Būla; ("virkne"). konstruktors === Virkne;

Bet instanceof šeit nedarbosies:

5 instanceof Number; // false Number .NaN instanceof Number; // viltus patiesa Būla instance; // nepatiesa "string" instanceof String; // viltus

5 instanceof Number; // false Number.NaN instanceof Number; // viltus patiesa Būla instance; // nepatiesa "string" instanceof String; // viltus

(piemērs strādās ilgi cietušajam jaunajam numuram (5))

Izmantojot funkcijas (kas arī ir objekti), instanceof nodos:

console.log ((funkcija () ()) instanceof Function); // true console.log ((funkcija () ()) .constructor === Funkcija); // taisnība

console.log ((funkcija () ()) instanceof Function); // true console.log ((funkcija () ()). konstruktors === Funkcija); // taisnība

Visus iebūvēto klašu objektus viegli identificē arī to konstruktori: Array, Date, RegExp, Error.

Šeit rodas viena problēma ar argumentiem, kuru konstruktors ir objekts.

Un otrs ar pašu Objektu, vai drīzāk, kā uz to atsaukties uz objektu, kas izveidots, izmantojot pielāgotu konstruktoru.

Tikai pamata objektu var definēt šādi:

obj instanceof Object;

Kā viens no definīcijas variantiem - atkārtot visus citus iespējamos veidus (Array, Error ...) un, ja neviens neatbilst - "objekts".

Konstruktori un saimniekobjekti

Ar saimniekobjektiem lietas kļūst sliktākas.

Sāksim ar to, ka IE līdz 7. versijai ieskaitot tos vispār neuzskata par normāliem objektiem. Viņiem tur vienkārši nav konstruktoru un prototipu (katrā ziņā programmētājs tos nevar sasniegt).

Citas pārlūkprogrammas darbojas labāk. Ir konstruktori, un jūs varat tos izmantot, lai noteiktu vērtību klasi. Tikai tos dažādās pārlūkprogrammās sauc atšķirīgi. Piemēram, HTMLCollection konstruktors būs vai nu HTMLCollection, vai NodeList, vai pat NodeListConstructor.

Jums arī jādefinē DOMElement bāzes konstruktors. FF valodā tas ir, piemēram, HTMLElement, no kura HTMLDivElement un citi jau ir mantoti.

FireFox zem versijas 10 un Opera zem versijas 11 rada palaidnību.Tur kolekcijas konstruktors ir Object.

konstruktors.nosaukums

Konstruktoriem ir arī nosaukuma rekvizīts, kas var būt noderīgs.

Tas satur konstruktora funkcijas nosaukumu, piemēram, (5) .constructor.name === "Numurs".

Bet:
1. IE vispār nepastāv, pat 9..
2. Pārlūkprogrammas atkal visu veido Host-objektos (un bieži vien viņiem šī īpašība vispār nav). Operā DOMElement parasti ir konstruktora nosaukums Function.prototype.
3. argumenti atkal ir "objekts".

secinājumus

Neviena no piedāvātajām metodēm nesniedz simtprocentīgu vērtības veida / klases definīciju visās pārlūkprogrammās. Tomēr kopā tie ļauj jums to izdarīt.

Tuvākajā laikā mēģināšu apkopot visus datus tabulās un sniegt piemēru definējošai funkcijai.

Operators veids atgriež virkni, kas norāda operanda veidu.

Sintakse

Operandam seko operatora veids:

Tipsof operands

Iespējas

operands ir izteiksme, kas attēlo objektu vai primitīvu, kura tips ir jāatgriež.

Apraksts

Nākamajā tabulā ir norādītas iespējamās tipa atgriešanas vērtības. Plašāka informācija par veidiem un primitīviem ir lapā.

Piemēri

// Skaitļu tips 37 === "skaitlis"; typeof 3.14 === "skaitlis"; typeof (42) === "skaitlis"; typeof Math.LN2 === "skaitlis"; bezgalības veids === "skaitlis"; tips NaN === "skaitlis"; // pat ja tas ir "Not-A-Number" tipa Skaitlis (1) === "numurs"; // nekad neizmantojiet šo ierakstu! // Strings typeof "" === "virkne"; "bla" veids === "virkne"; tips "1" === "virkne"; // ņemiet vērā, ka skaitlis virknē joprojām ir tipa string typeof (typeof 1) === "string"; // typeof vienmēr atgriezīs virkni šajā gadījumā typeof String ("abc") === "string"; // nekad neizmantojiet šo ierakstu! // Būla tips true === "būla"; typeof false === "būla"; typeof Būla (patiess) === "būla"; // nekad neizmantojiet šo ierakstu! // Symbols typeof Symbol () === "simbols" typeof Symbol ("foo") === "simbols" typeof Symbol.iterator === "simbols" // Undefined typeof undefined === "nenodefinēts"; typeof deklaredButUndefinedVariable === "nenodefinēts"; typeof undeclaredVariable === "nenodefinēts"; // Objektu tips (a: 1) === "objekts"; // izmantojiet Array.isArray vai Object.prototype.toString.call //, lai atšķirtu parastos objektus un masīvus typeof === "object"; typeof new Datums () === "objekts"; // Tālāk norādītais rada kļūdas un problēmas. Nelietojiet! typeof new Būla (true) === "objekts"; typeof new Skaitlis (1) === "objekts"; typeof new String ("abc") === "objekts"; // Funkcijas typeof function () () === "funkcija"; C klases veids () === "funkcija"; typeof Math.sin === "funkcija";

null

// Tas ir definēts kopš dzimšanas JavaScript typeof null === "object";

Pirmajā JavaScript ieviešanā vērtības tika attēlotas ar taga veida un vērtību pāri. Objektu tagu tips bija 0. Nulle tika attēlota kā nulles rādītājs (0x00 lielākajā daļā platformu). Tādējādi nulles taga tips bija nulle, tāpēc typeof atgriešanas vērtība ir viltota. ()

ECMAScript tika ieteikts labojums (izmantojot atspējošanu), taču tas tika noraidīts. Tā rezultātā typeof null === "null".

Izmantojot jauno operatoru

// Visas konstruktora funkcijas, kas izveidotas ar "new", būs tipa "object" var str = new String ("String"); var num = jauns Skaitlis (100); str tips; // Atgriež "object" typeof num; // Atgriež "objektu" // Bet ir izņēmums funkciju konstruktoram var func = new Function (); funkcijas veids; // Atgriež "funkciju"

Regulāras izteiksmes

Izsaucamās regulārās izteiksmes dažās pārlūkprogrammās bija nestandarta papildinājums.

Typeof / s / === "funkcija"; // Chrome 1-12 Nav saderīgs ar ECMAScript 5.1 typeof / s / === "object"; // Saderīgs ar Firefox 5+ ECMAScript 5.1

Kļūdas, kas saistītas ar pagaidu mirušajām zonām

Pirms ECMAScript 2015 operatora tipam tika garantēts, ka tas atgriezīs virkni jebkuram operandam, ar kuru tas tika izsaukts. Tas mainījās, pievienojot bloka darbības jomas bez pacelšanas let un const deklarācijas. Tagad, ja mainīgie tiek deklarēti ar let un const, un tie tiek izsaukti typeof mainīgo deklarācijas blokā, bet pirms deklarācijas, tad tiek iemesta ReferenceError. Uzvedība atšķiras no nedeklarētajiem mainīgajiem, kuriem typeof atgriezīsies "undefined". Bloku darbības jomas mainīgie atrodas "īslaicīgā mirušajā zonā", kas ilgst no bloka sākuma līdz mainīgā deklarēšanai. Šajā zonā mēģinājums piekļūt mainīgajiem rada izņēmumu.

Typeof undeclaredVariable === "nenodefinēts"; typeof newLetVariable; let newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "sveiki"; // Atsauces kļūda

Izņēmumi

Visām pašreizējām pārlūkprogrammām ir nestandarta document.all resursdatora objekts, kura tips ir Undefined.

Typeof document.all === "nenodefinēts";

Lai gan specifikācija pieļauj pielāgotus tipu nosaukumus nestandarta eksotiskiem objektiem, šiem nosaukumiem ir jāatšķiras no iepriekš definētajiem. Situācija, kad dokuments.viss nav definēts, jāuzskata par ārkārtēju noteikumu pārkāpumu.

Specifikācijas (rediģēt)

Specifikācija	Statuss	Komentāri (1)
ECMAScript jaunākais melnraksts (ECMA-262)	Melnraksts
ECMAScript 2015 (6. izdevums, ECMA-262) "Operatora veida" definīcija šajā specifikācijā.	Standarta
ECMAScript 5.1 (ECMA-262) "Operatora veida" definīcija šajā specifikācijā.	Standarta
ECMAScript 3rd Edition (ECMA-262) "Operatora veida" definīcija šajā specifikācijā.	Standarta
ECMAScript 1st Edition (ECMA-262) "Operatora veida" definīcija šajā specifikācijā.	Standarta	Sākotnējā definīcija. Ieviests JavaScript versijā 1.1

Pārlūka saderība

Atjauniniet saderības datus vietnē GitHub

	Datori						Mobilais						Serveris
	Chrome	Mala	Firefox	Internet Explorer	Opera	Safari	Android tīmekļa skats	Chrome Android ierīcēm	Firefox operētājsistēmai Android	Opera operētājsistēmai Android	Safari operētājsistēmā iOS	Samsung internets	Node.js
veids	Chrome Pilns atbalsts 1	Mala Pilns atbalsts 12	Firefox Pilns atbalsts 1	IE Pilns atbalsts 3	Opera Pilns atbalsts Jā	Safari Pilns atbalsts Jā	WebView Android Pilns atbalsts 1	Chrome Android Pilns atbalsts 18	Firefox Android Pilns atbalsts 4	Opera Android Pilns atbalsts Jā	Safari iOS Pilns atbalsts Jā	Samsung interneta Android Pilns atbalsts 1.0	nodejs Pilns atbalsts Jā

Leģenda

Pilns atbalsts Pilns atbalsts

IE īpašas piezīmes

IE 6, 7 un 8 daudzi resursdatora objekti ir objekti, bet ne funkcijas. Piemēram.