Types de référence ECMAScript

Les types de référence sont généralement appelés classes (class).

Ce tutoriel discutera de nombreux types de référence prédéfinis d'ECMAScript.

Types de référence

Les types de référence sont généralement appelés classes (class), ce qui signifie que lorsqu'on traite des valeurs de référence, on traite des objets.

Ce tutoriel discutera de nombreux types de référence prédéfinis d'ECMAScript.

À partir de maintenant, nous nous concentrerons sur les types de référence étroitement liés aux types de base déjà discutés.

Attention :En termes traditionnels, ECMAScript ne possède pas véritablement de classes. En réalité, à part indiquer l'absence de classes, le mot "classe" n'apparaît pas du tout dans ECMA-262. ECMAScript définit "définition d'objet", qui est logiquement équivalent aux classes d'autres langages de programmation.

Astuce :Ce tutoriel utilisera le terme "objet".

Les objets sont créés en utilisant l'opérateur new suivi du nom de l'objet à instancier. Par exemple, le code suivant crée une instance de l'objet Object :

var o = new Object();

Cette syntaxe est similaire au langage Java, mais ECMAScript nécessite l'utilisation de parenthèses lorsque plusieurs paramètres sont présents. Si il n'y a pas de paramètres, comme dans le code suivant, les parenthèses peuvent être omises :

var o = new Object;

Attention :Bien que les parenthèses ne soient pas nécessaires, il est préférable d'utiliser des parenthèses pour éviter toute confusion.

Astuce :Nous explorerons plus en détail les objets et leur comportement dans le chapitre sur les bases des objets.

Ce chapitre met l'accent sur les types de données de référence équivalents aux types de données primitives.

Object

L'objet Object n'est pas très utile en soi, mais il est préférable de l'explorer avant de comprendre d'autres classes. Car dans ECMAScript, l'objet Object est similaire à java.lang.Object dans Java, tous les objets dans ECMAScript dérivent de cet objet, toutes les propriétés et méthodes de l'objet Object apparaîtront dans d'autres objets, donc comprendre l'objet Object permet de mieux comprendre d'autres objets.

L'objet Object possède les propriétés suivantes :

constructor
Référence à la fonction créant l'objet (pointeur). Pour l'objet Object, ce pointeur pointe vers la fonction originale Object().
Prototype
Référence à l'prototype de l'objet. Pour tous les objets, il retourne par défaut une instance de l'objet Object.

L'objet Object possède également plusieurs méthodes :

hasOwnProperty(property)
Juge si l'objet a une propriété spécifique. Il est nécessaire de spécifier cette propriété sous forme de chaîne. (Par exemple, o.hasOwnProperty("name"))
IsPrototypeOf(object)
Juge si l'objet en question est le prototype d'un autre objet.
PropertyIsEnumerable
Juge si la propriété donnée peut être itérée avec la phrase for...in.
ToString()
Retourne la représentation en chaîne originale de l'objet. Pour l'objet Object, ECMA-262 ne définit pas cette valeur, donc différentes implémentations ECMAScript peuvent avoir des valeurs différentes.
ValueOf()
Retourne la valeur originale la plus appropriée pour l'objet donné. Pour de nombreux objets, la valeur retournée par cette méthode est identique à celle de la méthode ToString().

Remarque :Chaque propriété et méthode énumérée ci-dessus sera remplacée par d'autres objets.

Objet Boolean

L'objet Boolean est un type de données de référence pour le type de données Boolean original.

Pour créer un objet Boolean, il suffit de passer une valeur Boolean en tant que paramètre :

var oBooleanObject = new Boolean(true);

L'objet Boolean remplace la méthode ValueOf() de l'objet Object, retournant la valeur primitive, c'est-à-dire true et false. La méthode ToString() est également remplacée, retournant la chaîne "true" ou "false".

Malheureusement, les objets Boolean sont rarement utilisés dans ECMAScript, et même lorsqu'ils sont utilisés, ils sont difficiles à comprendre.

Les problèmes se produisent généralement lorsque des objets Boolean sont utilisés dans des expressions Boolean. Par exemple :

var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true;	//Sortie true

