Identification dynamique du type

Identification de type dynamique (RTTI) permet de déterminer le type d'un objet à l'exécution. Il s'avère utile pour plusieurs raisons. En particulier, par référence à la classe de base, on peut déterminer assez précisément le type de l'objet accessible par cette référence. L'identification de type dynamique vous permet également de vérifier à l'avance dans quelle mesure le résultat de la conversion de type sera réussi, évitant ainsi une exception due à une conversion de type incorrecte. De plus, l'identification dynamique du type est une composante majeure de la réflexion.

Pour prendre en charge l'identification de type dynamique, C# fournit trois mots clés a : est, comme et typeof. Chacun de ces mots-clés est discuté plus loin à son tour.

est l'opérateur

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

l'expression est de type

où expression désigne une expression unique qui décrit 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 est du type testé sous une forme ou une autre. Dans l'opérateur is, les deux types sont définis comme compatibles s'ils sont du même type ou si une conversion de référence, un boxing ou unboxing est fourni.

Voici un exemple d'utilisation de l'opérateur is :

Utilisation du système ; namespace 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(); ) ) )

en tant qu'opérateur

Parfois, une conversion de type doit être effectuée au moment de l'exécution, mais pas lancée si la conversion échoue, ce qui est parfaitement possible avec un transtypage de type. L'opérateur as remplit cette fonction et a la forme générale suivante :

expression comme type

où expression désigne une expression unique convertible dans le type spécifié.

Si le résultat d'une telle conversion réussit, une référence au type est renvoyée, sinon, une référence nulle. 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(); // Effectuer le cast a = s as Add; if ( a != null) Console.WriteLine("Conversion réussie"); 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.

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

Tableau 14.5. Opérateurs logiques

Description de l'opérateur

! NON (inversion logique)

&& ET (multiplication booléenne)

|| 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'instruction NOT

obtenir le type d'opérateur

Obtenir l'opérateur de type typeof renvoie une chaîne décrivant le type de données de l'opérande. L'opérande dont le type est à rechercher est placé après cet opérateur et entre parenthèses :

s = typeof("str");

À la suite de cette expression, la variable s contiendra la chaîne "string" , indiquant le type de chaîne.

Toutes les valeurs pouvant être renvoyées type d'opérateur sont répertoriés dans le tableau. 14.8.

	Tableau 14.8. Valeurs renvoyées par l'opérateur typeof
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 de type de données

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

Que se passe-t-il lorsque vous additionnez 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 se heurte au problème d'incompatibilité des types de données et essaie de rendre ces types compatibles en convertissant l'un d'entre eux en un autre. Il essaie d'abord de convertir la chaîne en un nombre et, s'il réussit, effectue l'addition. En cas d'échec, le nombre sera converti en une 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 la variable b lorsqu'elle est ajoutée à la variable a en un type numérique ; ainsi la variable c contiendra la valeur 23.

Liste 14.6

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

b = "12" ; c = un + 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 de chaîne, selon le cas. True sera converti en nombre 1 ou en chaîne "1" , et false en 0 ou "0" . A l'inverse, le nombre 1 sera converti en true , et le nombre 0 en false . De plus, false sera converti

nous sommes nuls et indéfinis.

	Partie III. Comportement des pages Web. Scripts Web

On peut voir que JavaScript a du mal à exécuter correctement des expressions même mal écrites. Parfois, cela fonctionne, mais le plus souvent, les choses ne fonctionnent pas comme prévu, et finalement le script Web est abandonné car une erreur est trouvée à un endroit complètement différent du script, sur l'instruction absolument correcte. Par conséquent, il vaut mieux éviter de tels incidents.

Priorité des opérateurs

Le dernier problème que nous traiterons 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 la somme sera soustraite de 10. 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, d'abord, la valeur c sera multipliée par 10, puis 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 violé.

Les opérateurs d'affectation ont la priorité la plus faible. 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 de l'exécution de tous les opérateurs est le suivant : d'abord, les opérateurs avec une priorité plus élevée sont exécutés, et ensuite seulement - les opérateurs avec une priorité inférieure. Les opérateurs de même priorité sont exécutés dans l'ordre dans lequel ils apparaissent (de gauche à droite).

