Dinamikus típusazonosítás

Dinamikus típusazonosító (RTTI) lehetővé teszi egy objektum típusának meghatározását a program végrehajtása során. Számos okból hasznosnak bizonyul. Különösen egy alaposztályra való hivatkozás használatával elég pontosan meghatározhatja az ezen a hivatkozáson keresztül elérhető objektum típusát. A dinamikus típusazonosítás azt is lehetővé teszi, hogy előre ellenőrizni tudja, mennyire lesz sikeres egy típusdobás, így elkerülhető a hibás típusdobás miatti kivétel. Ezenkívül a dinamikus típusazonosítás a reflexió egyik fő összetevője.

A dinamikus típusazonosítás támogatására a C# hármat biztosít kulcsszavakat a: is, as és typeof. Ezeket a kulcsszavakat az alábbiakban sorra tárgyaljuk.

az operátor

Egy objektum konkrét típusa az is operátorral határozható meg. Alább látható az általános formája:

kifejezés típus

ahol a kifejezés egyetlen kifejezést jelöl, amely leírja azt az objektumot, amelynek típusát teszteljük. Ha a kifejezés kompatibilis vagy ugyanolyan típusú, mint a tesztelt típus, akkor ennek a műveletnek az eredménye igaz, ellenkező esetben hamis. Így az eredmény akkor lesz igaz, ha a kifejezés ilyen vagy olyan formában a tesztelt típusú. Az is operátorban mindkét típus kompatibilis, ha azonos típusúak, vagy ha referenciakonverzió, dobozolás vagy unboxing biztosított.

Az alábbiakban egy példa az is operátor használatára:

Rendszer használata; névtér ConsoleApplication1 ( class Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); if (a az Add) Console.WriteLine("Változó a típusa Add"); if (s összeg) Console.WriteLine("Az s változó típusa az Add osztályból öröklődik"); Console.ReadLine(); ) ) )

Üzemeltető mint

Néha futás közben szeretne típuskonverziót végrehajtani, de nem kell kivételt tenni, ha az átalakítás meghiúsul, ami típusöntéssel teljesen lehetséges. Ezt a célt szolgálja az as operátor, amelynek általános formája a következő:

kifejezés típusként

ahol a kifejezés egyetlen kifejezést jelöl, amely a megadott típusra konvertál.

Ha egy ilyen átalakítás eredménye sikeres, akkor a típusra való hivatkozás kerül visszaadásra, ellenkező esetben üres hivatkozás. Az as operátor csak referencia konvertálásra, identitásra, dobozolásra, kicsomagolásra használható. Bizonyos esetekben az as operátor kényelmes alternatívája lehet az is operátornak. Példaként tekintsük a következő programot:

Rendszer használata; névtér ConsoleApplication1 ( class Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); // Hajtsa végre az a = s típusú öntést Addként; if (a != null) Console.WriteLine("A konverzió sikeres volt"); else Console.WriteLine("Hiba az átalakítás során"); Console.ReadLine(); ) ) )

A program végrehajtásának eredménye egy sikeres átalakítás.

a = (b > 0) && (c + 1 != d); zászló = !(állapot = 0);

14.5. táblázat. Logikai operátorok

Üzemeltető leírása

! NEM (logikai inverzió)

&& ÉS (logikai szorzás)

|| VAGY (logikai kiegészítés)

14.6. táblázat. AND és OR operátorok végrehajtásának eredményei

1. operandus	2. operandus

14.7. táblázat. A NOT operátor végrehajtásának eredménye

típusú get operátor

Írja be a get operátort A typeof egy karakterláncot ad vissza, amely leírja az operandus adattípusát. Az operandus, amelynek típusát szeretné tudni, ez az operátor után kerül zárójelbe:

s = typeof("str");

A kifejezés végrehajtásának eredményeként az s változó tartalmazza a "string" karakterláncot, amely a karakterlánc típusát jelzi.

Minden visszaadható érték operátor típusa táblázatban vannak felsorolva. 14.8.

	14.8. táblázat. Az operátor típusa által visszaadott értékek
Adattípus		Visszatérési karakterlánc
Húr
Számszerű

			14.8. táblázat (vége)
	Adattípus	Visszatérési karakterlánc
	Logikus

