1. Fonction:
L'opérateur Typeof renvoie une chaîne qui représente le type de données de l'expression.
Les chaînes possibles sont: "numéro", "String", "Boolean", "Object", "Fonction" et "Undefined".
2. Description de la valeur de retour couramment utilisée
| expression | Valeur de retour |
| type de indéfini | 'indéfini' |
| type de nul | 'objet' |
| type de vrai | 'booléen' |
| typeof 123 | 'nombre' |
| type de "ABC" | 'chaîne' |
| typeof function () {} | 'fonction' |
| Typeof {} | 'objet' |
| typeof [] | 'objet' |
| type d'inconnu | 'indéfini' |
Remarque: Les valeurs de retour du type sont toutes des chaînes, et ce sont tous des en-têtes minuscules.
3. Application régulière:
1). Vérifiez si une variable existe et a une valeur.
Le typeof renvoie "non défini" dans deux cas: lorsqu'une variable n'est pas déclarée et lorsque la valeur d'une variable n'est pas définie. Par exemple:
> Typeof UndeclaredVariable === "Undefined" True
> var déclarévariable;
> Typeof déclarévariable «non défini»
> type de «non défini»
Il existe d'autres moyens de détecter si une valeur n'est pas définie:
> Var Value = Undefined;
> valeur === UNDEFINED VRAI
Cependant, si cette méthode est utilisée sur une variable non déclarée, une exception sera lancée, car seul le typeof peut détecter les variables non déclarées normalement sans signaler une erreur:
> UnclaredVariable === UNDEFINED ReferenceError: UnclaredVariable n'est pas défini
Remarque: les variables non initialisées, les paramètres formels qui ne sont pas transmis dans les paramètres et les propriétés inexistantes n'auront pas les problèmes ci-dessus, car ils sont toujours accessibles et les valeurs sont toujours indéfinies:
> var déclarévariable;
> DÉCLARDVARIABLE === UNDEFINED VRAI
> (fonction (x) {return x === Undefined} ()) true
> ({}). foo === Undefined True
Remarque: Par conséquent, if (window.mayBeUndeclaredVariable) {}
Question: Le type de feu semble compliqué lorsque vous effectuez de telles tâches.
Solution: Ce type de fonctionnement n'est pas très courant, donc certaines personnes pensent qu'il n'est pas nécessaire de trouver une meilleure solution. Cependant, quelqu'un peut proposer un opérateur spécial:
> Faux non déclarévariables définis
> var déclarévariable;
> Faux de la variable déclarée définie
Ou peut-être que quelqu'un a besoin d'un opérateur qui détecte si une variable est déclarée:
> Faux non déclarévariables non déclarés
> var déclarévariable;
> déclaré déclaré VRAI
Note du traducteur: Dans Perl, l'opérateur défini ci-dessus est équivalent à défini (), et l'opérateur déclaré ci-dessus est équivalent à existant (),
2. Déterminez qu'une valeur n'est pas égale à non définie et non égale à Null
Question: Si vous souhaitez détecter si une valeur a été définie (la valeur n'est pas non définie ou nul), alors vous avez rencontré une manifestation étrange de typeof (qui est considéré comme un bug): typeof Null Renvoie "Objet":
> Type de «objet» nul
Remarque: Cela ne peut être considéré comme un bogue dans l'implémentation d'origine JavaScript, et la norme est désormais standardisée. V8 a une fois corrigé et implémenté le type de null === "null", mais il s'est finalement révélé impossible. http://wiki.ecmascript.org/doku.php?id=harmony:typeof_null
Solution: N'utilisez pas de type de tâche pour effectuer cette tâche, utilisez la méthode suivante à la place: cependant, la variable X doit être déclarée à l'avance, sinon une erreur sera signalée.
fonction isDefined (x) {return x! == null && x! == Undefined; }
Une autre possibilité consiste à introduire un "opérateur de valeur par défaut". Si MyValue n'est pas défini, l'expression suivante renverra defaultValue:
MyValue || DefaultValue
L'expression ci-dessus est équivalente à:
(MyValue! == Undefined && myvalue! == null)? MyValue: DefaultValue
En fait, c'est une simplification de l'énoncé suivant:
myvalue = myvalue || DefaultValue
3. Distinguer les valeurs des objets et les valeurs d'origine
La fonction suivante est utilisée pour détecter si X est une valeur d'objet:
fonction isObject (x) {return (typeof x === "function" || (typeof x === "objet" && x! == null)); }
Problème: La détection ci-dessus est plus compliquée car le typeof traite les fonctions et les objets comme différents types, et le type de renvoie nul "objet".
Solution: Les méthodes suivantes sont également souvent utilisées pour détecter les valeurs des objets:
fonction isObject2 (x) {return x === objet (x); }
AVERTISSEMENT: Vous pouvez penser que l'instance d'objet peut être utilisée pour le détecter ici, mais l'instance est utilisée pour juger la relation d'instance en utilisant un prototype à l'aide d'un objet. Alors, que dois-je faire si un objet sans prototype:
> var obj = object.create (null);
> Objet.getprototype de (obj) null
OBJ est en effet un objet, mais ce n'est pas une instance de valeur:
> type OBJ 'objet'
> instance obj de l'objet faux
En pratique, vous pouvez rarement rencontrer un tel objet, mais il existe et a son objectif.
Remarque du traducteur: Object.prototype est un objet qui existe par défaut et n'a pas de prototype.
> Object.getprototypeof (object.prototype) null
> type d'objet.prototype 'objet'
> Objet.prototype instance de l'objet faux
4. Quel est le type de valeur d'origine?
Le typeof est le meilleur moyen de visualiser un type d'une certaine valeur d'origine.
> Typeof "ABC" 'String'
> type de «non défini»
Question: Vous devez connaître le comportement étrange du type de null.
> Typeof Null // Soyez prudent! 'objet'
Solution: La fonction suivante peut résoudre ce problème (pour ce cas d'utilisation uniquement).
fonction getPriMiteTypeEName (x) {
var typename = typeof x;
commutateur (typename) {
Case "Undefined": Case "Boolean": Case "Number": case "String": return typename;
case "objet": if (x === null) {return "null"; }
par défaut: // Le jugement précédent n'a pas réussi à passer de New TypeError ("Le paramètre n'est pas une valeur primitive:" + x);
}}
Une meilleure solution: implémentez une fonction getTyPename (), qui peut non seulement renvoyer le type de la valeur d'origine, mais également renvoyer l'attribut interne [[classe]] de la valeur de l'objet. Ici, nous parlons de la façon d'implémenter cette fonction (Note du traducteur: $. Type dans jQuery est l'implémentation comme celle-ci)
5. Si une valeur est une fonction
Le typeof peut être utilisé pour détecter si une valeur est une fonction.
> typeof function () {} 'fonction'
> type d'objet.prototype.tostring 'fonction'
En principe, l'instance de fonction peut également effectuer ce type de détection des exigences. À première vue, il semble que l'écriture soit plus élégante. Cependant, le navigateur a une bizarrerie: chaque cadre et fenêtre a sa propre variable globale. Par conséquent, si vous transmettez un objet dans un certain cadre dans un autre cadre, l'instance OFF ne fonctionne pas correctement parce que les deux cadres ont des constructeurs différents. C'est pourquoi il existe une méthode array.isArray () dans ecmascript5. Ce serait bien s'il existe une méthode qui traverse le cadre pour vérifier si un objet est une instance d'un constructeur donné. Le GetTyPename () ci-dessus est une solution de contournement, mais il y a peut-être une solution plus fondamentale.
6. Présentation
Les éléments mentionnés suivants devraient être le besoin le plus urgent de JavaScript à l'heure actuelle, et il peut remplacer certaines caractéristiques fonctionnelles des responsabilités actuelles du type de:
isDefined () (comme object.isdefined ()): il peut être utilisé comme fonction ou opérateur
isObject ()
getTyPename ()
Un mécanisme qui peut détecter si un objet est une instance d'un constructeur spécifié dans les cadres
Pour vérifier si une variable a été déclarée pour une telle exigence, il peut ne pas être nécessaire d'avoir son propre opérateur.
Le résumé ci-dessus de l'utilisation du type de JS est l'ensemble du contenu partagé par l'éditeur. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.