DANS languette. 14.9 liste tous les opérateurs que nous avons étudiés par ordre décroissant de leur précédence.

		Tableau 14.9. Priorité des opérateurs (par ordre décroissant)
	Les opérateurs	Description
	++ -- - ~ ! Type de	Incrémentation, décrémentation, changement de signe, NON logique, inférence 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)
	Les opérateurs	Description
		OU logique
		Opérateur conditionnel (voir ci-dessous)
	= <оператор>=	Mission, simple et complexe

ATTENTION!

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

Mais que se passe-t-il si nous devons briser l'ordre d'exécution normal des instructions ? Utilisons des parenthèses. Dans cette notation, les instructions entre parenthèses sont exécutées en premier :

un = (b + c) * 10 ;

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

Les opérateurs entre parenthèses sont également soumis à la priorité. Par conséquent, plusieurs parenthèses imbriquées sont souvent utilisées :

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

Ici, les instructions seront exécutées dans l'ordre suivant :

1. Additionnez b et c.

2. Multipliez le montant obtenu par 10.

3. Soustraire d du produit.

4. Divisez la différence par 2.

5. Ajout de 9 au quotient.

Si vous supprimez les crochets :

un = b + c * 10 - ré / 2 + 9 ;

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

1. Multipliez c et 10.

2. Divisez d par 2.

3. Additionnez b et produit c et 10.

4. Soustraction de la somme résultante du quotient de la division d à 2.

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

Il s'avère que le résultat est complètement différent, n'est-ce pas ?

Javascript ou JS(sous peu) 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 approfondissant un peu, il y a Tableaux JavaScript, des objets, des rappels et tout ce qui vous étonne souvent.

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

Vérification du 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 vous dira pas toujours la vérité, et je vais vous montrer pourquoi dans l'exemple ci-dessous.

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

Var _comparison = ( string : "string", int : 99, float : 13,555, object : (hello : "hello"), array : new Array(1, 2, 3) ); // Retourne 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 :

Objet objet numéro de chaîne

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

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

Comparaison.float n'est pas un nombre et doit être un nombre flottant au lieu d'un nombre. 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("")); function isFloat(n)( return Number(n) === n && n % 1 !== 0; )

La fonction isFloat() vérifie toutes les valeurs pour les nombres à virgule flottante. Vérifiez d'abord si la variable est égale n nombre (Nombre(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 est retourné ( vrai ou FAUX) résultat (n % 1 !== 0).

Dans l'exemple ci-dessus, il renvoie vrai, FAUX Et FAUX. Le premier sens est flotter type, le second ne l'est pas - il s'agit d'un nombre normal et le dernier n'est qu'une chaîne vide qui ne respecte pas les règles.

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

Dans le tout premier exemple, le tableau est rendu sous la forme d'un objet, ce qui n'est pas très bon, car parfois vous devez utiliser ce type et rien d'autre.

Il existe plusieurs façons de tester une variable pour un type de tableau.

La première option (bonne option). Vérifiez si les données appartiennent à un tableau en utilisant instanceof().

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

La deuxième option (bonne option). La méthode Array.isArray() retourne une valeur booléenne qui dépendra si la variable est un tableau ou non().

Var data = new Array("bonjour", "monde"); var isArr = Array.isArray(data);

La troisième option (la meilleure, mais longue). Pour plus de commodité, vous pouvez faire de cette méthode une fonction. En utilisant Object nous 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("bonjour", "monde"); var isArr = Object.prototype.toString.call(data) == "" ; console.log(isArr);

Le dernier résultat en tant que fonction de commodité :

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

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

Épilogue

Le disque s'est avéré être assez volumineux par rapport à ce qui était initialement prévu. Mais j'en suis satisfait car il est suffisamment concis et clair pour décrire les difficultés de validation des variables en JavaScript et comment les contourner.

Si vous avez des questions, veuillez les poster sous ce post. Je serai ravi 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

Choix

opérande est une expression représentant l'objet ou la 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 sont sur la page.

Exemples

