Valeurs primitives et complexes dans les astuces JavaScript_javascript

Mots précédents

Les types de données JavaScript peuvent être divisés en deux types : les types primitifs et les types de référence. Les types primitifs sont également appelés types de base ou types simples. Les types de données de base de JavaScript incluent les types non définis, nuls, booléens, numériques et de référence, également appelés types complexes, qui sont des objets en Javascript. En conséquence, leurs valeurs sont également appelées respectivement valeurs primitives et valeurs complexes

Fonctionnalités

Valeur primitive

Pour faire simple : les valeurs primitives sont des valeurs fixes et simples, qui sont de simples segments de données stockés dans la pile, c'est-à-dire que leurs valeurs sont stockées directement à l'emplacement d'accès aux variables.

Une valeur primitive est la forme la plus basse ou la plus simple qui représente des données ou des informations disponibles en Javascript. Les valeurs de types primitifs sont appelées valeurs primitives car elles ne sont pas réductibles. C'est-à-dire que les nombres sont des nombres, les caractères sont des caractères, les valeurs booléennes sont vraies ou fausses et null et indéfini sont nulles et indéfinies. Les valeurs elles-mêmes sont simples et ne peuvent pas représenter des valeurs composées d'autres valeurs

Quels types sont des types primitifs ?

Le type primitif a les cinq types suivants : non défini, nul, booléen, nombre, chaîne

Nous pouvons utiliser typeof pour déterminer si un type entre dans la portée d'un certain type.

type d'opérateur

L'utilisation de l'opérateur typeof sur une variable ou une valeur renverra l'une des valeurs suivantes :

Remarque :

1. La valeur de retour est de type chaîne.

2. Par rapport au type d'origine, il existe toujours une différence nulle. C'est assez spécial. L'utilisation de typeof(null) renvoie "object".

Valeur complexe

Les valeurs complexes peuvent être composées de nombreux types différents d'objets JavaScript. La taille d'un objet complexe en mémoire est inconnue car un objet complexe peut contenir n'importe quelle valeur plutôt qu'une valeur spécifique connue

Méthode de stockage

Stockage en pile

Étant donné que la valeur d'origine occupe un espace fixe et est un simple segment de données, afin d'améliorer la vitesse de requête des variables, elle est stockée dans la pile

Stockage en tas

Étant donné que la taille de la valeur complexe va changer, elle ne peut pas être stockée sur la pile, sinon cela réduira la vitesse de requête de la variable, elle est donc stockée dans le tas (tas). La valeur stockée dans la variable est un pointeur. pointant vers l'objet de stockage L'emplacement mémoire

Méthode d'accès

Accès par valeur

Les valeurs primitives sont stockées et manipulées comme des valeurs non réductibles, leur référencement transfère leur valeur

var myString = 'foo';
var myStringCopy = myString;
var myString = null;
console.log(myString,myStringCopy);//null,'foo' 

Visite de devis

Les valeurs complexes sont stockées et manipulées par référence, et non par la valeur réelle. Lorsque vous créez une variable contenant un objet complexe, sa valeur est une adresse de référence en mémoire. Lorsque vous référencez un objet complexe, utilisez son nom (c'est-à-dire une variable ou une propriété d'objet) pour obtenir la valeur de l'objet via l'adresse de référence en mémoire

var myObject = {};
var copyOfMyObject = myObject;//没有复制值，而是复制了引用
myObject.foo = 'bar';//操作myObject中的值
//现在如果输出myObject和copyOfMyObject，则都会输出foo属性，因为它们引用的是同一个对象
console.log(myObject,copyOfMyObject);//Object{foo="bar"} 

Comparaison

Les valeurs primitives utilisent la comparaison de valeurs, tandis que les valeurs complexes utilisent la comparaison de références. Les valeurs complexes ne sont égales que si elles font référence au même objet (c'est-à-dire qu'elles ont la même adresse). Même deux variables contenant le même objet ne sont pas égales car elles ne pointent pas vers le même objet

var price1 = 10;
var price2 = 10;
var price3 = new Number('10');
var price4 = price3;
console.log(price1 == price2);//true
console.log(price1 == price3);//false
price4 = 10;
console.log(price4 == price3);//true
console.log(price4 === price3);//false 
var objectFoo = {same:'same'};
var objectBar = {same:'same'};
console.log(objectFoo == objectBar);//false
var objectA = {foo: 'bar'};
var objectB = objectA;
console.log(objectA == objectB);//true 

Attributs dynamiques

Pour les valeurs complexes, vous pouvez leur ajouter des propriétés et des méthodes, et vous pouvez également modifier et supprimer leurs propriétés et méthodes ; mais les valeurs simples ne peuvent pas ajouter de propriétés et de méthodes

Les valeurs complexes prennent en charge les propriétés d'objet dynamiques car nous pouvons définir un objet, puis créer une référence, puis mettre à jour l'objet, et toutes les variables pointant vers l'objet seront mises à jour. Une nouvelle variable pointe vers un objet complexe existant et l'objet n'est pas copié. C'est pourquoi les valeurs complexes sont parfois appelées valeurs de référence. Les valeurs complexes peuvent avoir autant de références que nécessaire, et elles pointent toujours vers le même objet même si l'objet change

var str = 'test';
str.property = true;
console.log(str.property);//undefined　 
var objA = {property: 'value'};
var pointer1 = objA;
var pointer2 = pointer1;
objA.property = null;
console.log(objA.property,pointer1.property,pointer2.property);//null null null 

포장형태

생성자가 생성한 객체로 원시값을 사용하면 자바스크립트는 객체의 속성과 메소드를 사용할 수 있도록 이를 객체로 변환한 후 객체 속성을 버리고 다시 원시값으로 변경합니다.