Dans ce code, un objet Boolean est créé avec la valeur false. Ensuite, cette valeur est opérée avec la valeur primitive true. Le résultat de l'opération AND entre false et true dans les opérations Boolean est false. Cependant, dans cette ligne de code, il est calculé oFalseObject, pas sa valeur false.

Comme discuté précédemment, dans les expressions Boolean, tous les objets sont automatiquement convertis en true, donc la valeur de oFalseObject est true. Ensuite, true est opéré avec true, le résultat est true.

Attention :Bien que vous devriez comprendre la disponibilité de l'objet Boolean, il est préférable d'utiliser les valeurs primitives Boolean pour éviter les problèmes mentionnés dans cette section.

参阅

Pour obtenir plus d'informations sur l'objet Boolean, veuillez visiter Manuel de référence de l'objet Boolean JavaScript。

Objet Number

Comme vous pourriez l'imaginer, l'objet Number est un type de données de référence pour le type de données Number original. Pour créer un objet Number, utilisez le code suivant :

var oNumberObject = new Number(68);

Vous devriez déjà avoir reconnu l'objet Number mentionné dans la section précédente de ce chapitre, lors de la discussion sur les valeurs spéciales (comme Number.MAX_VALUE). Toutes les valeurs spéciales sont des propriétés statiques de l'objet Number.

Pour obtenir la valeur originale du nombre de l'objet numérique, il suffit d'utiliser la méthode valueOf() :

var iNumber = oNumberObject.valueOf();

Bien sûr, la classe Number a également une méthode toString(), qui a été discutée en détail dans la section sur la conversion de type.

En plus des méthodes standard héritées de l'objet Object, l'objet Number a plusieurs méthodes spécifiques pour traiter les nombres.

La méthode toFixed()

La méthode toFixed() retourne la représentation sous forme de chaîne de caractères d'un nombre avec un certain nombre de décimales. Par exemple :

var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2));  // Sortie "68.00"

Dans ce cas, le paramètre de la méthode toFixed() est 2, ce qui signifie que deux décimales doivent être affichées. Cette méthode retourne "68.00", les caractères de chaîne vides sont remplacés par des 0. Pour les applications traitant des devises, cette méthode est très utile. La méthode toFixed() peut représenter des nombres avec 0 à 20 décimales, les valeurs au-delà de cette plage déclencheront une erreur.

La méthode toExponential()

Une autre méthode liée à la mise en forme des nombres est toExponential(), qui retourne la représentation sous forme de chaîne de caractères du nombre en forme exponentielle.

Comme pour la méthode toFixed(), la méthode toExponential() a également un paramètre qui spécifie le nombre de décimales à afficher. Par exemple :

var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1));  // Sortie "6.8e+1"

Le résultat de ce code est "6.8e+1", comme expliqué précédemment, cela représente 6.8x101Le problème est, que faire si on ne sait pas quelle forme (prédéfinie ou exponentielle) utiliser pour représenter le nombre ? On peut utiliser la méthode toPrecision().

La méthode toPrecision()

La méthode toPrecision() retourne la forme prédéfinie ou exponentielle du nombre en fonction de la forme la plus significative. Elle a un paramètre, c'est-à-dire le nombre total de chiffres utilisés pour représenter le nombre (sans inclure l'exponentiel). Par exemple,

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  // Sortie "7e+1"

La tâche de ce code est d'exprimer le nombre 68 avec un seul chiffre, le résultat est "7e+1", sous une autre forme, c'est-à-dire 70. En effet, la méthode toPrecision() arrondit les nombres. Cependant, si on représente 68 avec 2 chiffres, c'est beaucoup plus facile :

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(2));  // Sortie "68"

Bien sûr, la sortie est "68", car c'est bien la représentation exacte de ce nombre. Mais que faire si le nombre de chiffres spécifiés dépasse celui nécessaire ?

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(3));  //输出 "68.0"

在这种情况下，toPrecision(3) 等价于 toFixed(1)，输出的是 "68.0"。

toFixed()、toExponential() 和 toPrecision() 方法都会进行舍入操作，以便用正确的小数位数正确地表示一个数。

Astuce :与 Boolean 对象相似，Number 对象也很重要，不过应该少用这种对象，以避免潜在的问题。只要可能，都使用数字的原始表示法。

参阅

如需更多有关 Number 对象的信息，请访问 Manuel de référence de l'objet Number JavaScript。

String 对象

