Maison > Article > interface Web > Quels sont les types de données de JavaScript ? Introduction aux types de données js
Ce que cet article vous apporte, c'est quels sont les types de données de JavaScript ? L'introduction des types de données js a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer, j'espère que cela vous sera utile.
1. Combien de types de valeurs JavaScript possède-t-il ?
Javascript a deux types de données, à savoir les types de données de base et les types de données de référence. Les types de données de base incluent Non défini, Null, Booléen, Nombre, Chaîne, Symbole. (Nouveau dans ES6, représentant des valeurs uniques) et les types de données de référence sont collectivement appelés objets Objet, qui incluent principalement des objets, des tableaux et des fonctions. Examinons ensuite respectivement les caractéristiques des deux.
2. Types de données de base
1. La valeur est immuable
var name = 'java'; name.toUpperCase(); // 输出 'JAVA' console.log(name); // 输出 'java'
On peut voir que la valeur du type de données de base est immuable
2. Stocké dans la zone de pile
Le type de données d'origine est un simple segment de données directement stocké dans la pile et a souvent une taille fixe. données utilisées. Alors mettez-les sur la pile et stockez-les.
3. Comparaison de valeurs
var a = 1; var b = true; console.log(a == b); // true console.log(a === b); // false
== : Seule la comparaison de valeurs est effectuée et la conversion du type de données est effectuée.
=== : comparez non seulement les valeurs, mais comparez également les types de données.
3. Types de données de référence
1. La valeur est variable
var a={age:20}; a.age=21; console.log(a.age)//21
Le code ci-dessus montre que les types de référence peuvent avoir des propriétés et des méthodes. , Et cela peut être modifié dynamiquement.
2. Enregistré dans la mémoire de pile et dans la mémoire de tas en même temps
Le type de données de référence est stocké dans le tas (heap), qui occupe un grand espace et n'est pas de taille fixe. S'il est stocké dans la pile, cela affectera les performances du programme ; le type de données de référence stocke un pointeur sur la pile, qui pointe vers l'adresse de départ de l'entité dans le tas. Lorsque l'interpréteur recherche une valeur de référence, il récupère d'abord son adresse sur la pile puis obtient l'entité du tas.
3. La comparaison est une comparaison de référence
Lors de l'attribution d'une valeur de type référence d'une variable à une autre variable, la même chose Copie également la valeur de l'objet stocké dans la variable dans l'espace alloué à la nouvelle variable.
var a={age:20}; var b=a; b.age=21; console.log(a.age==b.age)//true
Nous avons mentionné ci-dessus que les types de base et les types de référence sont stockés à différents emplacements de la mémoire. Les types de référence sont stockés dans les objets du tas. En même temps, un pointeur est stocké dans la pile. ce pointeur pointe vers l'emplacement correct. Est la position de départ de l'entité dans le tas. Lorsque la variable a est initialisée, le pointeur a pointe vers l'adresse de l'objet {age:20}. Une fois a attribué à b, b pointe vers l'adresse de l'objet {age:20}. Par conséquent, la modification de l’une de ces variables s’affectera mutuellement.
À ce stade, si une variable fait référence à l'objet d'origine, elle n'affectera pas l'autre variable.
var a={age:20}; var b=a; a = 1; b // {age:20}
Dans le code ci-dessus, a et b pointent vers le même objet, puis la valeur de a passe à 1. Cela n'affectera pas b, et b pointe toujours vers l'objet d'origine.
4. Vérifiez le type de données
1.typeof
typeof renvoie une chaîne représentant le type de données. Les résultats renvoyés incluent : nombre, booléen. , Il existe 7 types de données tels que chaîne, symbole, objet, non défini et fonction, mais null, tableau, etc. ne peuvent pas être jugés
typeof Symbol(); // symbol 有效 typeof ''; // string 有效 typeof 1; // number 有效 typeof true; //boolean 有效 typeof undefined; //undefined 有效 typeof new Function(); // function 有效 typeof null; //object 无效 typeof [] ; //object 无效 typeof new Date(); //object 无效 typeof new RegExp(); //object 无效
Les tableaux et les objets renvoient des objets Dans ce cas, vous avez besoin. utiliser instanceof pour juger
2.instanceof
instanceof est utilisé pour déterminer si A est une instance de B. L'expression est : Une instance de B. Si A est une instance de B, il renvoie vrai, sinon il renvoie faux. L'opérateur instanceof est utilisé pour tester si un objet possède la propriété prototype d'un constructeur dans sa chaîne de prototypes.
[] instanceof Array; //true {} instanceof Object;//true new Date() instanceof Date;//true new RegExp() instanceof RegExp//true
Concernant le jugement de type des tableaux, vous pouvez également utiliser ES6 pour ajouter Array.isArray()
Array.isArray([]); // true
instance de trois inconvénients majeurs :
Pour les types de données de base, il existe certaines différences entre les résultats créés par les littéraux et ceux créés par les instances
console.log(1 instanceof Number)//false console.log(new Number(1) instanceof Number)//true
À proprement parler, seuls les résultats créés par les instances sont La valeur du type de données d'objet standard est également une instance de la classe Number standard ; le résultat créé par la méthode littérale est une valeur de type de données de base, et non une instance stricte. Cependant, en raison des caractéristiques lâches de JS, les méthodes Number peuvent être utilisées sur le prototype.
Tant qu'il se trouve sur la chaîne de prototypes de l'instance actuelle, le résultat que nous détectons en l'utilisant est vrai. Dans l’héritage prototypique d’une classe, le résultat final que nous détectons peut ne pas être précis.
var arr = [1, 2, 3]; console.log(arr instanceof Array) // true console.log(arr instanceof Object); // true function fn(){} console.log(fn instanceof Function)// true console.log(fn instanceof Object)// true
Impossible de détecter null et indéfini
Pour les types de données spéciaux null et indéfinis, leurs classes sont Null et Undefined, mais le navigateur protège ces deux classes. Nous ne sommes pas autorisés à visiter. et utilisez-le à l'extérieur.
3. Opérateur strict ===
只能用于判断null和undefined,因为这两种类型的值都是唯一的。
var a = null typeof a // "object" a === null // true
undefined 还可以用typeof来判断
var b = undefined; typeof b === "undefined" // true b === undefined // true
4.constructor
constructor作用和instanceof非常相似。但constructor检测 Object与instanceof不一样,还可以处理基本数据类型的检测。
var aa=[1,2]; console.log(aa.constructor===Array);//true console.log(aa.constructor===RegExp);//false console.log((1).constructor===Number);//true var reg=/^$/; console.log(reg.constructor===RegExp);//true console.log(reg.constructor===Object);//false
constructor 两大弊端:
null 和 undefined 是无效的对象,因此是不会有 constructor 存在的,这两种类型的数据需要通过其他方式来判断。
函数的 constructor 是不稳定的,这个主要体现在把类的原型进行重写,在重写的过程中很有可能出现把之前的constructor给覆盖了,这样检测出来的结果就是不准确的
function Fn(){} Fn.prototype = new Array() var f = new Fn console.log(f.constructor)//Array
5.Object.prototype.toString.call()
Object.prototype.toString.call() 最准确最常用的方式。首先获取Object原型上的toString方法,让方法执行,让toString方法中的this指向第一个参数的值。
关于toString重要补充说明:
本意是转换为字符串,但是某些toString方法不仅仅是转换为字符串
对于Number、String,Boolean,Array,RegExp、Date、Function原型上的toString方法都是把当前的数据类型转换为字符串的类型(它们的作用仅仅是用来转换为字符串的)
Object上的toString并不是用来转换为字符串的。
Object上的toString它的作用是返回当前方法执行的主体(方法中的this)所属类的详细信息即"[object Object]",其中第一个object代表当前实例是对象数据类型的(这个是固定死的),第二个Object代表的是this所属的类是Object。
Object.prototype.toString.call('') ; // [object String] Object.prototype.toString.call(1) ; // [object Number] Object.prototype.toString.call(true) ; // [object Boolean] Object.prototype.toString.call(undefined) ; // [object Undefined] Object.prototype.toString.call(null) ; // [object Null] Object.prototype.toString.call(new Function()) ; // [object Function] Object.prototype.toString.call(new Date()) ; // [object Date] Object.prototype.toString.call([]) ; // [object Array] Object.prototype.toString.call(new RegExp()) ; // [object RegExp] Object.prototype.toString.call(new Error()) ; // [object Error] Object.prototype.toString.call(document) ; // [object HTMLDocument] Object.prototype.toString.call(window) ; //[object global] window是全局对象global的引用
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!