Identification de type dynamique

Identification de type dynamique (RTTI) permet de déterminer le type d'un objet lors de l'exécution du programme. Cela s’avère utile pour plusieurs raisons. En particulier, en utilisant une référence à une classe de base, vous pouvez déterminer assez précisément le type d'objet accessible via cette référence. L'identification de type dynamique vous permet également de vérifier à l'avance le succès d'une conversion de type, évitant ainsi une exception due à une conversion de type incorrecte. De plus, l’identification dynamique des types est une composante majeure de la réflexion.

Pour prendre en charge l'identification de type dynamique, C# propose trois mots-clés a : est, comme et type de. Chacun de ces mots-clés est abordé ci-dessous tour à tour.

est l'opérateur

Le type spécifique d'un objet peut être déterminé à l'aide de l'opérateur is. Ci-dessous sa forme générale :

l'expression est un type

où expression désigne une expression unique décrivant l’objet dont le type est testé. Si l'expression est d'un type compatible ou du même type que le type testé, alors le résultat de cette opération est vrai, sinon il est faux. Ainsi, le résultat sera vrai si l'expression a un type testé sous une forme ou une autre. L'opérateur is définit les deux types comme compatibles s'ils sont du même type ou si la conversion de référence, le boxing ou le unboxing sont fournis.

Vous trouverez ci-dessous un exemple d'utilisation de l'opérateur is :

Utilisation du système ; espace de noms ConsoleApplication1 ( class Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); if (a est Add) Console.WriteLine("Variable a est de type Add"); if (s est Sum) Console.WriteLine("Le type de variable s est hérité de la classe Add"); Console.ReadLine(); ) ) )

Opérateur en tant que

Parfois, vous souhaitez effectuer une conversion de type au moment de l'exécution, mais ne pas lever d'exception si la conversion échoue, ce qui est tout à fait possible avec la conversion de type. L'opérateur as sert à cet effet, ayant la forme générale suivante :

expression comme type

où expression désigne une expression unique qui se convertit en type spécifié.

Si le résultat d'une telle conversion est réussi, alors une référence au type est renvoyée, sinon une référence vide. L'opérateur as ne peut être utilisé que pour la conversion de référence, l'identité, le boxing, le unboxing. Dans certains cas, l’opérateur as peut être une alternative pratique à l’opérateur is. A titre d'exemple, considérons le programme suivant :

