Création d'objet JavaScript

Les objets sont composés de属性etMéthodesLe type de données composé des collections.

Comme dans de nombreux autres langages de programmation, les objets de JavaScript peuvent être comparés aux objets de la vie réelle.

En JavaScript, presque tout est un objet :

• La chaîne peut être un objet (si elle est définie avec la clé new)

• Le nombre peut être un objet (si il est défini avec la clé new)

• La valeur booléenne peut être un objet (si elle est définie avec la clé new)

• La date est toujours un objet

• Les mathématiques sont toujours des objets

• Le tableau est toujours un objet

• L'expression régulière est toujours un objet

• 函数永远是对象

• Object就是对象

除原语外，所有JavaScript值都是对象。

JavaScript基元

原始值是没有属性或方法的值。

在JavaScript中，有5种原始类型：

• string

• number

• boolean

• null

• undefined

对象是变量

JavaScript变量只能包含一个值。

var user = "oldtoolbag.com";

对象也是变量，但是对象可以包含许多值。

可以将对象写为name：value对，并用冒号（:）分隔。

var user = {firstName: "维沙尔", lastName: "乔达里", age:22, location: "New Delhi"};

JavaScript对象是无序属性的集合。

对象属性

属性是对象中名称和值之间的关联，并且可以包含任何数据类型。

属性通常是指对象的特征。

您将在下一章中了解有关属性的更多信息。

对象方法

方法是作为对象属性值的函数，因此是对象可以执行的任务。

方法存储在属性中作为函数定义.

注意：方法是作为属性存储的函数。

创建一个JavaScript对象

JavaScript有许多预定义的对象。另外，您可以创建自己的对象。

有多种创建新对象的方法：

• Les deux exemples ci-dessus sont complètement identiques. Il n'est pas nécessaire d'utiliser new Object().对象常量，它使用大括号：{}

• Les deux exemples ci-dessus sont complètement identiques. Il n'est pas nécessaire d'utiliser new Object().对象构造函数，它使用new Object()

• 或者，您可以先创建一个Constructeur 　 ，然后示例化一个调用该函数的对象

使用对象常量

Les deux exemples ci-dessus sont complètement identiques. Il n'est pas nécessaire d'utiliser new Object().对象常量是创建JavaScript对象的最简单方法。

Les deux exemples ci-dessus sont complètement identiques. Il n'est pas nécessaire d'utiliser new Object().对象常量，您可以在一个语句中定义和创建一个对象。

下面的示例创建一个具有四个属性的新JavaScript对象：

var user = {firstName: "维沙尔", lastName: "乔达里", age:22, location: "New Delhi"};

对象定义可以跨越多行：

var user = {
　　firstName: "维沙尔",
　　lastName : "乔达里",
　　age　　:　22,
　　location : "新德里"
};

使用new Object()

Les deux exemples ci-dessus sont complètement identiques. Il n'est pas nécessaire d'utiliser new Object().对象构造函数这是创建JavaScript对象的另一种方法。

下面的示例创建一个具有四个属性的新JavaScript对象：

var user = new Object();
user.firstName = "维沙尔";
user.lastName = "乔达里";
user.age　=　22;
;

user.location　=　"nouveau Delhi";

Les deux exemples ci-dessus sont complètement identiques. Il n'est pas nécessaire d'utiliser new Object().En utilisantLittéral d'objet

est la méthode plus courante et préférée, car elle est moins susceptible de produire des résultats incohérents et imprévus.

En utilisant le constructeur

• De plus, vous pouvez créer un objet en deux étapes suivantes :ConstructeurDéfinir un type d'objet (on utilise généralement une majuscule en début de nom)

• Exemple de création d'objet en utilisant la clé new

L'exemple suivant montre comment définir un type d'objet en écriture de constructeur :

　　function　User(fname,　lname,　age,　loc)　{
　　　this.firstName　=　fname;
　　　this.lastName　=　lname;
　　　this.age　=　age;
　　　this.location　=　loc;
　　}

Maintenant, nous pouvons créer un utilisateur nomméuser1de l'objet, comme suit :

var　user1　=　new　User("Vishal",　"Jodari",　22,　"nouveau Delhi");

Nous en discuterons plus tard dans cette leçonConstructeur.

Les objets JavaScript sont mutables

Le mutable est une variable qui peut être modifiée. Dans JavaScript, seuls les objets et les tableaux sont mutables, pas les valeurs primitives.

Objet mutableest un objet dont l'état peut être modifié après sa création.

L'immuableUn objet est un objet dont l'état ne peut pas être modifié une fois créé.

une chaîneetun nombreestL'immuable. Laissez-nous comprendre cela à l'aide d'un exemple :

　　var　immutableString　=　"Hello";
　　
　　//　Dans le code ci-dessus, un nouvel objet avec une valeur de chaîne a été créé.
　　
　　immutableString　=　immutableString　+　"World";
　　
　　//　Nous allons maintenant ajouter "World" à la valeur existante.

Après avoir ajouté "immutableString" à la valeur de chaîne, les événements suivants se produiront :

• La valeur existante de "immutableString" est récupérée

• "World" est ajouté à la valeur existante de "immutableString"

• Ensuite, la valeur de résultat est allouée à un nouveau bloc de mémoire

• Maintenant, l'objet "immutableString" pointe vers l'espace mémoire créé récemment

• L'espace mémoire créé précédemment est maintenant disponible pour le回收垃圾

Les objets sont mutables : ils sont adressés par référence plutôt que par valeur.

Si user est un objet, les lignes suivantes ne créeront pas de copie de cet utilisateur :

　　var x = user;　　//　Cela ne créera pas de copie de user.

L'objet x n'est pas une copie de user, c'est user. x et user sont le même objet.

Toute modification de x changera également user, car x et user sont les mêmes objets.

var user = {firstName: "维沙尔", lastName: "乔达里", age:22, location: "New Delhi"};
var x = user;
x.location = "Goa";//　Cela changera à la fois x.location et user.location

Comparaison des objets

En JavaScript, les objets sont de type référence. Même si deux objets différents ont les mêmes attributs, ils ne seront jamais égaux.

//　Deux variables, deux objets différents avec les mêmes attributs
var fruit = {name: "apple"};
var fruitbear = {name: "apple"};
fruit == fruitbear;　　//　Retour false
fruit === fruitbear;　//　Retour false

Seulement comparer la même référence d'objet avec elle-même donnera true :

//　Deux variables, un objet
var fruit = {name: "apple"};
var fruitbear = fruit;　　//　Assignez la référence de l'objet fruit à fruitbear
//　Ici, fruit et fruitbear pointent vers le même objet
fruit == fruitbear;　//　Retour true
fruit === fruitbear;　//　Retour true