Detaillierte Erläuterung der Fähigkeiten von system_javascript für Objekte im JavaScript-Typ

Vorherige Wörter

In JavaScript sind Objekte König; fast alles in Javascript ist ein Objekt oder funktioniert wie ein Objekt. Wenn Sie Objekte verstehen, verstehen Sie Javascript. In JavaScript ist ein Referenztyp eine Datenstruktur, die zum gemeinsamen Organisieren von Daten und Funktionen verwendet wird. Er wird auch oft als Klasse bezeichnet. Referenztypen werden manchmal als Objektdefinitionen bezeichnet, weil sie die Eigenschaften und Methoden einer Objektklasse beschreiben

Die meisten Referenztypwerte sind Instanzen des Objekttyps. Darüber hinaus ist Object auch der am häufigsten verwendete Typ in JavaScript. Obwohl Objektinstanzen nicht viele Funktionen haben, eignen sie sich dennoch ideal zum Speichern und Übertragen von Daten in Anwendungen

Objekt erstellen

Es gibt zwei Möglichkeiten, Objekttypen zu erstellen

[1]Objektkonstruktor

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/));

[Hinweis] Der Object()-Konstruktor selbst ist ein Objekt, und der Konstruktor ist ein Objekt, das auf der Grundlage des Funktionskonstruktors

erstellt wurde

[2]Verwenden Sie Objektliterale

Javascript bietet Verknüpfungen, sogenannte Literale, zum Erstellen der meisten nativen Objektwerte. Durch die Verwendung von Literalen wird lediglich dasselbe

ausgeblendet wie durch die Verwendung des neuen Operators

Grundlegender Prozess

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

[Hinweis] Verwenden Sie Kommas in Objektliteralen, um verschiedene Eigenschaften zu trennen. Das Hinzufügen eines Kommas nach der letzten Eigenschaft führt jedoch zu einem Fehler in IE7

Verwenden Sie die Objektliteralmethode, um das Objekt zu definieren, und der Attributname wird automatisch in eine Zeichenfolge konvertiert

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

Wenn Sie die geschweiften Klammern leer lassen, können Sie ein Objekt definieren, das nur Standardeigenschaften und -methoden enthält

//等价于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'
});

Der obige Parameterübergabemodus eignet sich am besten für Situationen, in denen eine große Anzahl optionaler Parameter an die Funktion übergeben werden muss. Im Allgemeinen sind benannte Parameter zwar einfach zu handhaben, können jedoch unflexibel sein, wenn mehrere optionale Parameter vorhanden sind. Verwenden Sie daher formale Parameter für erforderliche Werte und Objektliterale, um mehrere optionale Parameter zu kapseln

Objekt festlegen

Es gibt zwei Möglichkeiten, auf Objekteigenschaften zuzugreifen. Sie können die Punktnotation oder die Klammernotation verwenden, um die Eigenschaften eines Objekts abzurufen, festzulegen oder zu aktualisieren

Die beiden Vorteile der eckigen Klammermethode bestehen darin, dass auf Attribute über Variablen zugegriffen werden kann und Attributnamen ungültige Javascript-Bezeichner sein können

[Hinweis] Chinesische Schriftzeichen können in Variablen vorhanden sein, da chinesische Schriftzeichen äquivalent zu Schriftzeichen sind und genauso behandelt werden wie englische Schriftzeichen, sodass sie als person.白 oder person['白'] geschrieben werden können

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

Wenn der Wert in eckigen Klammern kein String-Typ ist, wird er mit String() implizit in einen String konvertiert und dann ausgegeben. Wenn es sich um einen String-Typ handelt, wird der ursprüngliche Wert ausgegeben Andernfalls wird es als Variable erkannt. Wenn die Variable nicht definiert ist, wird ein Fehler gemeldet

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

Objekt löschen

Mit dem Löschoperator kann ein Attribut vollständig aus einem Objekt gelöscht werden. Löschen ist die einzige Möglichkeit, eine Eigenschaft aus einem Objekt zu löschen. Wenn Sie eine Eigenschaft auf undefiniert oder null setzen, kann nur der Wert der Eigenschaft geändert werden, ohne dass die Eigenschaft aus dem Objekt gelöscht wird. delete kann nur die Daten unter dem Objekt löschen, die anderen fünf Grundtypen von Werten können nicht gelöscht werden

[Hinweis] Durch Löschen werden keine Eigenschaften gelöscht, die in der Prototypenkette gefunden werden

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

Wenn Sie eine Variable a im globalen Status deklarieren, entspricht sie den Daten a unter dem Fensterobjekt. Sie können a über window.a oder a und den Werten von window einen Wert zuweisen. a und a sind immer gleich, können aber nicht gelöscht werden

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

Wenn Sie window.b verwenden, um einen Wert zu deklarieren und zuzuweisen (b entspricht der Deklaration unter dem Fensterobjekt), können Sie ihn löschen. Die Verwendung von delete b und delete window.b hat nach dem Löschen den gleichen Effekt. console.log(b) fordert die Variable auf. Existiert nicht, console.log(window.b) fordert auf, undefiniert zu sein

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 

Objektverschachtelung

Objekte können verschachtelt werden, Werte müssen jedoch Schicht für Schicht ermittelt werden

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

[Hinweis] Der Wert kann nur Schicht für Schicht übernommen werden, z. B. student.name.chinese, und kann nicht direkt mit dem Namen „student.chinese“ verwendet werden, da unter derselben Ebene wie „name“ möglicherweise auch Elemente mit dem Namen „chinesisch“ vorhanden sind 🎜>

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()方法的返回值相同。