String 对象是 String 原始类型的对象表示法，它是以下方式创建的：

var oStringObject = new String("hello world");

String 对象的 valueOf() 方法和 toString() 方法都会返回 String 类型的原始值：

alert(oStringObject.valueOf() == oStringObject.toString());	//输出 "true"

如果运行这段代码，输出是 "true"，说明这些值真的相等。

Remarque :String 对象是 ECMAScript 中比较复杂的引用类型之一。同样，本节的重点只是 String 类的基本功能。更多的高级功能请阅读本教程相关的章节，或参阅 Manuel de référence de l'objet String JavaScript。

length 属性

String 对象具有属性 length，它是字符串中的字符个数：

var oStringObject = new String("hello world");
alert(oStringObject.length);	//输出 "11"

这个例子输出的是 "11"，即 "hello world" 中的字符个数。注意，即使字符串包含双字节的字符（与 ASCII 字符相对，ASCII 字符只占用一个字节），每个字符也只算一个字符。

charAt() 和 charCodeAt() 方法

String 对象还拥有大量的方法。

首先，两个方法 charAt() 和 charCodeAt() 访问的是字符串中的单个字符。这两个方法都有一个参数，即要操作的字符的位置。

charAt() 方法返回的是包含指定位置处的字符的字符串：

var oStringObject = new String("hello world");
alert(oStringObject.charAt(1));	//输出 "e"

Dans la chaîne "hello world", le caractère à la position 1 est "e". Dans la section "Types primitifs ECMAScript", nous avons mentionné que la position du premier caractère est 0, la position du deuxième caractère est 1, et ainsi de suite. Par conséquent, l'appel de charAt(1) retourne "e".

Si vous souhaitez obtenir non pas le caractère, mais le code de caractères, vous pouvez appeler la méthode charCodeAt() :

var oStringObject = new String("hello world");
alert(oStringObject.charCodeAt(1));	//Affiche "101"

Cet exemple affiche "101", c'est-à-dire le code de caractères de la lettre minuscule "e".

La méthode concat()

La méthode concat() suivante est utilisée pour ajouter une ou plusieurs chaînes de caractères à la valeur originale du String. Cette méthode retourne la valeur originale de String, en laissant l'objet String d'origine inchangé :

var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
alert(sResult);		//Affiche "hello world"
alert(oStringObject);	//Affiche "hello "

Dans ce segment de code, l'appel de la méthode concat() retourne "hello world", mais l'objet String conserve toujours "hello ". Pour cette raison, il est plus courant d'utiliser le signe (+) pour concaténer des chaînes de caractères, car cette forme indique réellement le comportement réel :

var oStringObject = new String("hello ");
var sResult = oStringObject + "world";
alert(sResult);		//Affiche "hello world"
alert(oStringObject);	//Affiche "hello "

Les méthodes indexOf() et lastIndexOf()

Jusqu'à présent, nous avons discuté des méthodes pour concaténer des chaînes de caractères et des méthodes pour accéder aux caractères individuels dans une chaîne. Cependant, si vous ne pouvez pas déterminer si un caractère existe vraiment dans une chaîne donnée, quelle méthode devriez-vous appeler ? Dans ce cas, vous pouvez appeler les méthodes indexOf() et lastIndexOf().

Les méthodes indexOf() et lastIndexOf() retournent tous deux la position de la sous-chaîne spécifiée dans une autre chaîne. Si la sous-chaîne n'est pas trouvée, elle retourne -1.

Les différences entre ces deux méthodes sont que la méthode indexOf() commence à rechercher la sous-chaîne à partir du début de la chaîne (position 0), tandis que la méthode lastIndexOf() commence à rechercher la sous-chaîne à partir de la fin de la chaîne. Par exemple :

var oStringObject = new String("hello world!");
alert(oStringObject.indexOf("o"));		输出 "4"
alert(oStringObject.lastIndexOf("o"));	输出 "7"

Dans ce cas, la première occurrence de la chaîne "o" apparaît à la position 4, c'est-à-dire dans "hello"; la dernière occurrence de la chaîne "o" apparaît à la position 7, c'est-à-dire dans "world". Si la chaîne ne contient qu'une seule occurrence de la chaîne "o", alors les méthodes indexOf() et lastIndexOf() renvoient la même position.

