Explication détaillée de l'objet en compétences de type JavaScript system_javascript

Mots précédents

En JavaScript, les objets sont rois ; presque tout en Javascript est un objet ou fonctionne comme un objet. Si vous comprenez les objets, vous comprenez Javascript. En JavaScript, un type référence est une structure de données utilisée pour organiser les données et les fonctionnalités ensemble. On l'appelle aussi souvent une classe. Les types de référence sont parfois appelés définitions d'objets car ils décrivent les propriétés et les méthodes d'une classe d'objets

La plupart des valeurs de type référence sont des instances du type Object. De plus, Object est également le type le plus couramment utilisé en JavaScript. Bien que les instances d'objet n'aient pas beaucoup de fonctions, elles sont en effet idéales pour stocker et transférer des données dans des applications

Créer un objet

Il existe deux façons de créer des types d'objet

[1]Constructeur d'objet

var person = new Object();
//如果不给构造函数传递参数可以不加括号 var person = new Object;
person.name = 'bai';
person.age = 29; 
//创建无属性的空对象
var cody1 = new Object();
var cody2 = new Object(undefined);
var cody3 = new Object(null);
console.log(typeof cody1,typeof cody2, typeof cody3);//object object object 
//创建string、number、array、function、boolean、regex
console.log(new Object('foo'));
console.log(new Object(1));
console.log(new Object([]));
console.log(new Object(function(){}));
console.log(new Object(true));
console.log(new Object(/\bbt[a-z]+\b/));

[Note] Le constructeur Object() lui-même est un objet, et le constructeur est un objet créé sur la base du constructeur Function

[2]Utiliser des littéraux d'objet

Javascript fournit des raccourcis appelés littéraux pour créer la plupart des valeurs d'objet natives. L'utilisation de littéraux cache simplement la même chose

que l'utilisation du nouvel opérateur

Processus de base

var person = {
name : 'bai',
age : 29,
5 : true
};

[Note] Utilisez des virgules dans les littéraux d'objet pour séparer les différentes propriétés, mais l'ajout d'une virgule après la dernière propriété provoquera une erreur dans IE7

Utilisez la méthode littérale d'objet pour définir l'objet, et le nom de l'attribut sera automatiquement converti en chaîne

//同上
var person = {
'name' : 'bai',
'age' : 29,
'5' : true
};

Si vous laissez ses accolades vides, vous pouvez définir un objet contenant uniquement les propriétés et méthodes par défaut

//等价于var person = new Object();
var person = {}; 
[tips]使用对象字面量封装多个可选参数
function displayInfo(args){
var output = '';
if(typeof args.name == 'string'){
output += 'name:' + args.name +'\n';
}
if(typeof args.age == 'number'){
output += 'Age:' + args.age + '\n';
}
console.log(output);
};
displayInfo({
name: 'Nicholas',
age: 29
});
displayInfo({
name: 'match'
});

Le mode de transmission de paramètres ci-dessus est le plus adapté aux situations où un grand nombre de paramètres facultatifs doivent être transmis à la fonction. De manière générale, même si les paramètres nommés sont faciles à gérer, ils peuvent se révéler rigides lorsqu'il existe plusieurs paramètres facultatifs. Par conséquent, utilisez des paramètres formels pour les valeurs requises et utilisez des littéraux d'objet pour encapsuler plusieurs paramètres facultatifs

Définir l'objet

Il existe deux manières d'accéder aux propriétés d'un objet. Vous pouvez utiliser la notation par points ou la notation par crochets pour obtenir, définir ou mettre à jour les propriétés d'un objet

Les deux avantages de la méthode des crochets sont que les attributs sont accessibles via des variables et que les noms d'attributs peuvent être des identifiants Javascript non valides

[Remarque] Les caractères chinois peuvent exister dans des variables, car les caractères chinois sont équivalents aux caractères et sont traités de la même manière que les caractères anglais, ils peuvent donc être écrits comme personne.白 ou personne['白']

var myObject = {
123:'zero',
class:'foo'
};
console.log(myObject['123'],myObject['class']);//'zero' 'foo'
console.log(myObject.123);//报错

Si la valeur entre crochets est un type non-chaîne, elle sera implicitement convertie en chaîne à l'aide de String() puis affichée s'il s'agit d'un type chaîne, s'il y a des guillemets, la valeur d'origine sera affichée ; , sinon elle sera reconnue comme variable. Si la variable Si elle n'est pas définie, une erreur sera signalée