Adattípus-kompatibilitás és átalakítás

Itt az ideje, hogy fontolóra vegyük még két fontos kérdést: az adattípusok kompatibilitását és az egyik típusból a másikba való átalakítást.

Mit kapsz, ha két számértéket adsz össze? Így van – egy másik számérték. Mi van, ha hozzáad egy számot és egy karakterláncot? Nehéz megmondani... Itt a JavaScript az inkompatibilis adattípusok problémájával néz szembe, és megpróbálja kompatibilissé tenni ezeket a típusokat úgy, hogy az egyiket egy másikra konvertálja. Először megpróbálja számmá alakítani a karakterláncot, és ha sikeres, összeadást hajt végre. Ha nem sikerül, a számot karakterláncsá alakítja, és a kapott két karakterláncot összefűzi. Például a webszkript futtatása a 14.6-os listában a b értékét numerikus értékké alakítja, ha hozzáadja a-hoz; így a c változó a 23 értéket fogja tartalmazni.

Felsorolás 14.6

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

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

d="JavaScript"; e = 2;

De mivel a d változó értéke nem konvertálható számmá, ezért e értéke karaktersorozattá alakul, és az eredmény - f értéke - egyenlő lesz

A logikai értékeket a rendszer numerikus vagy karakterlánc-értékekké alakítja, az adott esettől függően. A true érték 1-es számra vagy "1" karakterláncra, a false érték pedig 0-ra vagy "0"-ra lesz konvertálva. Ezzel szemben az 1-es szám igaz, a 0 pedig hamis lesz. A false is át lesz konvertálva erre

Nálunk nulla és meghatározatlan értékeink vannak.

	rész III. Weboldal viselkedése. Web szkriptek

Látható, hogy a JavaScript még a rosszul megírt kifejezéseket is nehezen tudja helyesen végrehajtani. Néha ez működik, de legtöbbször nem minden a tervek szerint működik, és a végén a webszkript végrehajtása megszakad egy teljesen más helyen észlelt hiba miatt, egy teljesen helyes utasításra. Ezért jobb elkerülni az ilyen eseményeket.

Üzemeltetői elsőbbség

Az utolsó kérdés, amelyet itt megvizsgálunk, az operátori elsőbbség. Mint emlékszünk, az elsőbbség befolyásolja a kifejezés operátorainak végrehajtási sorrendjét.

Legyen a következő kifejezés:

Ebben az esetben először a b változó értékéhez hozzáadjuk a c értéket, majd az összegből kivonjuk a 10-et.. A kifejezés operátorai azonos prioritásúak, ezért szigorúan balról jobbra hajtódnak végre.

Most nézzük meg ezt a kifejezést:

Itt először a c értéket megszorozzuk 10-zel, és csak ezután adjuk hozzá a b értéket a kapott szorzathoz. A szorzó operátornak nagyobb a prioritása, mint az összeadás operátornak, így a "szigorúan balról jobbra" sorrend megszakad.

A hozzárendelési operátoroknak van a legalacsonyabb prioritása. Ezért először magát a kifejezést értékeli ki, majd az eredményét egy változóhoz rendeli.

BAN BEN Általánosságban elmondható, hogy az összes operátor végrehajtásának alapelve a következő: először a magasabb prioritású operátorokat hajtják végre, és csak azután az alacsonyabb prioritású operátorokat. Az azonos prioritású operátorok a megjelenésük sorrendjében (balról jobbra) végrehajtásra kerülnek.

BAN BEN asztal A 14.9 felsorolja az összes általunk vizsgált operátort prioritásuk csökkenő sorrendjében.

		14.9. táblázat. Operátori prioritás (csökkenő sorrendben)
	Üzemeltetők	Leírás
	++ -- - ~ ! típusú	Növekedés, csökkentés, előjelváltás, logikai NEM, típusdefiníció
		Szorzás, osztás, maradék
		Karakterláncok összeadása, összefűzése, kivonás
		Összehasonlító operátorok
		logikus ÉS

	14. fejezet Bevezetés a webprogramozásba. JavaScript nyelv
			14.9. táblázat (vége)
	Üzemeltetők	Leírás
		Logikus VAGY
		Feltételes nyilatkozat (lásd lent)
	= <оператор>=	Feladat, egyszerű és összetett