Utilisation du système ; espace de noms ConsoleApplication1 ( class Add ( ) class Sum: Add ( ) class Program ( static void Main() ( Add a = new Add(); Sum s = new Sum(); // Effectue la conversion de type a = s en Add; if (a != null) Console.WriteLine("La conversion a réussi"); else Console.WriteLine("Erreur lors de la conversion" Console.ReadLine() ) )

Le résultat de l'exécution de ce programme sera une conversion réussie.

Javascript ou JS(en abrégé) n'est pas un langage facile et les développeurs novices ne l'apprendront pas tout de suite. Au début, ils apprennent les bases et tout semble coloré et beau. En allant un peu plus loin, des tableaux JavaScript, des objets, des rappels et tout ce qui ressemble à cela apparaissent, ce qui vous époustoufle souvent.

En JavaScript, il est important de bien vérifier le type d'une variable. Disons que vous voulez savoir si une variable est un tableau ou un objet ? Comment vérifier cela correctement ? Dans ce cas particulier, il existe des astuces lors de la vérification et cet article en parlera. Commençons tout de suite.

Vérifier le type d'une variable

Par exemple, vous devez vérifier si une variable est un objet, un tableau, une chaîne ou un nombre. Vous pouvez utiliser typeof pour cela, mais cela ne dira pas toujours la vérité et dans l'exemple ci-dessous, je vais montrer pourquoi.

J'ai écrit cet exemple pour montrer clairement pourquoi typeof n'est pas toujours le bon choix.

Var _comparison = ( string : "string", int : 99, float : 13.555, object : (bonjour : "bonjour"), array : new Array(1, 2, 3) ); // Renvoie un tableau avec les clés de l'objet var _objKeys = Object.keys(_comparison); pour(var je = 0; je<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Résultat de l'exécution du code :

Numéro de chaîne numéro objet objet

Droite? - Bien sûr que non. Il y a deux problèmes. Chacun d’entre eux sera décrit en détail et une solution proposée.

Premier problème : nombre flottant, sortie sous forme de nombre

Comparison.float n'est pas un nombre et au lieu d'un nombre, il devrait être un flottant (nombre à virgule flottante). Pour résoudre ce problème, vous pouvez créer une fonction avec une vérification comme dans le code ci-dessous.

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

La fonction isFloat() vérifie que toutes les valeurs sont à virgule flottante. Tout d'abord, on vérifie si la variable est égale à n nombre (Number(n) === n) et si oui, alors une autre vérification est faite pour la division avec un reste et s'il y a un reste, alors un booléen ( vrai ou FAUX) résultat (n % 1 !== 0).

Dans l'exemple ci-dessus, il renvoie vrai, FAUX Et FAUX. Le premier sens est flotter tapez, le second ne l'est pas - c'est un nombre normal et le dernier est juste une chaîne vide qui ne correspond pas aux règles.

Deuxième problème : le tableau a été défini comme un objet

Dans le tout premier exemple, le tableau était affiché sous forme d'objet et ce n'est pas très bon, car parfois vous devez utiliser exactement ce type et rien d'autre.

Il existe plusieurs façons de vérifier si une variable est de type tableau.

Première option (bonne option). Nous vérifions si les données appartiennent à un tableau en utilisant instanceof().

Var data = new Array("hello", "world"); var isArr = instance de données du tableau ;

Deuxième option (bonne option). La méthode Array.isArray() renvoie une valeur booléenne qui dépendra du fait que la variable soit un tableau ou non ().

Var data = new Array("hello", "world"); var isArr = Array.isArray(données);

Troisième option (la meilleure, mais longue). Pour plus de commodité, vous pouvez faire de cette méthode une fonction. En utilisant Object, nous le faisons. Si le résultat de Object.prototype.toString.call(data) n'est pas égal, alors la variable n'est pas un tableau ().

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

Le dernier résultat sous la forme d’une fonction de commodité :

Fonction isArray(data) ( return Object.prototype.toString.call(data) == "" )

Vous pouvez maintenant appeler les fonctions isArray() et définir un tableau ou autre chose comme argument et voir le résultat.

Épilogue

L’enregistrement s’est avéré plus volumineux que prévu initialement. Mais j'en suis satisfait car il décrit de manière assez succincte et claire les difficultés liées à la vérification des variables en JavaScript et comment les contourner.

Si vous avez encore des questions, écrivez-les ci-dessous dans cette entrée. Je serai heureux de vous aider.

Opérateur type de renvoie une chaîne indiquant le type de l'opérande.

Syntaxe

L'opérande suit le type d'opérateur :

Type de opérande

Possibilités

opérande est une expression représentant un objet ou une primitive dont le type doit être renvoyé.

Description

Le tableau suivant répertorie les valeurs de retour possibles de typeof. Plus d'informations sur les types et les primitives peuvent être trouvées sur la page.

Exemples

// Type de nombres de 37 === "numéro" ; typeof 3.14 === "numéro" ; typeof(42) === "numéro" ; type de Math.LN2 === "nombre" ; typeof Infinity === "nombre"; type de NaN === "nombre" ; // même s'il s'agit du type "Not-A-Number" de Number(1) === "number"; // n'utilise jamais cette entrée ! // Type de chaînes de "" === "string"; type de "bla" === "string"; type de "1" === "chaîne" ; // notez que le nombre à l'intérieur de la chaîne est toujours du type chaîne typeof (typeof 1) === "string"; // typeof renverra toujours une chaîne dans ce cas typeof String("abc") === "string"; // n'utilise jamais cette entrée ! // Type booléen de true === "boolean"; typeof false === "booléen" ; typeof Boolean(true) === "booléen" ; // n'utilise jamais cette entrée ! // Type de symboles Symbol() === "symbole" typeof Symbol("foo") === "symbole" typeof Symbol.iterator === "symbole" // Type non défini de undefined === "undefined"; typeof déclaréButUndéfiniVariable === "non défini" ; typeof undeclaredVariable === "non défini" ; // Type d'objets (a : 1) === "objet" ; // utilisez Array.isArray ou Object.prototype.toString.call // pour différencier les objets normaux et les tableaux typeof === "object"; typeof new Date() === "objet"; // Ce qui suit entraîne des erreurs et des problèmes. Ne l'utilisez pas ! typeof new Boolean(true) === "objet"; type de nouveau Number(1) === "objet"; typeof new String("abc") === "objet"; // Fonctions typeof function() () === "function"; type de classe C() === "fonction" ; type de Math.sin === "fonction" ;

nul

// Ceci a été défini depuis la naissance de JavaScript typeof null === "object";

Dans la première implémentation de JavaScript, les valeurs étaient représentées par un type de balise et une paire de valeurs. Le type de balise pour les objets était 0. null était représenté comme un pointeur nul (0x00 sur la plupart des plateformes). Par conséquent, le type de balise pour null était null, donc la valeur de retour de typeof est factice. ()

Un correctif a été proposé dans ECMAScript (via désactiver) mais a été rejeté. Cela entraînerait typeof null === "null" .

Utiliser le nouvel opérateur

// Toutes les fonctions constructeur créées avec "new" seront de type "object" var str = new String("String"); var num = nouveau nombre (100); type de str ; // Renvoie le type "objet" de num ; // Renvoie "objet" // Mais il existe une exception pour le constructeur de fonction var func = new Function(); type de fonction ; // Retourne "fonction"

Expressions régulières

Les expressions régulières appelables étaient un ajout non standard dans certains navigateurs.

Type de /s/ === "fonction" ; // Chrome 1-12 N'est pas conforme au type ECMAScript 5.1 de /s/ === "object" ; // Firefox 5+ est conforme à ECMAScript 5.1

Erreurs liées aux zones mortes temporaires

Avant ECMAScript 2015, l'opérateur typeof était assuré de renvoyer une chaîne pour tout opérande avec lequel il était appelé. Cela a changé avec l'ajout de déclarations let et const sans levage de portée bloc. Désormais, si les variables sont déclarées avec let et const et que typeof est appelé sur elles dans le bloc de déclaration de variable, mais avant la déclaration, alors une ReferenceError est levée. Le comportement diffère des variables non déclarées, pour lesquelles typeof renverra « undéfini ». Les variables de portée bloc ont une « zone morte temporaire » qui dure depuis le début du bloc jusqu'à ce que la variable soit déclarée. Dans cette zone, une tentative d'accès aux variables lève une exception.

Type de variable non déclarée === "non défini" ; type de newLetVariable ; laissez newLetVariable ; // Type d'erreur de référence de newConstVariable ; const newConstVariable = "bonjour"; // Erreur de référence

Exceptions

Dans tous les navigateurs actuels, il existe un objet hôte non standard document.all, qui est de type Non défini.

Type de document.all === "non défini" ;

Bien que la spécification autorise des noms de types personnalisés pour les objets exotiques non standard, elle exige que ces noms soient différents de ceux prédéfinis. La situation dans laquelle document.all est de type indéfini doit être considérée comme une violation exceptionnelle des règles.

Caractéristiques

Spécification	Statut	Commentaires
Dernière version d'ECMAScript (ECMA-262)	Brouillon
ECMAScript 2015 (6e édition, ECMA-262) La définition du « type d'opérateur » se trouve dans cette spécification.	Standard
ECMAScript 5.1 (ECMA-262) La définition du « type d'opérateur » se trouve dans cette spécification.	Standard
ECMAScript 3e édition (ECMA-262) La définition du « type d'opérateur » se trouve dans cette spécification.	Standard
ECMAScript 1ère édition (ECMA-262) La définition du « type d'opérateur » se trouve dans cette spécification.	Standard	Définition initiale. Implémenté en JavaScript 1.1

Compatibilité du navigateur

Mettre à jour les données de compatibilité sur GitHub

	Ordinateurs						Mobile						Serveur
	Chrome	Bord	Firefox	Internet Explorer	Opéra	Safari	Vue Web Android	Chrome pour Android	Firefox pour Android	Opéra pour Android	Safari sur iOS	Internet Samsung	Noeud.js
type de	Chrome Prise en charge complète 1	Bord Prise en charge complète 12	Firefox Prise en charge complète 1	C.-à-D. Prise en charge complète 3	Opéra Prise en charge complète Oui	Safari Prise en charge complète Oui	WebView Android Prise en charge complète 1	Chrome-Android Prise en charge complète 18	Firefox-Android Prise en charge complète 4	Opéra Android Prise en charge complète Oui	SafariiOS Prise en charge complète Oui	Samsung Internet Android Prise en charge complète 1.0	noeudjs Prise en charge complète Oui

Légende

Prise en charge complète Prise en charge complète

Notes spécifiques à IE

Dans IE 6, 7 et 8, de nombreux objets hôtes sont des objets, mais pas des fonctions. Par exemple.

une = (b > 0) && (c + 1 != d); drapeau = !(statut = 0);

Tableau 14.5. Opérateurs logiques

Description de l'opérateur

! NON (inversion logique)

&& ET (multiplication logique)

|| OU (addition logique)

Tableau 14.6. Résultats de l'exécution des opérateurs AND et OR

Opérande 1	Opérande 2

Tableau 14.7. Résultats de l'exécution de l'opérateur NOT

type d'opérateur d'obtention

Tapez l'opérateur obtenir typeof renvoie une chaîne décrivant le type de données de l'opérande. L'opérande dont vous souhaitez connaître le type est placé après cet opérateur et mis entre parenthèses :

s = typeof("str");

Suite à l'exécution de cette expression, la variable s contiendra la chaîne "string" indiquant le type de chaîne.

Toutes les valeurs que l'opérateur typeof peut renvoyer sont répertoriées dans le tableau. 14.8.

	Tableau 14.8. Valeurs renvoyées par le type d'opérateur
Type de données		Chaîne de retour
Chaîne
Numérique

			Tableau 14.8 (fin)
	Type de données	Chaîne de retour
	Logique

Compatibilité et conversion des types de données

Il est temps d'examiner deux questions plus importantes : la compatibilité des types de données et la conversion d'un type à un autre.

Qu'obtient-on lorsque l'on additionne deux nombres ? C'est vrai - une autre valeur numérique. Et si vous ajoutiez un nombre et une chaîne ? C'est difficile à dire... Ici, JavaScript est confronté au problème des types de données incompatibles et essaie de rendre ces types compatibles en convertissant l'un d'eux en un autre. Il essaie d'abord de convertir la chaîne en nombre et, en cas de succès, effectue une addition. En cas d'échec, le nombre sera converti en chaîne et les deux chaînes résultantes seront concaténées. Par exemple, le script Web du listing 14.6 convertirait la valeur de b en valeur numérique lorsqu'il serait ajouté à a ; ainsi la variable c contiendra la valeur 23.

Inscription 14.6

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

b = "12" ; c = une + b ;

d = « JavaScript » ; e = 2 ;

Mais comme la valeur de la variable d ne peut pas être convertie en nombre, la valeur de e sera convertie en chaîne et le résultat - la valeur de f - deviendra égal à

Les valeurs booléennes sont converties en valeurs numériques ou en chaînes, selon le cas spécifique. La valeur true sera convertie en chiffre 1 ou en chaîne "1" et la valeur false sera convertie en 0 ou "0" . A l’inverse, le chiffre 1 sera converti en vrai et le chiffre 0 sera converti en faux . De plus, false sera converti en

Nous avons les valeurs null et undefined .

	Partie III. Comportement des pages Web. Scripts Web

On peut constater que JavaScript a du mal à exécuter correctement même les expressions mal écrites. Parfois cela fonctionne, mais le plus souvent tout ne fonctionne pas comme prévu et, à la fin, l'exécution du script Web est interrompue à cause d'une erreur détectée à un endroit complètement différent, sur une instruction absolument correcte. Il est donc préférable d’éviter de tels incidents.

Priorité des opérateurs

Le dernier problème que nous examinerons ici est la priorité des opérateurs. Comme nous nous en souvenons, la priorité affecte l'ordre dans lequel les opérateurs d'une expression sont exécutés.

Soit l'expression suivante :

Dans ce cas, la valeur de c sera d'abord ajoutée à la valeur de la variable b, puis 10 sera soustrait de la somme. Les opérateurs de cette expression ont la même priorité et sont donc exécutés strictement de gauche à droite.

Considérons maintenant cette expression :

Ici, la valeur c sera d'abord multipliée par 10, et ensuite seulement la valeur b sera ajoutée au produit résultant. L'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition, donc l'ordre « strictement de gauche à droite » sera rompu.

Les opérateurs d’affectation ont la priorité la plus basse. C'est pourquoi l'expression elle-même est évaluée en premier, puis son résultat est affecté à une variable.

DANS En général, le principe de base pour l'exécution de tous les opérateurs est le suivant : les opérateurs avec une priorité plus élevée sont exécutés en premier, et ensuite seulement les opérateurs avec une priorité inférieure. Les opérateurs ayant la même priorité sont exécutés dans l'ordre dans lequel ils apparaissent (de gauche à droite).

DANS tableau 14.9 répertorie tous les opérateurs que nous avons étudiés par ordre décroissant de leurs priorités.

		Tableau 14.9. Priorité des opérateurs (par ordre décroissant)
	Opérateurs	Description
	++ -- - ~ ! type de	Incrémentation, décrémentation, changement de signe, NON logique, définition de type
		Multiplication, division, reste
		Addition et concaténation de chaînes, soustraction
		Opérateurs de comparaison
		ET logique

	Chapitre 14. Introduction à la programmation Web. Langage JavaScript
			Tableau 14.9 (fin)
	Opérateurs	Description
		OU logique
		Opérateur conditionnel(voir ci-dessous)
	= <оператор>=	Mission, simple et complexe

ATTENTION!

Rappelez-vous ce tableau. Une mauvaise exécution des instructions peut provoquer des erreurs difficiles à détecter, dans lesquelles une expression apparemment absolument correcte produit un résultat incorrect.

Mais que se passe-t-il si nous devons rompre l’ordre normal d’exécution des instructions ? Utilisons des parenthèses. Lorsqu'elles sont écrites de cette façon, les instructions entre parenthèses sont exécutées en premier :

une = (b + c) * 10 ;

Ici, les valeurs des variables b et c seront d'abord additionnées, puis la somme résultante sera multipliée par 10.

Les opérateurs entre parenthèses sont également soumis à la priorité. C'est pourquoi plusieurs parenthèses imbriquées sont souvent utilisées :

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

Ici, les opérateurs seront exécutés dans l'ordre suivant :

1. Ajout de b et c.

2. Multipliez le montant obtenu par 10.

3. Soustraire d du produit.

4. Divisez la différence par 2.

5. Ajouter 9 au quotient.

Si vous supprimez les parenthèses :

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

alors l'ordre d'exécution des opérateurs sera le suivant :

1. Multiplier c et 10.

2. Divisez d par 2.

3. Addition de b et produit de c et 10.

4. Soustraire le quotient de la division de la somme résultante d par 2.

5. Ajoutez 9 à la différence résultante.

Le résultat est complètement différent, n'est-ce pas ?

• Indéfini : "indéfini"
• Null : "objet"
• Booléen : "booléen"
• Numéro : "numéro"
• Chaîne : "chaîne"
• Fonction : "fonction"
• Tout le reste : "objet"

Les notes suivantes doivent être ajoutées à ce tableau :

1. typeof null === "objet" .

Théoriquement, il y a ici un point subtil. Dans les langages typés statiquement, une variable de type objet ne peut pas contenir d'objet (NULL, nil, pointeur nul).

En pratique, cela n'est pas pratique en JavaScript. Les développeurs d'ES 5.1 vont donc faire quelque chose de plus intuitif : typeof null === "null" .

Mais comme nous avons toujours ES3 partout, ne vous y trompez pas, par exemple, avec ceci :

/* La fonction recherche un objet et le renvoie ou null si rien n'est trouvé */ function search() () var obj = search(); if (typeof obj === "object") ( // avons-nous vraiment trouvé l'objet (FAIL) obj.method(); )

2. N'oubliez pas les objets wrapper (typeof new Number(5) === « object »).

3. Et n'oubliez pas le droit des navigateurs de faire ce qu'ils veulent avec les objets hôtes.

Ne soyez pas surpris que Safari considère obstinément HTMLCollection comme un type de fonction, et IE antérieur à la version 9 conserve notre fonction alert() préférée en tant qu'objet. De plus, Chrome considérait RegExp comme une fonction , mais maintenant il semble reprendre ses esprits et y répondre avec un objet .

àChaîne()

Essayer de connaître le type d’une valeur à partir du résultat de sa méthode toString() est inutile. Dans toutes les « classes », cette méthode est remplacée par la sienne.

La méthode est efficace pour afficher les informations de débogage, mais elle ne peut pas être utilisée pour déterminer le type d'une variable.

Objet.prototype.toString()

Bien que toString soit remplacé dans des "classes" spécifiques, nous avons toujours son implémentation originale à partir d'Object. Essayons de l'utiliser :

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

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

Clinton allège cet ennui

Curieusement, cette méthode fonctionne étonnamment bien.

Pour les types scalaires, renvoie , , , .

Ce qui est drôle, c'est que même le nouveau Number(5) sur lequel typeof a échoué revient ici.

La méthode échoue sur null et non défini. Différents navigateurs reviennent, parfois attendus et parfois, parfois en général. Cependant, vous pouvez facilement déterminer le type de ces deux valeurs sans cela.

Les choses deviennent intéressantes quand on arrive aux objets (ceux avec typeof === "object").

les objets intégrés fonctionnent pratiquement avec brio :

• {} —
• —
• Date -
• Erreur -
• Expression régulière –

La seule chose est qu'il ne figure plus dans la liste des arguments, qui sont soit .
Les choses empirent encore avec les objets hôtes.

Dans IE, les objets DOM n'ont commencé à devenir des objets « normaux » qu'à partir de la version 8, et même alors pas complètement. Par conséquent, dans IE 6-8, tous ces objets (HTMLCOllection, DOMElement, TextNode, ainsi que document et fenêtre) sont simplement réduits à .

Dans tous les autres navigateurs (y compris IE9), vous pouvez déjà faire quelque chose avec le résultat de toString. Bien que tout ne soit pas non plus facile : HTMLCollection est là, alors . fenêtre - alors, alors, alors. Mais vous pouvez déjà essayer d’en tirer quelque chose.

C'est plus compliqué avec DOMElement : il s'affiche sous la forme, - un format différent pour chaque balise. Mais la saison régulière va nous aider ici aussi.

L'histoire est à peu près la même avec les autres objets hôtes (dans les tests de localisation et de navigateur). Partout sauf IE, ils peuvent être identifiés par la ligne.

Inconvénients de l'utilisation de Object.prototype.toString() :

1. Cette possibilité n'est pas couverte par la norme. Et ici, nous devrions plutôt nous réjouir que tout fonctionne si bien, plutôt que de nous plaindre de certaines lacunes.

2. Déterminer un type en analysant une chaîne renvoyée par une méthode qui n'est pas du tout utilisée pour déterminer un type, et qui est également appelée sur un objet auquel elle ne s'applique pas, laisse un peu de sédiment dans l'âme.

3. Dans l'ancien IE, comme vous pouvez le constater, il est normal de ne pas identifier les objets hôtes.

Cependant, cela fonctionne parfaitement lorsqu'il est utilisé conjointement avec d'autres moyens.

Constructeurs

Et enfin, les designers. Qui de mieux pour dire sur la « classe » d’un objet en JS que son constructeur ?

null et undefined n'ont ni objets wrapper ni constructeurs.

D'autres types scalaires ont des wrappers, vous pouvez donc également obtenir un constructeur :

(5).constructeur === Nombre ;

(Nombre .NaN ) .constructor === Nombre ;

(true).constructor === Booléen ;

5 instances de Nombre ;

// false Nombre .NaN instanceof Nombre ;

// false true instance de Boolean ;

// fausse instance "string" de String ;

// FAUX

5 instances de numéro ; // false Number.NaN instance de Number ; // false true instance de Boolean ; // fausse instance "string" de String ; // FAUX

(instanceof fonctionnera pour le nouveau numéro (5) qui souffre depuis longtemps)

Avec des fonctions (qui sont aussi des objets), instanceof fonctionnera :

console.log ( (function () ( ) ) instanceof Function ) ;

// true console.log ( (function () ( ) ).constructor === Function ) ;

// vrai

console.log((function () ()) instanceof Function); // true console.log((function () ()).constructor === Function); // vrai

Tous les objets des classes intégrées sont également facilement identifiés par leurs constructeurs : Array, Date, RegExp, Error.

Un problème se pose ici avec les arguments , dont le constructeur est Object .

Et la seconde concerne l'objet lui-même, ou plutôt comment lui attribuer un objet créé via un constructeur personnalisé.

De cette façon, vous pouvez définir uniquement l'objet de base : obj instance d'objet ; L'une des options de définition consiste à parcourir tous les autres types possibles (Tableau, Erreur...) et si aucun d'entre eux ne convient - « objet ».

Constructeurs et objets hôtes

Les choses empirent avec les objets hôtes.

Commençons par le fait qu'IE jusqu'à la version 7 incluse ne les considère pas du tout comme des objets normaux. Ils n’ont tout simplement pas de concepteurs ni de prototypes (au moins un programmeur ne peut pas les atteindre).

Les choses vont mieux dans d’autres navigateurs. Il existe des constructeurs et vous pouvez les utiliser pour déterminer la classe d'une valeur. On les appelle seulement

différents navigateurs

différemment. Par exemple, pour HTMLCollection, le constructeur sera soit HTMLCollection, soit NodeList, voire NodeListConstructor.
Vous devez également définir un constructeur de base pour DOMElement. Dans FF, il s'agit par exemple de HTMLElement , dont HTMLDivElement et d'autres héritent déjà.
L'astuce est lancée sur FireFox sous la version 10 et Opera sous la version 11. Le constructeur de collection est Object .
constructeur.nom

Les constructeurs ont également une propriété name, qui peut être utile.

Aucune des méthodes présentées ne permet de déterminer à 100 % le type/classe d'une valeur dans tous les navigateurs. Cependant, pris ensemble, ils permettent d’y parvenir.

Dans un avenir proche, j'essaierai de collecter toutes les données dans des tableaux et de donner un exemple de fonction de définition.