person[0] = 1; //[]中的数字不会报错，而是自动转换成字符串
person[a] = 1; //[]中符合变量命名规则的元素会被当成变量，变量未被定义，而报错
person[''] = 2; //[]中的空字符串不会报错,是实际存在的且可以调用,但不会在控制台右侧的集合中显示
person[undefined 或 null 或 true 或 false] = 4;// 不会报错，而是自动转换成字符串
person['白'] = 6; // 不会报错 

Supprimer l'objet

L'opérateur delete peut être utilisé pour supprimer complètement un attribut d'un objet. Supprimer est le seul moyen de supprimer une propriété d'un objet. Définir une propriété sur non défini ou null peut uniquement modifier la valeur de la propriété sans supprimer la propriété de l'objet. delete ne peut supprimer que les données sous l'objet, les cinq autres types de valeurs de base ne peuvent pas être supprimés

[Note] delete ne supprimera pas les propriétés trouvées sur la chaîne de prototypes

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo);//false 
var a = 123;
delete a;
console.log(a);//123

Si vous déclarez une variable a dans l'état global, elle équivaut à une donnée a sous l'objet window Vous pouvez attribuer une valeur à a via window.a ou a, et les valeurs de window. a et a sont toujours égaux, mais ils ne peuvent pas être supprimés

.

var a;
a = 10;
console.log(a,window.a);//10 10
window.a = 20;
console.log(a,window.a);//20 20
delete a ;
console.log(a,window.a);//20 20
delete window.a;
console.log(a,window.a);//20 20

Si vous utilisez window.b pour déclarer et attribuer une valeur (b équivaut à la déclarer sous l'objet window), vous pouvez la supprimer, et utiliser delete b et delete window.b a le même effet. console.log(b) demande la variable N'existe pas, console.log(window.b) demande non défini

window.b = 10;
console.log(b,window.b);//10 10
delete b;
console.log(b);//报错
console.log(window.b);//undefined 
window.b = 10;
console.log(b,window.b);//10 10
delete window.b;
console.log(b);//报错
console.log(window.b);//undefined 

Imbrication d'objets

Les objets peuvent être imbriqués, mais les valeurs doivent être obtenues couche par couche

var student = {
name : {
chinese : 1,
englisth : 2
},
sex : 1,
age : 26
}

[Remarque] La valeur ne peut être prise que couche par couche, comme student.name.chinese, et ne peut pas croiser directement le nom student.chinese, car il peut également y avoir des éléments appelés chinois sous le même niveau que name<.>

var object1 = {
object1_1:{
object1_1_1:{foo: 'bar'},
object1_1_2:{}
},
object1_2:{
object1_2_1:{},
object1_2_2:{}
}
};
console.log(object1.object1_1.object1_1_1.foo);//bar

实例方法

　　constructor:保存着用于创建当前对象的函数
　　hasOwnProperty(propertyName):用于检查给定的属性在当前对象实例中(而不是在实例的原型中)是否存在。其中，propertyName必须以字符串形式指定

　　isPrototypeOf(object):用于检查传入的对象是否是传入对象的原型

　　propertyIsEnumerable(propertyName):用于检查给定的属性是否能够使用for-in语句来枚举。其中，propertyName必须以字符串形式指定

　　toLocaleString():返回对象的字符串表示，该字符串与执行环境的地区对应

　　toString():返回对象的字符串表示

　　valueOf():返回对象的字符串、数值或布尔值表示，通常与toString()方法的返回值相同

var myObject = {
mark: true
};
console.log(myObject.constructor);//function Object(){}
console.log(myObject.hasOwnProperty('mark'));//true
console.log(Object.prototype.isPrototypeOf(myObject));//true
console.log(myObject.propertyIsEnumerable('mark'));//true
console.log(myObject.toLocaleString());//[object Object]
console.log(myObject.toString());//[object Object]
console.log(typeof myObject.valueOf(),myObject.valueOf());// object Object{mark:true}

小结：

Object类型

　　对象其实就是一组数据和功能的集合。对象可以通过执行new操作符后跟要创建的对象类型的名称来创建。而创建Object类型的实例并为其添加属性和（或）方法，就可以创建自定义对象。

var o = new Object(); 

　　Object的每个实例都具有下列属性和方法： 

　　● constructor——保存着用于创建当前对象的函数
 　　● hasOwnProperty(propertyName)——用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是否存在。其中，作为参数的属性名(propertyName)必须以字符串形式指定（例如：o.hasOwnProperty("name")）
 　　● isPrototypeOf(object)——用于检查传入的对象是否是另一个对象的原型
 　　● propertyIsEnumerable(propertyName)——用于检查给定的属性是否能够使用for-in语句来枚举 
　　● toString()——返回对象的字符串表示
 　　● valueOf()——返回对象的字符串、数值或布尔值表示。通常与toString()方法的返回值相同。