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 a változó típusának helyes ellenőrzése. Tegyük fel, hogy szeretné tudni, hogy egy változó tömb vagy objektum? Hogyan ellenőrizhető helyesen? Ebben a konkrét esetben vannak trükkök az ellenőrzés során, és ez a bejegyzés errő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 ez nem mindig mond igazat, és az alábbi példában megmutatom, miért.

Ezt a példát annak szemléltetésére írtam, hogy 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:

String 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, hanem szám helyett float. Ennek kijavításához létrehozhat egy függvényt egy pipával, mint az alábbi kódban.

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 a lebegőpontos számok összes értékét ellenőrzi. Először ellenőrizze, 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 értéket ad vissza ( 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 jelenik meg, ami nem túl jó, mert néha 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 objektum segítségével elkészítjük. 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 valamit 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ör és világos ahhoz, hogy leírja a változók JavaScriptben való érvényesítésének nehézségeit é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.

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 utasítás végrehajtásának eredménye

szerezze be az operátor típusát

Get type operátor A typeof egy karakterláncot ad vissza, amely leírja az operandus adattípusát. A keresendő operandus az operátor mögé kerül, és zárójelbe kerül:

s = typeof("str");

Ennek a kifejezésnek az eredményeként az s változó tartalmazza a "string" karakterláncot, amely a karakterlánc típusát jelöli.

Az 1. táblázat tartalmazza az összes értéket, amelyet az operátor típusa vissza tud adni. 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

Kompatibilitás és adattípus á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.

Mi történik, ha két számot összeadunk? Í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 belefut az adattípusok inkompatibilitásának problémájába, és úgy próbálja meg kompatibilissé tenni ezeket a típusokat, hogy az egyiket a másikba konvertálja. Először megpróbálja számmá alakítani a karakterláncot, és ha sikerül, végrehajtja az összeadást. Ha nem sikerül, a számot karakterláncsá alakítja, és a kapott két karakterláncot összefűzi. Például a 14-6. listában szereplő webszkript átalakítja a b változó értékét, ha hozzáadja az a változóhoz, numerikus típussá; í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 át. A True értéket 1-es számra vagy "1" karakterláncra, a hamis értéket pedig 0-ra vagy "0"-ra konvertálja. Ezzel szemben az 1-es szám igaz, a 0 pedig hamis lesz. A false is át lesz alakítva

nullák vagyunk és meghatározatlanok .

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

Látható, hogy a JavaScript még a hibásan írt kifejezések helyes végrehajtásával is küzd. Néha működik, de legtöbbször nem úgy alakulnak a dolgok, ahogyan eltervezték, és végül a webszkript megszakad, mert a szkriptben teljesen más helyen, a teljesen helyes kijelentésen hibát találtak. Ezért jobb elkerülni az ilyen eseményeket.

Üzemeltetői elsőbbség

Az utolsó kérdés, amellyel itt foglalkozunk, 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 adjuk hozzá a c értékét, 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 sérül.

A hozzárendelési operátorok a legalacsonyabb prioritásúak. 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 ezutá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 lapon. A 14.9 felsorolja az összes általunk vizsgált operátort prioritásuk szerinti csökkenő sorrendben.

		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ípuskövetkeztetés
		Szorzás, osztás, maradék
		Karakterlánc összeadás és összefűzés, 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 operátor (lásd lent)
	= <оператор>=	Feladat, egyszerű és összetett

FIGYELEM!

Emlékezzen erre a táblázatra. Az utasítások hibás végrehajtási sorrendje nehezen észlelhető hibákat okozhat, amelyekben egy 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ások szokásos végrehajtási sorrendjét? Használjunk zárójeleket. Ebben a jelölésben először a zárójeles utasítások kerülnek végrehajtásra:

a = (b + c) * 10;

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

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

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

Itt az utasítások végrehajtása a következő sorrendben történik:

1. Adja hozzá b és c.

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. Szorozzuk meg c-t és 10-et.

2. Oszd el d-t 2-vel.

3. B összeadása, c és 10 szorzása.

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

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

Teljesen más eredményt kap, igaz?

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 azt az objektumot vagy primitívet reprezentálja, 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. további információ típusokról és primitívekről 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"; // annak ellenére, hogy "Not-A-Number" típusú Number(1) === "szám"; // soha ne használd ezt a jelölé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 typeof 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 jelölést! // Booleans typeof true === "boolean"; typeof false === "boolean"; typeof Boolean(true) === "boolean"; // soha ne használd ezt a jelölé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 // használatával a szokásos objektumok és tömbök megkülönböztetésére === "object"; typeof new Date() === "objektum"; // Az alábbiakban leírtak 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 hamis. ()

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 meghívott reguláris kifejezések egyes böngészőkben nem szabványos kiegészítések voltak.

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

Az ideiglenes holt zónákhoz kapcsolódó hibák

Az ECMAScript 2015 előtt az operátor típusa garantáltan visszaadta a karakterláncot bármely operandushoz, amellyel meghívták. Ez megváltozott a nem emelő blokk hatókörű let és const deklarációk hozzáadásával. Most, ha a változók let és const paraméterekkel vannak deklarálva, és a typeof meghívásra kerül 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ók egy "ideiglenes holt zónában" vannak, amely a blokk elejétől a változók 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 egyéni típusnevek megadását a nem szabványos egzotikus objektumokhoz, ezeknek a neveknek el kell térniük 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	OperaAndroid 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.

• undefined: "undefined"
• Null: "objektum"
• Logikai: "boolean"
• Szám: "szám"
• Karakterlánc: "string"
• Funkció: "funkció"
• Minden más: "objektum"

Ezt a táblázatot a következő megjegyzésekkel kell kiegészíteni:

1. typeof null === "objektum" .

Elméletileg van itt egy finom pont. Statikusan beírt nyelvekben az objektumtípus változó nem tartalmazhat objektumot (NULL, nil, null pointer).

Gyakorlatilag - a JavaScriptben ez kényelmetlen. Tehát az ES 5.1 fejlesztői valami intuitívabbat fognak csinálni: typeof null === "null" .

De mivel még mindig az ES3 körül járunk, ne tévedjünk például ebben:

/* A függvény megkeres valamilyen objektumot, és visszaadja azt vagy nullát, ha nem talál semmit */ függvény search() () var obj = search(); if (obj típusa === "objektum") ( // valóban megtaláltuk az objektumot (FAIL) obj.method(); )

2. Ne feledkezzünk meg a wrapper objektumokról (új Number(5) === "objektum" típusa).

3. És ne felejtse el a böngészők jogát, hogy bármit megtegyenek a gazdagép objektumokkal.

Ne lepődj meg azon, hogy a Safari makacsul függvénytípusként kezeli a HTMLCollection-t, a 9. előtti IE pedig objektumként tartja meg kedvenc alert() függvényünket. Ezenkívül a Chrome korábban a RegExp-et függvénynek tekintette, de most úgy tűnik, hogy magához tér, és egy tárggyal reagál rá.

toString()

Felesleges a toString() metódus eredményéből kideríteni egy érték típusát. Minden "osztályban" ez a metódus újradefiniálva van.

A módszer jó a hibakeresési információk megjelenítésére, de a változó típusa nem határozható meg belőle.

Object.prototype.toString()

Annak ellenére, hogy a toString felül van írva a konkrét "osztályokon", még mindig megvan az eredeti megvalósítása az Object-ből. Próbáljuk meg használni:

console.log ( Object .prototype .toString .call (érték) ) ;

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

Clinton felhígítja ezt a terhet

Furcsa módon ez a módszer meglepően jól működik.

Skaláris típusok esetén a , , , .

A vicces az, hogy még az új Number(5) is, amelyen a typeof failed here, visszaadja a .

Null és undefined esetén a metódus sikertelen lesz. Különböző böngészők a várt és a , vagy , vagy páros értéket adják vissza. Ennek a két értéknek a típusát azonban e nélkül is könnyű meghatározni.

Az érdekes dolgok akkor kezdõdnek, amikor az objektumokhoz érünk (azokhoz, amelyek típusa === "objektum").

a beépített tárgyak gyakorlatilag egy ütéssel működnek:

• {} —
• —
• dátum-
• hiba-
• reguláris kifejezés-

Az egyetlen dolog, ami kimarad az argumentumlistából, ami vagy , vagy .
A host-objektumokkal ismét minden rosszabb.

Az IE-ben a DOM objektumok csak a 8. verziótól kezdtek "normális" objektummá válni, aztán nem egészen a végéig. Ezért az IE 6-8-ban ezek az objektumok (HTMLCOllection, DOMElement, TextNode, valamint dokumentum és ablak) egyszerűen átküldésre kerülnek a .

Minden más böngészőben (beleértve az IE9-et is) már lehet kezdeni valamit a toString eredménnyel. Bár minden szintén nem egyszerű: HTMLCollection ott , akkor . ablak - akkor, akkor, akkor. De ebből már lehet próbálni valamit kihozni.

A DOMElement esetében ez nehezebb: minden címkénél más formátumban jelenik meg. De itt az alapszakasz a segítségünkre lesz.

Más gazdagép objektumokkal (a hely- és navigátortesztekben) a történet körülbelül ugyanaz. Az IE kivételével mindenhol egy karakterlánc alapján azonosíthatók.

Az Object.prototype.toString() használatának hátrányai közül:

1. Ezt a lehetőséget a szabvány nem szentesíti. És itt inkább örülnünk kell, hogy minden ilyen jól működik, nem pedig néhány hiányosságon siránkozni.

2. A típus meghatározása egy olyan metódussal visszaadott karakterlánc elemzésével, amely egyáltalán nem a típus meghatározására szolgál, és még olyan objektumra is meghív, amelyre nem vonatkozik, némi üledéket hagy a lélekben.

3. A régi IE-ben, amint látható, a gazdagép-objektumok általában nem azonosíthatók.

Más eszközökkel együtt használva azonban nagyon jól működik.

Konstruktorok

És végül a kivitelezők. Ki mondhatna jobbat egy objektum "osztályáról" a JS-ben, mint a konstruktora?

A null és undefined nem tartalmaz sem wrapper objektumot, sem konstruktort.

A többi skalár típusnak van burkolója, így beszerezhet egy konstruktort:

(5) .constructor === Szám ; (Szám .NaN ) .constructor === Szám ; (igaz) .constructor === Boolean ; ("karakterlánc") .constructor === Karakterlánc ;

(5).konstruktor === Szám; (Szám.NaN).constructor === Szám; (igaz).constructor === Boolean; ("karakterlánc").constructor === Karakterlánc;

De az instanceof itt nem fog működni:

5 instanceofNumber ; // false Number .NaN instanceof Number ; // hamis igaz példány of Boolean ; // hamis "string" instanceof String ; // hamis

5 instanceofNumber; // false Number.NaN instanceof Number; // hamis igaz példány of Boolean; // hamis "karakterlánc" példánya String; // hamis

(az példány a régóta szenvedett új számnak fog működni(5))

A függvényekkel (amelyek egyben objektumok is) az instanceof a következőket teszi:

konzol. napló ( (függvény () ( ) ) Függvény példánya ) ; // true console. log ( (függvény () ( ) ) .constructor === függvény ) ; // igaz

console.log((függvény () ()) példánya függvény); // true console.log((függvény () ()).constructor === Függvény); // igaz

A beépített osztályok minden objektumát a konstruktorok is könnyen azonosítják: Array , Date , RegExp , Error .

Itt egy probléma adódik az argumentumokkal, amelyek konstruktora az Object.

A második pedig magával az Object-szel, vagy inkább, hogyan hivatkozhatunk rá egy egyedi konstruktoron keresztül létrehozott objektumra.

Csak az alapobjektum definiálható így:

obj instanceofObject;

A definíciók egyikeként ismételje meg az összes többi lehetséges típust (Array , Error ...), és ha egyik sem tartozik az "objektum" alá.

Konstruktorok és gazdagép objektumok

A dolgok rosszabbra fordulnak a gazdagép objektumokkal.

Kezdjük azzal, hogy az IE egészen a 7. verzióig egyáltalán nem tekinti őket normál objektumnak. Egyszerűen nincs ott konstruktoruk és prototípusuk (mindenesetre a programozó nem tudja elérni őket).

Más böngészőkben jobbak a dolgok. Vannak konstruktorok, és ezekből lehet meghatározni az értékosztályt. Csak hívják különböző böngészők eltérően. Például egy HTMLCollection esetében a konstruktor vagy egy HTMLCollection vagy egy NodeList , vagy akár egy NodeListConstructor .

Meg kell határoznia a DOMElement alapkonstruktorát is. FF-ben ez például a HTMLElement , amelyből a HTMLDivElement és mások már örökölnek.

A trükköt a 10-es verzió alatt a FireFox, a 11-es verzió alatt az Opera dobja be. Ott a gyűjteménykonstruktor az Object.

konstruktor.név

A konstruktoroknak is van egy név tulajdonságuk, ami hasznos lehet.

Tartalmazza a konstruktor függvény nevét, például (5).constructor.name === "Szám" .

Azonban:
1. IE-ben egyáltalán nincs, még a 9.-ben sem.
2. A Host-objektumokban a böngészők ismét öntöttek mindent, ami sok (és gyakran egyáltalán nem rendelkeznek ezzel a tulajdonsággal). Az Operában a DOMElementnek általában van egy konstruktorneve Function.prototype .
3. argumentumok ismét "objektum".

következtetéseket

A bemutatott módszerek egyike sem adja meg az érték típusának/osztályának 100%-os meghatározását minden böngészőben. Együtt azonban lehetővé teszik ezt.

A közeljövőben megpróbálom az összes adatot táblázatokba gyűjteni, és példát mutatni egy definiáló függvényre.