// Nombres typeof 37 === "nombre" ; typeof 3.14 === "nombre" ; typeof(42) === "nombre" ; typeof Math.LN2 === "nombre" ; typeof Infinity === "nombre" ; typeof NaN === "nombre" ; // même s'il s'agit du type "Pas-un-nombre" de Number(1) === "number" ; // n'utilisez jamais cette notation ! // Chaînes typeof "" === "string" ; typeof "bla" === "chaîne" ; typeof "1" === "chaîne" ; // notez que le nombre à l'intérieur de la chaîne est toujours de type string typeof (typeof 1) === "string"; // typeof retournera toujours une chaîne dans ce cas typeof String("abc") === "string"; // n'utilisez jamais cette notation ! // Booléens typeof true === "booléen" ; typeof false === "booléen" ; typeof Booléen(vrai) === "booléen" ; // n'utilisez jamais cette notation ! // Symbols typeof Symbol() === "symbol" typeof Symbol("foo") === "symbol" typeof Symbol.iterator === "symbol" // Undefined typeof undefined === "undefined"; typeof declareButUndefinedVariable === "undefined" ; typeofVariablenondéclarée === "undefined" ; // Type d'objets(a : 1) === "objet" ; // utilisez Array.isArray ou Object.prototype.toString.call // pour faire la distinction entre les objets normaux et les tableaux typeof === "object"; typeof new Date() === "objet" ; // Tout ce qui suit entraîne des erreurs et des problèmes. Ne pas utiliser! typeof new Boolean(true) === "object" ; typeof new Number(1) === "objet" ; typeof new String("abc") === "object" ; // Type de fonctions de fonction() () === "fonction" ; typeof classe C() === "fonction" ; typeof Math.sin === "fonction" ;

nul

// Cela 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 une paire type de balise et valeur. Le type de balise pour les objets était 0. null était représenté comme un pointeur nul (0x00 sur la plupart des plates-formes). Par conséquent, le type de la balise pour null était null, donc la valeur de retour de typeof est fausse. ()

Un correctif a été proposé dans ECMAScript (via disable) mais a été rejeté. Cela se traduirait par typeof null === "null" .

Utilisation du 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); typeofstr; // Retourne le type "objet" de num ; // Renvoie "object" // Mais il y a une exception pour le constructeur Function var func = new Function(); type de fonction ; // Retourne "fonction"

Expressions régulières

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

Type de /s/ === "fonction" ; // Chrome 1-12 Non conforme ECMAScript 5.1 typeof /s/ === "object"; // Firefox 5+ est conforme à ECMAScript 5.1

Bugs liés aux zones mortes temporaires

Avant ECMAScript 2015, l'opérateur typeof était garanti de renvoyer une chaîne pour l'opérande avec lequel il était appelé. Cela a changé avec l'ajout de déclarations let et const de portée de bloc sans levage. Maintenant, si des 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 est différent des variables non déclarées, pour lesquelles typeof renverra "undefined". Les variables à portée de bloc se trouvent dans une "zone morte temporaire", qui dure du début du bloc jusqu'au moment où les variables sont déclarées. 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 ; let newLetVariable ; // ReferenceError typeof newConstVariable ; const newConstVariable = "bonjour" ; // Erreur de référence

Des exceptions

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

Type de document.all === "undefined" ;

Bien que la spécification autorise les noms de type personnalisés pour les objets exotiques non standard, ces noms doivent être différents de ceux prédéfinis. La situation où document.all est de type undefined doit être considérée comme une violation exceptionnelle des règles.

Caractéristiques

spécification	Statut	commentaires
Dernier projet ECMAScript (ECMA-262)	Brouillon
ECMAScript 2015 (6e édition, ECMA-262) Définition de "Le type d'Opérateur" dans cette spécification.	Standard
ECMAScript 5.1 (ECMA-262) Définition de "Le type d'Opérateur" dans cette spécification.	Standard
ECMAScript 3e édition (ECMA-262) Définition de "Le type d'Opérateur" dans cette spécification.	Standard
ECMAScript 1ère édition (ECMA-262) Définition de "Le type d'Opérateur" 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

	Des ordinateurs						Mobile						serveur
	Chrome	bord	Firefox	Internet Explorer	Opéra	safari	vue Web Android	Chrome pour Androïd	Firefox pour Androïd	Opéra pour Android	Safari sur iOS	Internet Samsung	Node.js
Type de	Chrome Plein soutien 1	bord Plein soutien 12	Firefox Plein soutien 1	C'EST À DIRE Plein soutien 3	Opéra Plein soutien Oui	safari Plein soutien Oui	vue web android Plein soutien 1	ChromeAndroid Plein soutien 18	FirefoxAndroid Plein soutien 4	OpéraAndroid Plein soutien Oui	SafariiOS Plein soutien Oui	Samsung Internet Androïd Plein soutien 1.0	nodejs Plein soutien Oui

Légende

Plein soutien Plein soutien

Remarques spécifiques à IE

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