En savoir plus sur les compétences JavaScriptobjects

En JavaScript, à l'exception des cinq types primitifs (c'est-à-dire les nombres, les chaînes, les valeurs booléennes, nulles et non définies), ce sont tous des objets. Alors, comment pouvez-vous continuer à apprendre si vous ne comprenez pas les objets ?

1. Aperçu

Un objet est une valeur composite qui regroupe de nombreuses valeurs (valeurs primitives ou autres objets), accessibles via les noms de propriétés. Le nom de l'attribut peut être n'importe quelle chaîne, y compris la chaîne vide. Les objets JavaScript peuvent également être appelés structure de données, comme on entend souvent parler de « hachage », « table de hachage », « dictionnaire » et « tableau associatif ».

Les objets en JavaScript peuvent être divisés en trois catégories :

①Objets intégrés, tels que des tableaux, des fonctions, des dates, etc.

②L'objet hôte est défini par l'environnement hôte (tel que le navigateur) dans lequel l'interpréteur JavaScript est intégré, tel que HTMLElement, etc.;

③ Objets personnalisés, qui sont définis par les programmeurs dans le code

Les propriétés des objets peuvent être

divisées en deux catégories :

①Propre propriété : Propriétés définies directement dans l'objet

②Propriété héritée : propriétés définies dans l'objet prototype de l'objet (l'objet prototype sera discuté en détail ci-dessous) ;

2. Création d'objets

Puisque vous apprenez des objets, comment ne pas comprendre comment créer des objets ? Les étudiants qui passent un entretien pour des postes front-end se sont peut-être vu poser cette question de base :

Quelles sont les deux manières de créer des objets JavaScript ? (Ou : dites-moi comment créer des objets JavaScript ?)

On m'a posé cette question deux fois. Il existe de nombreux dictons sur Internet concernant « deux façons de créer des objets », mais d'après les livres que j'ai lus, il y a trois façons ! Parlons de ces trois méthodes en détail ci-dessous :

1. Quantité directe de l'objet

Le littéral d'objet est une table de mappage composée de plusieurs paires nom/valeur. Les paires nom/valeur sont séparées par des deux-points, les paires nom/valeur sont séparées par des virgules et la table de mappage entière est entourée d'accolades. Le nom de l'attribut peut être un identifiant JavaScript ou une chaîne littérale. C'est-à-dire que les deux manières suivantes d'écrire l'objet obj sont exactement les mêmes :

var obj = {x : 1, y : 2};

var obj = {'x' : 1, 'y' :2};

2. Créez des objets grâce à de nouveaux

L'opérateur new est suivi d'un appel de fonction, le constructeur, qui crée et initialise un nouvel objet. Par exemple :

1 var o = new Object(); //Créer un objet vide, identique à {}

2 var a = new Array(); //Créer un tableau vide, identique à []

3 var d = new Date(); //Créer un objet Date représentant l'heure actuelle

Nous parlerons du contenu lié au constructeur plus tard.

3.Object.create()

ECMAScript5 définit une méthode appelée Object.create(), qui crée un nouvel objet. Le premier paramètre est l'objet prototype de cet objet (il semble que l'objet prototype n'ait pas encore été expliqué... Je vais en parler. bientôt), et le deuxième paramètre est l'objet prototype de cet objet. Un paramètre facultatif est utilisé pour décrire plus en détail les propriétés de l'objet. Le deuxième paramètre sera discuté ci-dessous (car cette troisième méthode est définie dans ECMAScript5, donc tout le monde en parle souvent. sur les deux méthodes de création d'objets dans le passé, non personnellement je pense que c'est la raison). Cette méthode est très simple à utiliser :

1 var o1 = Object.create({x: 1, y: 2}); //Object o1 hérite des attributs x et y

2 var o2 = Object.create(null); //L'objet o2 n'a pas de prototype

Les trois suivants sont exactement les mêmes :

1 var obj1 = {};

2 var obj2 = nouvel Objet();

3 var obj3 = Object.create(Object.prototype);

Afin d'expliquer pourquoi ces trois méthodes sont exactement les mêmes, expliquons d'abord l'objet prototype en JavaScript (oh, je t'ai fait attendre longtemps ! je me souviens qu'un grand dieu a dit :

Javascript est un langage basé sur les objets, et presque tout ce que vous rencontrez est un objet. Cependant, il ne s’agit pas d’un véritable langage de programmation orienté objet (POO) car sa syntaxe ne comporte aucune classe.

Langage de programmation orienté objet JavaScript, pas de classes ! ! ! Alors, comment implémente-t-il l’héritage ? C'est vrai, via l'objet prototype. Fondamentalement, chaque objet JavaScript (sauf null) est associé à un autre objet. L'objet "autre" est ce qu'on appelle l'objet prototype (l'objet prototype peut également être appelé prototype pour faire court. Ce n'est pas aussi compliqué qu'on l'imagine, c'est n'est qu'un objet). Chaque objet hérite des propriétés de l'objet prototype, et la valeur de la propriété prototype d'un objet (cette propriété est automatiquement générée par défaut lors de la création de l'objet et ne nécessite pas de personnalisation explicite) est l'objet prototype de l'objet, c'est-à-dire obj.prototype est l'objet L'objet prototype d'obj.

Parlons d'abord des objets prototypes. Pour revenir à la question ci-dessus, avec la compréhension des objets prototypes, voici les réglementations du langage JavaScript qui ne nécessitent pas trop d'explications :

①L'objet prototype de tous les objets créés via des littéraux d'objet est l'objet Object.prototype

;

②L'objet prototype de l'objet créé via le mot-clé new et la fonction constructeur est la valeur de l'attribut prototype de la fonction constructeur, donc le prototype de l'objet créé via la fonction constructeur Object est Object.prototype ;

La signification du premier paramètre de la troisième méthode de création d'objets, Object.create(), est désormais également ajoutée.

3. Requête et paramétrage d'attribut

Apprendre à créer des objets ne suffit pas, car les objets ne peuvent vraiment jouer un rôle que s'ils possèdent certaines propriétés ! Alors continuons à apprendre les propriétés des objets !

La valeur d'un attribut peut être obtenue et définie à l'aide des opérateurs point (.) ou crochet ([]). Pour le point (.), le côté droit doit être un identifiant nommé d'après le nom de l'attribut (remarque : les identifiants du langage JavaScript ont leurs propres règles juridiques et sont différents des chaînes entre guillemets ([] ), les crochets doivent) ; être une expression de chaîne (bien sûr, des variables de chaîne peuvent également être utilisées, ainsi que d'autres valeurs qui peuvent être converties en chaînes, telles que des nombres, etc.), et cette chaîne est le nom de l'attribut. Tout comme l'exemple suivant :

var obj = {x: 1, y: 2}; 
obj.x = 5; 
obj['y'] = 6

Copier après la connexion

Comme mentionné dans la présentation, les objets JavaScript ont des « propriétés propres » et des « propriétés héritées ». Lors de l'interrogation de l'attribut Si l'objet prototype obj.prototype.prototype de .prototype a l'attribut x, c'est jusqu'à ce que x soit trouvé ou que l'objet prototype trouvé soit un objet non défini. Comme vous pouvez le voir, un objet hérite de nombreux objets prototypes, et ces objets prototypes forment une "chaîne". C'est ce que nous appelons habituellement la "chaîne prototype". Ce type d'héritage est aussi "l'héritage prototypique" en JavaScript (héritage prototypique). ).

Lorsque l'objet o interroge un certain attribut, il recherchera étape par étape le long de la chaîne de prototypes comme mentionné ci-dessus, mais lorsqu'il définit la valeur d'un certain attribut, il ne modifiera que ses propres attributs (si l'objet n'a pas cet attribut, il sera ajouté (Cette propriété et attribuant une valeur) ne modifiera pas les propriétés des autres objets de la chaîne prototype.

4. Getter et setter d'attribut accesseur

Ce dont nous avons parlé ci-dessus, ce sont des propriétés d'objet très courantes. Ce type de propriété est appelé « propriété de données », et la propriété de données n'a qu'une seule valeur simple. Cependant, dans ECMAScript 5, les valeurs de propriété peuvent être remplacées par une ou deux méthodes. Ces deux méthodes sont des getters et des setters. Les propriétés définies par les getters et les setters sont appelées « propriétés d'accesseur ».

Lorsqu'un programme interroge la valeur d'une propriété d'accesseur, JavaScript appelle la méthode getter (sans paramètres). La valeur de retour de cette méthode est la valeur de l'expression d'accès à l'attribut. Lorsqu'un programme définit la valeur d'une propriété d'accesseur, JavaScript appelle la méthode setter, en transmettant la valeur située à droite de l'expression d'affectation en tant que paramètre au setter. Si une propriété possède à la fois des méthodes getter et setter, il s'agit alors d'une propriété en lecture/écriture ; si elle n'a qu'une méthode getter, il s'agit alors d'une propriété en lecture seule. L'attribution d'une valeur à une propriété en lecture seule ne signalera pas d'erreur. , mais cela ne réussira pas ; s’il n’a qu’une méthode setter, alors c’est une propriété en écriture seule, et la lecture d’une propriété en écriture seule renvoie toujours undefined. Regardons un exemple pratique :

var p = { 
  x: 1.0, 
  y: 2.0, 
  get r(){ return Math.sqrt(this.x*this.x + this.y*this.y); }; 
  set r(newvalue){ 
    var oldvalue = Math.sqrt(this.x*this.x + this.y*this.y); 
    var ratio = newvalue/oldvalue; 
    this.x *= ratio; 
    this.y *= ratio; 
  }, 
  get theta(){ return Math.atan2(this.y, this.x); }, 
print: function(){ console.log('x:'+this.x+', y:'+this.y); } 
};

Copier après la connexion

Comme écrit dans l'exemple, l'attribut accesseur définit une ou deux fonctions avec le même nom que l'attribut. Cette définition de fonction n'utilise pas le mot-clé function, mais utilise get et set, et n'utilise pas de deux-points pour séparer les deux. nom d'attribut du corps de la fonction séparé. À titre de comparaison, l'attribut print ci-dessous est une méthode fonctionnelle. Remarque : En utilisant ce mot-clé dans getter et setter ici, JavaScript appelle ces fonctions en tant que méthodes d'objets, c'est-à-dire que ceci dans le corps de la fonction pointe vers cet objet. Jetons un coup d'œil aux résultats de l'exemple d'opération :

Tout comme la sortie de la console, r et theta ne sont que des attributs de valeur comme x et y, et print est un attribut de méthode.

L'accesseur ajouté dans ECMAScript 5, bien que plus complexe que les attributs ordinaires, rend également les paires clé-valeur des attributs de l'objet opérationnel plus rigoureuses.

5. Supprimer les attributs

Les programmeurs implémentent généralement les fonctions d'ajout, de suppression, de modification et de vérification lors du codage. Nous avons déjà mentionné l'ajout, la modification et la vérification auparavant.

L'opérateur delete peut supprimer les propriétés d'un objet et son opérande doit être une expression d'accès aux propriétés. Cependant, delete déconnecte uniquement l'attribut de l'objet hôte, mais n'exploite pas les attributs dans l'attribut :

var a = {p:{x:1}}; 
var b = a.p; 
delete a.p;

Copier après la connexion

执行这段代码后b.x的值依然是1，由于已删除属性的引用依然存在，所以有时这种不严谨的代码会造成内存泄露，所以在销毁对象的时候，要遍历属性中的属性，依次删除。

delete表达式返回true的情况：

①删除成功或没有任何副作用（比如删除不存在的属性）时；

②如果delete后不是一个属性访问表达式；

var obj = {x: 1,get r(){return 5;},set r(newvalue){this.x = newvalue;}}; 
delete obj.x;  //删除对象obj的属性x，返回true 
delete obj.x;  //删除不存在的属性，返回true 
delete obj.r;  //删除对象obj的属性r，返回true 
delete obj.toString;  //没有任何副作用（toString是继承来的，并不能删除），返回true 
delete 1;  //数字1不是属性访问表达式，返回true

Copier après la connexion

delete表达式返回false的情况：

①删除可配置性（可配置性是属性的一种特性，下面会谈到）为false的属性时；

delete Object.prototype; //返回false，prototype属性是不可配置的
//通过var声明的变量或function声明的函数是全局对象的不可配置属性
var x = 1;
delete this.x; //返回false
function f() {}
delete this.f; //返回false

六.属性的特性

上面已经说到了属性的可配置性特性，因为下面要说的检测属性和枚举属性还要用到属性的特性这些概念，所以现在就先具体说说属性的特性吧！

除了包含名字和值之外，属性还包含一些标识它们可写、可枚举、可配置的三种特性。在ECMAScript 3中无法设置这些特性，所有通过ECMAScript 3的程序创建的属性都是可写的、可枚举的和可配置的，且无法对这些特性做修改。ECMAScript 5中提供了查询和设置这些属性特性的API。这些API对于库的开发者非常有用，因为：

①可以通过这些API给原型对象添加方法，并将它们设置成不可枚举的，这让它们更像内置方法;

②可以通过这些API给对象定义不能修改或删除的属性，借此“锁定”这个对象；

在这里我们将存取器属性的getter和setter方法看成是属性的特性。按照这个逻辑，我们也可以把属性的值同样看做属性的特性。因此，可以认为属性包含一个名字和4个特性。数据属性的4个特性分别是它的值（value）、可写性（writable）、可枚举性（enumerable）和可配置性（configurable）。存取器属性不具有值特性和可写性它们的可写性是由setter方法是否存在与否决定的。因此存取器属性的4个特性是读取（get）、写入（set）、可枚举性和可配置性。

为了实现属性特性的查询和设置操作，ECMAScript 5中定义了一个名为“属性描述符”（property descriptor）的对象，这个对象代表那4个特性。描述符对象的属性和它们所描述的属性特性是同名的。因此，数据属性的描述符对象的属性有 value、writable、enumerable和configurable。存取器属性的描述符对象则用get属性和set属性代替value和 writable。其中writable、enumerable和configurable都是布尔值，当然，get属性和set属性是函数值。通过调用 Object.getOwnPropertyDescriptor()可以获得某个对象特定属性的属性描述符：

从函数名字就可以看出，Object.getOwnPropertyDescriptor()只能得到自有属性的描述符，对于继承属性和不存在的属性它都返回undefined。要想获得继承属性的特性，需要遍历原型链（不会遍历原型链？不要急，下面会说到的）。

要想设置属性的特性，或者想让新建属性具有某种特性，则需要调用Object.definePeoperty()，传入需要修改的对象、要创建或修改的属性的名称以及属性描述符对象：

可以看到：

①传入Object.defineProperty()的属性描述符对象不必包含所有4个特性；

②可写性控制着对属性值的修改；

③可枚举性控制着属性是否可枚举（枚举属性，下面会说的）；

④可配置性控制着对其他特性（包括前面说过的属性是否可以删除）的修改；

如果要同时修改或创建多个属性，则需要使用Object.defineProperties()。第一个参数是要修改的对象，第二个参数是一个映射表，它包含要新建或修改的属性的名称，以及它们的属性描述符，例如：

var p = Object.defineProperties({},{ 
  x: {value: 1, writable: true, enumerable: true, configurable: true}, 
  y: {value: 2, writable: true, enumerable: true, configurable: true}, 
  r: {get: function(){return 88;}, set: function(newvalue){this.x =newvalue;},enumerable: true, configurable: true}, 
  greet: {value: function(){console.log('hello,world');}, writable: true, enumerable: true, configurable: true} 
});

Copier après la connexion

相信你也已经从实例中看出：Object.defineProperty()和Object.defineProperties()都返回修改后的对象。

前面我们说getter和setter存取器属性时使用对象直接量语法给新对象定义存取器属性，但并不能查询属性的getter和setter方法或给已有的对象添加新的存取器属性。在ECMAScript 5中，就可以通过Object.getOwnPropertyDescriptor()和Object.defineProperty()来完成这些工作啦！但在ECMAScript 5之前，大多数浏览器（IE除外啦）已经支持对象直接量语法中的get和set写法了。所以这些浏览器还提供了非标准的老式API用来查询和设置 getter和setter。这些API有4个方法组成，所有对象都拥有这些方法。__lookupGetter__()和 __lookupSetter__()用以返回一个命名属性的getter和setter方法。__defineGetter__()和 __defineSetter__()用以定义getter和setter。这四个方法都是以两条下划线做前缀，两条下划线做后缀，以表明它们是非标准方法。下面是它们用法：

七.检测属性

JavaScript对象可以看做属性的集合，那么我们有时就需要判断某个属性是否存在于某个对象中，这就是接下来要说的检测属性。

检测一个对象的属性也有三种方法，下面就来详细说说它们的作用及区别！

1.in运算符

in运算符左侧是属性名（字符串），右侧是对象。如果对象的自有属性或继承属性中包含这个属性则返回true，否则返回false。

为了试验，我们先给对象Object.prototype添加一个可枚举属性m，一个不可枚举属性n；然后，给对象obj定义两个可枚举属性x,一个不可枚举属性y，并且对象obj是通过对象直接量形式创建的，继承了Object.prototype。下面看实例：

从运行结果可以看出：in运算符左侧是属性名（字符串），右侧是对象。如果对象的自有属性或继承属性（不论这些属性是否可枚举）中包含这个属性则返回true，否则返回false。

2.hasOwnProperty()

对象的hasOwnProperty()方法用来检测给定的名字是否是对象的自有属性（不论这些属性是否可枚举），对于继承属性它将返回false。下面看实例：

3.propertyIsEnumerable()

propertyIsEnumerable()是hasOwnProperty()的增强版，只有检测到是自有属性且这个属性可枚举性为true时它才返回true。还是实例：

八.枚举属性

相对于检测属性，我们更常用的是枚举属性。枚举属性我们通常使用for/in循环，它可以在循环体中遍历对象中所有可枚举的自有属性和继承属性，把属性名称赋值给循环变量。继续上实例：

我原来认为for/in循环跟in运算符有莫大关系的，现在看来它们的规则并不相同啊！当然，如果这里不想遍历出继承的属性，那就在for/in循环中加一层hasOwnProperty()判断：

for(prop in obj){ 
  if(obj.hasOwnProperty(prop)){ 
    console.log(prop); 
  } 
}

Copier après la connexion

除了for/in循环之外，ECMAScript 5还定义了两个可以枚举属性名称的函数：

①Object.getOwnpropertyNames()，它返回对象的所有自有属性的名称，不论是否可枚举；

②Object.keys()，它返回对象对象中可枚举的自有属性的名称；

还是实例：

九.对象的三个特殊属性

每个对象都有与之相关的原型（prototype）、类（class）和可扩展性（extensible attribute）。这三个就是对象的特殊属性（它们也只是对象的属性而已，并没有想象的复杂哦）。

1.原型属性

正如前面所说，对象的原型属性是用来继承属性的（有点绕…），这个属性如此重要，以至于我们经常把“o的原型属性”直接叫做“o的原型”。原型属性是在实例创建之初就设置好的（也就是说，这个属性的值是JavaScript默认自动设置的，后面我们会说如何自己手动设置），前面也提到：

①通过对象直接量创建的对象使用Object.prototype作为它们的原型；

②通过new+构造函数创建的对象使用构造函数的prototype属性作为它们的原型；

③通过Object.create()创建的对象使用第一个参数（如果这个参数为null，则对象原型属性值为undefined；如果这个参数为 undefined，则会报错：Uncaught TypeError: Object prototype may only be an Object or null: undefined）作为它们的原型；

那么，如何查询一个对象的原型属性呢？在ECMAScript 5中，将对象作为参数传入Object.getPrototypeOf()可以查询它的原型，例如：

但是在ECMAScript 3中，没有Object.getPrototypeOf()函数，但经常使用表达式obj.constructor.prototype来检测一个对象的原型，因为每个对象都有一个constructor属性表示这个对象的构造函数：

①通过对象直接量创建的对象的constructor属性指向构造函数Object()；

②通过new+构造函数创建的对象的constructor属性指向构造函数；

③通过Object.create()创建的对象的constructor属性指向与其原型对象的constructor属性指向相同；

要检测一个对象是否是另一个对象的原型（或处于原型链中），可以使用isPrototypeOf()方法。例如：

还有一个非标准但众多浏览器都已实现的对象的属性__proto__(同样是两个下划线开始和结束，以表明其为非标准），用以直接查询/设置对象的原型。

2.类属性

对象的类属性（class attribute）是一个字符串，用以表示对象的类型信息。ECMAScript 3 和ECMAScript 5 都未提供设置这个属性的方法，并只有一种间接的方法可以查询它。默认的toString()方法（继承自Object.prototype）返回了这种格式的字符串：[object class] 。因此，要想获得对象的类，可以调用对象的toString()方法，然后提取已返回字符串的第8到倒数第二个位置之间的字符。不过，很多对象继承的 toString()方法重写了（比如：Array、Date等），为了能调用正确的toString()版本，必须间接地调用 Function.call()方法。下面代码可以返回传递给它的任意对象的类：

function classof(obj){
  if(o === null){
    return 'Null';
  }
  if(o === undefined){
    return 'Undefined';
  }
  return Object.prototype.toString.call(o).slice(8, -1);
}

Copier après la connexion

La fonction classof() peut transmettre n'importe quel type de paramètres. Voici des exemples d'utilisation :

Résumé : il ressort des résultats d'exécution que les attributs de classe des objets créés des trois manières sont tous des « Objets ».

3. Évolutivité

L'extensibilité d'un objet indique si de nouvelles propriétés peuvent être ajoutées à l'objet. Tous les objets intégrés et personnalisés sont explicitement extensibles (sauf s'ils sont convertis en objets non extensibles). L'extensibilité des objets hôtes est définie par le moteur JavaScript. ECMAScript 5 définit des fonctions pour interroger et définir l'évolutivité des objets :

① (Requête) Déterminez si l'objet est extensible en passant l'objet dans Object.isExtensible().

② (Paramètres) Si vous souhaitez convertir l'objet en objet non extensible, vous devez appeler Object.preventExtensions() et transmettre l'objet à convertir en paramètre. Remarque :

a. Une fois qu'un objet est converti en non extensible, il ne peut pas être reconverti en extensible

b.preventExtensions() n'affecte que l'extensibilité de l'objet lui-même. Si vous ajoutez des propriétés au prototype d'un objet non extensible, l'objet non extensible héritera également de ces nouvelles propriétés

De plus, Object.seal() est similaire à Object.preventExtensions(). En plus de définir l'objet comme non extensible, vous pouvez également définir toutes les propriétés de l'objet comme non configurables. Les objets scellés ne peuvent pas être descellés. Vous pouvez utiliser Object.isSealed() pour détecter si un objet est scellé.

En allant plus loin, Object.freeze() verrouillera l'objet plus strictement - "gelé". En plus de rendre un objet non extensible et ses propriétés non configurables, vous pouvez également définir toutes ses propres propriétés de données en lecture seule (si les propriétés de l'accesseur de l'objet ont des méthodes de définition, les propriétés de l'accesseur ne seront pas affectées, elles peuvent toujours être appelé en attribuant des valeurs aux propriétés). Utilisez Object.isFrozen() pour détecter si un objet est gelé.

Résumé : Object.preventExtensions(), Object.seal() et Object.freeze() renvoient tous l'objet transmis, c'est-à-dire qu'ils peuvent être appelés de manière imbriquée :

var obj = Object.seal(Object.create(Object.freeze({x:1}),{y:{value: 2, writable: true}));

Cette instruction utilise la fonction Object.create() pour transmettre deux paramètres, c'est-à-dire que le premier paramètre est l'objet prototype de l'objet créé et le deuxième paramètre est l'attribut défini directement pour l'objet lors de sa création. , et est livré avec des attributs définis.

10. Sérialisation des objets

Après avoir parlé des propriétés des objets et des caractéristiques des propriétés des objets, il y a encore pas mal de choses, je ne sais pas si vous êtes confus. Cependant, ce qui suit est un sujet plus détendu !

La sérialisation d'objets fait référence à la conversion de l'état d'un objet en chaîne et peut également restaurer une chaîne en un objet. ECMAScript 5 fournit les fonctions intégrées JSON.stringify() et JSON.parse() pour sérialiser et restaurer des objets. Ces méthodes utilisent toutes JSON comme format d'échange de données. Le nom complet de JSON est "JavaScript Object Notation" - Sa syntaxe est très similaire à la syntaxe des objets JavaScript et des quantités directes de tableau :

Parmi eux, le dernier jsonObj est une copie complète d'obj

La syntaxe de JSON est un sous-ensemble de JavaScript et elle ne peut pas représenter toutes les valeurs en JavaScript. Les objets, tableaux, chaînes, nombres infinis, vrai, faux et nul sont pris en charge et peuvent être sérialisés et restaurés. Remarque :

①Le résultat de la sérialisation NaN, Infinity et -Infinity est nul

②JSON.stringify() ne peut sérialiser que les propres propriétés énumérables de l'objet

;

③Le résultat de la sérialisation des objets date est des chaînes de date au format ISO (voir la fonction Date.toJSON()), mais JSON.parse() conserve toujours leur forme de chaîne et ne peut pas les restaurer aux objets date d'origine ;

④Les fonctions, RegExp, les objets Error et les valeurs non définies ne peuvent pas être sérialisés et restaurés

;

Ce qui précède représente l’intégralité du contenu de cet article, j’espère qu’il sera utile à l’étude de chacun.