FIGYELEM!

Emlékezzen erre a táblázatra. Az utasítások nem megfelelő végrehajtása nehezen észlelhető hibákat okozhat, amelyekben a látszólag abszolút helyes kifejezés hibás eredményt ad.

De mi van akkor, ha meg kell törnünk az utasítás-végrehajtás normál sorrendjét? Használjunk zárójelet. Ha így írjuk, először a zárójelben lévő utasítások hajtódnak végre:

a = (b + c) * 10;

Itt először a b és c változók értékeit összeadjuk, majd a kapott összeget megszorozzuk 10-zel.

A zárójelben szereplő operátorok szintén elsőbbséget élveznek. Ezért gyakran használnak több beágyazott zárójelet:

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

Itt az operátorok a következő sorrendben kerülnek végrehajtásra:

1. b és c hozzáadása.

2. A kapott összeget megszorozzuk 10-zel.

3. d levonása a szorzatból.

4. Oszd el a különbséget 2-vel.

5. 9 hozzáadása a hányadoshoz.

Ha eltávolítja a zárójeleket:

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

akkor az operátorok végrehajtási sorrendje a következő lesz:

1. c és 10 szorzata.

2. Oszd el d-t 2-vel.

3. Adja hozzá a b-t és a c és 10-es terméket.

4. Kivonás az osztásból származó hányados összegéből d 2-vel.

5. 9 hozzáadásával a kapott különbséghez.

Teljesen más eredményt kap, igaz?

JavaScript vagy JS(röviden) nem könnyű nyelv, és a kezdő fejlesztők nem fogják azonnal megtanulni. Eleinte megtanulják az alapokat, és minden színesnek és gyönyörűnek tűnik. Ha kicsit mélyebbre megyünk, vannak JavaScript tömbök, tárgyak, visszahívások és minden más, ami gyakran feldobja a fejét.

A JavaScriptben fontos, hogy megfelelően ellenőrizze a változó típusát. Tegyük fel, hogy szeretné tudni, hogy egy változó tömb vagy objektum? Hogyan lehet ezt helyesen ellenőrizni? Ebben a konkrét esetben vannak trükkök az ellenőrzés során, és ez a bejegyzés ezekről fog szólni. Azonnal kezdjük.

Változó típusának ellenőrzése

Például ellenőriznie kell, hogy egy változó objektum, tömb, karakterlánc vagy szám. Ehhez használhatja a typeof-ot, de nem mindig mond igazat, és az alábbi példában megmutatom, miért.

Ezt a példát azért írtam, hogy világosan megmutassam, miért nem mindig a típus a megfelelő választás.

Var _comparison = ( string: "karakterlánc", int: 99, float: 13.555, objektum: (hello: "hello"), tömb: new Array(1, 2, 3) ); // Egy tömböt ad vissza az objektum kulcsaival. var _objKeys = Object.keys(_comparison); for(i változó = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

A kód végrehajtásának eredménye:

Karakterlánc szám szám objektum objektum

Jobb? - Természetesen nem. Két probléma van. Mindegyiket részletesen ismertetjük, és megoldást javasolunk.

Első probléma: float szám, kimenet számként

A Comparison.float nem szám, és a számnak lebegőpontosnak kell lennie (lebegőpontos szám), ennek kijavításához létrehozhat egy függvényt egy ellenőrzéssel az alábbi kód szerint.

Var_floatNumber = 9,22; var _notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); függvény isFloat(n)( return Number(n) === n && n % 1 !== 0; )

Az isFloat() függvény ellenőrzi, hogy minden érték lebegőpontos-e. Először is ellenőrizni kell, hogy a változó egyenlő-e n szám (Number(n) === n) és ha igen, akkor még egy ellenőrzést kell végezni a maradékkal való osztásra, és ha van maradék, akkor egy logikai ( igaz vagy hamis) eredmény (n % 1 !== 0).

A fenti példában ez tér vissza igaz, hamisÉs hamis. Az első jelentése az úszóírja be, a második nem – ez egy szabályos szám, az utolsó pedig csak egy üres karakterlánc, amely nem felel meg a szabályoknak.

Második probléma: a tömb objektumként lett definiálva