Méthode localeCompare()

La prochaine méthode est localeCompare(), qui trie les chaînes. Cette méthode a un paramètre - la chaîne à comparer, et elle renvoie l'un des trois valeurs suivantes :

  • Si l'objet String est classé avant la chaîne passée en paramètre par ordre alphabétique, il renvoie un nombre négatif.
  • Si l'objet String est égal à la chaîne passée en paramètre, il renvoie 0
  • Si l'objet String est classé après la chaîne passée en paramètre par ordre alphabétique, il renvoie un nombre positif.

Remarque :Si le retour est négatif, le plus courant est -1, mais le véritable retour est déterminé par l'implémentation. Si le retour est positif, tout comme le plus courant est 1, mais le véritable retour est déterminé par l'implémentation.

Voici un exemple :

var oStringObject = new String("yellow");
alert(oStringObject.localeCompare("brick"));		// Affiche "1"
alert(oStringObject.localeCompare("yellow"));		// Affiche "0"
alert(oStringObject.localeCompare("zoo"));		// Affiche "-1"

Dans ce segment de code, la chaîne "yellow" est comparée avec 3 valeurs, à savoir "brick", "yellow" et "zoo". Étant donné que les éléments sont classés par ordre alphabétique, "yellow" se trouve après "brick", donc localeCompare() renvoie 1; "yellow" est égal à "yellow", donc localeCompare() renvoie 0; "zoo" se trouve après "yellow", localeCompare() renvoie -1. Je le répète une fois de plus, étant donné que la valeur renvoyée est déterminée par l'implémentation, il est préférable d'appeler la méthode localeCompare() de la manière suivante :

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " précède " + oStringObject2);
} else if (iResult > 0) {
  alert(oStringObject1 + " suit " + oStringObject2);
} else {
  alert("Les deux chaînes sont égales");
}

Avec cette structure, on peut s'assurer que ce code fonctionne correctement dans toutes les implémentations.

L'originalité de la méthode localeCompare() réside dans le fait que le contexte régional (locale, qui fait également référence à la région et à la langue) précise exactement la manière dont cette méthode fonctionne. Aux États-Unis, l'anglais est la langue standard de l'implémentation ECMAScript, et localeCompare() est sensible à la casse, avec les lettres majuscules situées après les lettres minuscules dans l'ordre alphabétique. Cependant, dans d'autres régions, les choses peuvent être différentes.

slice() et substring()

ECMAScript fournit deux méthodes pour créer des valeurs de chaîne à partir de sous-chaînes, à savoir slice() et substring(). Ces deux méthodes retournent toutes deux des sous-chaînes à traiter et acceptent un ou deux paramètres. Le premier paramètre est la position de début de la sous-chaîne à obtenir, et le second paramètre (si utilisé) est la position avant la fin de la sous-chaîne à obtenir (c'est-à-dire, le caractère à la position de fin n'est pas inclus dans la valeur retournée). Si le second paramètre est omis, la position de fin est par défaut la longueur de la chaîne.

Comme pour la méthode concat(), les méthodes slice() et substring() ne modifient pas la valeur de l'objet String lui-même. Elles ne retournent que la valeur String originale et conservent l'objet String inchangé.

var oStringObject = new String("hello world");
alert(oStringObject.slice("3")); // Sortie "lo world"
alert(oStringObject.substring("3")); // Sortie "lo world"
alert(oStringObject.slice("3", "7")); // Sortie "lo w"
alert(oStringObject.substring("3", "7")); // Sortie "lo w"

Dans cet exemple, les utilisations de slice() et substring() sont identiques et les valeurs de retour également. Lorsque seul le paramètre 3 est utilisé, les deux méthodes renvoient tous deux "lo world", car le deuxième "l" de "hello" se trouve à la position 3. Lorsque deux paramètres "3" et "7" sont utilisés, les valeurs de retour des deux méthodes sont tous deux "lo w" (l'octet "o" de "world" se trouve à la position 7, donc il n'est pas inclus dans le résultat).

Pourquoi y a-t-il deux méthodes fonctionnelles complètement identiques ? En réalité, ces deux méthodes ne sont pas complètement identiques, mais elles diffèrent légèrement dans leur traitement des paramètres lorsque ceux-ci sont négatifs.

