Comment obtenir le type de données précis d’une variable en JavaScript

Posted on mars 2, 2021 by admin

Introduction

L’une des caractéristiques de langue javascript les plus controversées est sa typographie douce ou dynamique dont nous avons déjà parlé parfois. Cela signifie que, contrairement aux autres langues classiques telles que C ou Java, lorsque nous déclarons des variables, nous n’avons pas besoin de spécifier le type de données qu’ils contiendront. De plus, la même variable, peut posséder plusieurs types différents dans différents moments d’exécution: peut commencer à être une gamme, devenez une matrice puis, par exemple, finalement être un objet.

Cette flexibilité qu’il a Avantages très intéressants pour le développement d’applications complexes car il n’y a pas de limitations priories quant à la variable pouvant stocker. Cependant, pour ceux qui viennent d’autres langages pointillés, l’un des problèmes de ce concept est qu’il est très difficile d’identifier le type de données spécifique qu’une variable a à un moment donné de l’exécution.

Identification Le type

efficacement, JavaScript ne possède pas de moyen univocal pour identifier le type de données contenant une variable à un moment donné. Nativement, nous avons deux instructions qui peuvent nous donner une valeur approximative mais que, malheureusement, ne sont pas finales: typeof et instanceOf.

L’opérateur de typeOf

typeof est un opérateur UNAR, quoi ce qui signifie qu’il accepte seulement (et fonctionne) sur un seul argument; Dans ce cas une variable:

type de 2; // numptypeof ‘hello world’ // stringtypeof // objet

Cet opérateur n’est pas une fonction; Cependant, des parenthèses peuvent être utilisées pour regrouper les termes à évaluer:

<6 cec4a2976 ">

typeof (2); // NUBERTYPEOF (‘Hello World’); // stringtypeof (‘foo’, 4); // Nombre

Remarque: Les groupements d’arguments en JavaScript déterminent la valeur finale d’un élément à l’aide d’opérateurs internes. Ces opérateurs indiquent l’ordre dans lequel les termes sont évalués, tels que la virgule, qui rend cette évaluation de gauche à droite pour renvoyer la valeur du deuxième opérande. Pour plus d’informations sur cet aspect linguistique, l’élément de la virgule JavaScript est recommandé.

Le tableau suivant indique la correspondance d’objets JavaScript et la valeur obtenue avec typef:

type

résultat
non défini	« non défini »
null	« objet »
booléen	« booléen »
numéro	« numéro »
string	« string »
objet hôte (dans le JS Environnement)	dépend de la mise en oeuvre
fonction
objet xml e4x	« xml »
xmllist e4x	« xml »
Tout autre objet	« objet

Comment pouvons-nous voir Il n’ya aucune référence dans le tableau avant d’éléments tels que des tableaux, des dates, des expressions régulières, etc. Cela signifie que pour le typeOf, ces éléments sont un objet de plus. De plus, nous voyons des résultats qui peuvent sembler déroutant comme NULL dans lequel nous obtenons un type de nouvel « objet »:

« 6cec4a2976″>

type de nan; // NUBERTYPEOFF INFINITY; // NUBERTYPEOF (1/0); // nucbertypeof (typef); // string

Il semble que nous ne puissions pas trop faire confiance à cet opérateur pour déterminer le type de données que nous avons évaluées, il peut donc être intéressant de rechercher un autre plus sûr ou plus complet solution.

objet.pototype.string

La fonction de tostrage, renvoie une chaîne qui représente l’objet indiqué comme argument:

objet.pototype.tring (); //

Laissez-nous voir le résultat: « »: Selon la spécification ECMAScript5, objet.pototype.string renvoie en conséquence la concaténation de la chaîne « objet » plus la Valeur interne de l’objet Ce qui est passé (ce que nous appelons classe de classe) …

]

Tous les objets JavaScript ont un propriétaire interne appelé] (la notation avec double fermoir est identique à celui utilisé dans la spécification ES5). Selon ES5,] est une chaîne avec une seule valeur (non modifitable) qui identifie chaque objet. Par conséquent, un objet invoqué avec le constructeur et qui n’a pas été modifié, revient comme valeur de cette propriété le type d’objet précis auquel il appartient:

var o = nouvel objet (); ou.piquer (); //

Cependant, nous voyons que cet opérateur est également fragile lorsque nous l’appliquons sur des objets courants:

.Ring (); // « Foo, bar, 1 » « Hello World » .Tostring (); // « bonjour monde » /a-z/.lestring (); // « / A-Z / »

Ceci est ainsi parce que les objets personnalisés écrasent l’objet.Prototype.string méthode avec le vôtre. Un moyen de résoudre ce problème est d’invoquer cette méthode directement à partir de l’objet d’objet et d’utiliser la fonction d’appel pour injecter l’argument souhaité:

objet.prothotype.tring.call (); // objet.pototype.toscall (« Hello World »); // objet.pototype.tring.call (/ a-z /); //

De cette manière, nous évitons tout écrasé et que le résultat obtenu est prévu: nous avons le type de données correct.

Création d’une fonction pour Déterminez le type de données

extrait directement de l’article de crollage Angus, nous pouvons utiliser la fonction suivante pour obtenir le type de données correct d’une variable ou d’un objet:

var toype = fonction (obj) {retour ({}). Tostring.Call (obj) .Match (/ \ s (S (+) /) . Tolowercase ()}

examinons-le en parties:

({}). Tostring est une abréviation (un raccourci) de l’objet .Pototype. ToasRing Depuis, dans tout nouvel objet, la méthode de la totring fait référence à la définition donnée par objet.Prototype comme nous l’avons vu ci-dessus.
appelt que nous l’utilisons ici afin que la méthode précédente soit faite sur l’argument que nous indiquons, dans ce cas, un autre objet.
match: Nous utilisons une expression régulière pour extraire le type de données sans la CADEN Chez «objet» initial et les crochets. Nous utilisons une expression régulière au lieu d’une tranche ou une autre méthode due aux meilleures performances qu’il offre sur le reste.
Tolowercase: Nous passons par minuscule pour différencier le type de ce qui serait la référence à l’instance de Un objet et que, généralement, il est majuscule.

Voyons comment la fonction se comporte:

Totype ({A: 4}); // « objet » totype (); // « tableau » (fonction () {console.log (totype (arguments))); // argument detotype (nouvelle référenceError); // « Erreur » Totype (nouvelle date); // « DATE » TOTYPE (/ A-Z /); // « Regexp » Totype (Math); // « Math » Totype (Json); // « JSON » Totype (nouveau numéro (4)); // « Numéro » Totype (nouvelle chaîne (« ABC »); // « chaîne » Totype (nouveau boolean (true)); // « booléen »

et comparons-le avec ce que nous recevrions avec typeof:

typeof {A: 4}; // « objet » typef; // « objet » (fonction () {console.log (typeof arguments)}) (); // objet depeof nouvelle référence; // « objet » typef nouvelle date; // « objet » typeof / a-z /; // « objet » type de math; // « objet » type de json; // « objet » de type de nouveau numéro (4); // « objet » type de nouvelle chaîne (« ABC »); // « objet » type de nouveau booléen (vrai); // « objet »

La différence dans la plupart des cas est importante: de l’imprécision de typeof nous avons ensuite obtenu des types spécifiques.

comparaison avec l’instanceOf

L’utilisateur de l’utilisateur vérifie la chaîne prototypique du premier opérande à la recherche de la présence de la propriété prototypique de la seconde, qui devrait correspondre à un constructeur:

nouvelle instance de date de date; // valeur true d’instance de TRUE; // true

Le problème de cet opérateur est que certains objets de JavaScript ne possèdent pas de constructeur associé, de sorte qu’ils ne peuvent pas être évalués correctement par l’instance de:

Instance mathématique de math // typeError

Il y a aussi le problème de ces environnements avec plusieurs images où la présence de plusieurs contextes globaux (un pour chaque image) empêche d’assurer qu’un objet donné est une instance d’un certain constructeur:

Var iframe = document.createelement (‘iframe’); document.body.appendchild (iframe); var iframearray = window.frames.array; Var Array = nouvel iframearray (); Array Instanceof Tableau; // instance FALEARRARAY de l’iframearray; // true;

limitations

La fonction Totype ne peut pas être empêchée d’erreurs contre les types de données inconnus:

objet.totype (FFF); // référenceurror

Spécifiquement, c’est l’appel à Totype qui lance l’erreur, pas la fonction elle-même. Le seul moyen d’empêcher que cela utilise la comparaison implicite qui nous permettrait le système de court-circuit JavaScript:

 fenêtre.fff & & objet.TOTYPE (FFF);

Si la première condition est remplie, la suivante est poursuivie; Sinon, le circuit est coupé et l’erreur est évitée.

Conclusion

En Javacript, nous ne pouvons pas déterminer avec précision le type de données d’une variable à l’aide des méthodes natives qu’il fournit la langue. lui-même. Habituellement, lorsque nous devons identifier des types, nous avons généralement recours à des techniques approximatives telles que la typage du canard. Toutefois, dans les applications où l’intégrité est essentielle, cette technique ne permet pas que la rigueur requise.

Typeof et InstanceOf ne propose pas de contrôle rigoureux, fiable et univocal sur les types dont nous pourrions avoir besoin pendant un développement. Pour essayer de résoudre ce problème, nous utilisons certaines des particularités de la langue telles que la valeur], pour obtenir un résultat beaucoup plus précis.

Cet article est une traduction élargie de l’original de crollan Angus: fixer le JavaScript Opérateur de type de fichier.