A legelső példában a tömb objektumként volt megjelenítve, és ez nem túl jó, mert néha pontosan ezt a típust kell használni, semmi mást.

Egy tömbtípus változójának tesztelésére többféleképpen is lehetőség van.

Az első lehetőség (jó lehetőség). Ellenőrizze, hogy az adatok egy tömbhöz tartoznak-e az instanceof() használatával.

Var data = new Array("hello", "világ"); var isArr = tömb adatpéldánya;

A második lehetőség (jó lehetőség). Az Array.isArray() metódus egy logikai értéket ad vissza, amely attól függ, hogy a változó tömb-e vagy sem ().

Var data = new Array("hello", "világ"); var isArr = Array.isArray(data);

A harmadik lehetőség (a legjobb, de hosszú). A kényelem kedvéért ezt a módszert funkcióvá teheti. Az Object használatával ezt csináljuk. Ha az Object.prototype.toString.call(data) eredménye nem egyenlő, akkor a változó nem tömb ().

Var data = new Array("hello", "világ"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

Az utolsó eredmény kényelmi funkcióként:

Függvény isArray(data) (vissza Object.prototype.toString.call(data) == "" )

Most meghívhatja az isArray() függvényeket, és beállíthat egy tömböt vagy valami mást argumentumként, és láthatja az eredményt.

Utószó

A lemez elég nagynak bizonyult, mint ahogy eredetileg tervezték. De elégedett vagyok vele, mert elég tömören és világosan leírja a JavaScript változóinak ellenőrzése során felmerülő nehézségeket és azok megkerülését.

Ha bármilyen kérdése van, kérjük, tegye fel a bejegyzés alá. Szívesen segítek.

Operátor típusú egy karakterláncot ad vissza, amely jelzi az operandus típusát.

Szintaxis

Az operandus az operátor típusát követi:

Típusú operandus

Lehetőségek

operandus egy kifejezés, amely egy objektumot vagy primitívet képvisel, amelynek típusát vissza kell adni.

Leírás

Az alábbi táblázat felsorolja a typeof lehetséges visszatérési értékeit. A típusokról és a primitívekről bővebb információ az oldalon található.

Példák

// Numbers typeof 37 === "szám"; typeof 3.14 === "szám"; typeof(42) === "szám"; typeof Math.LN2 === "szám"; typeof Infinity === "szám"; NaN típusa === "szám"; // bár ez "Not-A-Number" típusú Number(1) === "szám"; // soha ne használd ezt a bejegyzést! // Strings typeof "" === "string"; "bla" típusa === "string"; typeof "1" === "karakterlánc"; // vegye figyelembe, hogy a karakterláncon belüli szám továbbra is string típusú (typeof 1) === "string"; // typeof ebben az esetben mindig egy karakterláncot ad vissza typeof String("abc") === "string"; // soha ne használd ezt a bejegyzést! // Booleans typeof true === "boolean"; typeof false === "boolean"; typeof Boolean(true) === "boolean"; // soha ne használd ezt a bejegyzést! // Symbols typeof Symbol() === "symbol" typeof Symbol("foo") === "symbol" typeof Symbol.iterator === "symbol" // Undefined typeof undefined === "undefined"; typeof deklaredButUndefinedVariable === "undefined"; typeof undeclaredVariable === "undefined"; // Objektumok typeof(a: 1) === "object"; // használja az Array.isArray vagy Object.prototype.toString.call // a szokványos objektumok és a tömbök közötti különbségtételhez === "object"; typeof new Date() === "objektum"; // A következők hibákhoz és problémákhoz vezetnek. Ne használja! typeof new Boolean(true) === "objektum"; typeof new Number(1) === "objektum"; typeof new String("abc") === "objektum"; // Függvények typeof function() () === "függvény"; osztály típusa C() === "függvény"; typeof Math.sin === "függvény";

nulla

// Ezt a JavaScript typeof null === "object" születése óta határozták meg;

A JavaScript első implementációjában az értékeket egy címketípus és egy értékpár képviselte. Az objektumok címketípusa 0 volt. A null nulla mutatóként volt ábrázolva (a legtöbb platformon 0x00). Ezért a null címke típusa null volt, tehát a typeof visszatérési értéke dummy. ()

Javasoltak egy javítást az ECMAScriptben (a letiltással), de azt elutasították. Ennek eredményeként typeof null === "null" lesz.

Az új operátor használata

// Minden "new"-val létrehozott konstruktor függvény "object" típusú lesz var str = new String("String"); var szám = new Szám(100); typeofstr; // "object" typeof num; // Az "object"-t adja vissza // De van egy kivétel a függvény konstruktor var func = new Function(); funkció típusa; // "függvény" visszaadása

Reguláris kifejezések

A hívható reguláris kifejezések egyes böngészőkben nem szabványos kiegészítésnek számítottak.

/s/ típusa === "függvény"; // Chrome 1-12 Nem ECMAScript 5.1-kompatibilis /s/ === "object"; // Firefox 5+ Megfelel az ECMAScript 5.1-nek

Ideiglenes holt zónákkal kapcsolatos hibák

Az ECMAScript 2015 előtt az operátor típusa garantáltan visszaad egy karakterláncot minden olyan operandushoz, amellyel meghívták. Ez megváltozott a blokk-hatókörű, nem emelő let és const deklarációk hozzáadásával. Ha a változók let és const paraméterekkel vannak deklarálva, és a typeof meg van hívva a változó deklarációs blokkban, de a deklaráció előtt, akkor egy ReferenceError jelenik meg. A viselkedés eltér a nem deklarált változóktól, amelyeknél a typeof "undefined"-et ad vissza. A blokk-hatókörű változóknak van egy "ideiglenes holt zónája", amely a blokk elejétől a változó deklarálásáig tart. Ebben a zónában a változókhoz való hozzáférési kísérlet kivételt okoz.

Typeof undeclaredVariable === "undefined"; typeof newLetVariable; legyen newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "helló"; // ReferenceError

Kivételek

Az összes jelenlegi böngészőben található egy nem szabványos document.all gazdagép objektum, amely Undefined típusú.

Dokumentum típusa.all === "undefined";

Bár a specifikáció lehetővé teszi az egyéni típusnevek használatát a nem szabványos egzotikus objektumokhoz, megköveteli, hogy ezek a nevek eltérjenek az előre meghatározott nevektől. Kivételes szabálysértésnek kell tekinteni azt a helyzetet, amikor a document.all undefined típusú.

Műszaki adatok

Leírás	Állapot	Hozzászólások
ECMAScript legújabb vázlat (ECMA-262)	Piszkozat
ECMAScript 2015 (6. kiadás, ECMA-262) Az „Üzemeltető típusa” meghatározása ebben a specifikációban.	Alapértelmezett
ECMAScript 5.1 (ECMA-262) Az „Üzemeltető típusa” meghatározása ebben a specifikációban.	Alapértelmezett
ECMAScript 3rd Edition (ECMA-262) Az „Üzemeltető típusa” meghatározása ebben a specifikációban.	Alapértelmezett
ECMAScript 1st Edition (ECMA-262) Az „Üzemeltető típusa” meghatározása ebben a specifikációban.	Alapértelmezett	Kezdeti meghatározás. JavaScript 1.1-ben implementálva

Böngésző kompatibilitás

Frissítse a kompatibilitási adatokat a GitHubon

	Számítógépek						Mobil						szerver
	Króm	Él	Firefox	internet böngésző	Opera	Szafari	android webview	Chrome Androidra	Firefox Androidra	Opera Androidra	Safari iOS rendszeren	Samsung internet	Node.js
típusú	Króm Teljes támogatás 1	Él Teljes támogatás 12	Firefox Teljes támogatás 1	AZAZ. Teljes támogatás 3	Opera Teljes támogatás Igen	Szafari Teljes támogatás Igen	WebView Android Teljes támogatás 1	Chrome Android Teljes támogatás 18	Firefox Android Teljes támogatás 4	Opera Android Teljes támogatás Igen	Safari iOS Teljes támogatás Igen	Samsung Internet Android Teljes támogatás 1.0	nodejs Teljes támogatás Igen

Legenda

Teljes támogatás Teljes támogatás

IE-specifikus megjegyzések

Az IE 6-ban, 7-ben és 8-ban sok gazdagép objektum objektum, nem pedig függvény. Például.