Pour les paramètres négatifs, la méthode slice() ajoute le paramètre à la longueur de la chaîne, tandis que la méthode substring() le traite comme 0 (autrement dit, il est ignoré). Par exemple :

var oStringObject = new String("hello world");
alert(oStringObject.slice("-3")); // Sortie "rld"
alert(oStringObject.substring("-3")); // Sortie "hello world"
alert(oStringObject.slice("3, -4")); // Sortie "lo w"
alert(oStringObject.substring("3, -4")); // Sortie "hel"

De cette manière, on peut voir la principale différence entre les méthodes slice() et substring().

Lorsque seul le paramètre -3 est utilisé, slice() renvoie "rld", substring() renvoie "hello world". C'est parce que pour la chaîne "hello world", slice("-3") est converti en slice("8"), et substring("-3") est converti en substring("0").

De même, l'utilisation des paramètres 3 et -4 montre une différence évidente. slice() est converti en slice(3, 7), comme dans l'exemple précédent, et retourne "lo w". En revanche, la méthode substring() interprète les deux paramètres comme substring(3, 0), ce qui est en réalité substring(0, 3), car substring() considère toujours le plus petit nombre comme la position de début et le plus grand nombre comme la position de fin. Par conséquent, substring("3, -4") retourne "hel". La dernière ligne de code est utilisée pour expliquer comment utiliser ces méthodes.

toLowerCase(), toLocaleLowerCase(), toUpperCase() et toLocaleUpperCase()

La dernière série de méthodes à discuter concerne la conversion de casse. Il y a 4 méthodes pour effectuer la conversion de casse, à savoir

  • toLowerCase()
  • toLocaleLowerCase()
  • toUpperCase()
  • toLocaleUpperCase()

Comme leur nom l'indique, les deux premières méthodes sont utilisées pour convertir une chaîne en minuscules, et les deux dernières méthodes sont utilisées pour convertir une chaîne en majuscules.

Les méthodes toLowerCase() et toUpperCase() sont primitives et sont implémentées sur le modèle des méthodes similaires dans java.lang.String.

Les méthodes toLocaleLowerCase() et toLocaleUpperCase() sont basées sur une implémentation spécifique à la région (comme pour la méthode localeCompare()). Dans de nombreux régions, les méthodes spécifiques à la région sont identiques aux méthodes génériques. Cependant, certaines langues appliquent des règles spécifiques de conversion de casse Unicode (par exemple, le turc), donc il est nécessaire d'utiliser les méthodes spécifiques à la région pour effectuer des conversions correctes.

var oStringObject = new String("Hello World");
alert(oStringObject.toLocaleUpperCase());     // affiche "HELLO WORLD"
alert(oStringObject.toUpperCase());         // affiche "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase()); // affiche "hello world"
alert(oStringObject.toLowerCase()); // Sortie "hello world"

Dans ce code, toUpperCase() et toLocaleUpperCase() sortent tous deux "HELLO WORLD", et toLowerCase() et toLocaleLowerCase() sortent tous deux "hello world". En général, si on ne sait pas dans quel encodage un langage est exécuté, il est plus sûr d'utiliser des méthodes spécifiques à la région.

Astuce :Rappelez-vous, toutes les propriétés et méthodes de l'objet String peuvent être appliquées aux valeurs primitives String, car elles sont des pseudo-objets.

Opérateur instanceof

Lors de l'utilisation de l'opérateur typeof avec des types de stockage de valeur par référence, un problème se pose, que ce soit pour quel type d'objet, il retourne toujours "object". ECMAScript a introduit un autre opérateur Java instanceof pour résoudre ce problème.

L'opérateur instanceof est similaire à l'opérateur typeof, utilisé pour identifier le type de l'objet en cours de traitement. Contrairement à la méthode typeof, la méthode instanceof nécessite que le développeur confirme explicitement que l'objet est de type spécifique. Par exemple :

var oStringObject = new String("hello world");
alert(oStringObject instanceof String); // Sortie "true"

Ce code demande si "l'objet oStringObject est une instance de l'objet String ?" oStringObject est effectivement une instance de l'objet String, donc le résultat est "true". Bien que moins flexible que la méthode typeof, la méthode instanceof est encore très utile lorsque la méthode typeof retourne "object".