1. Delete Attributes
The delete operator can delete an object's properties
Delete // that person no longer has attribute age Delete // or so
Delete simply disconnects the property from the host object and does not go to the property in the Action property see delete A.P after b.x still 1
var a = {p:{x:1}}; var b =//1Delete//TypeError a.p is undefined //undefined//1
Delete can only delete its own property and cannot delete an inherited property (to delete an inherited property must remove it from the prototype object that defines the property, which, of course, affects all inherited objects from this prototype)
functioninherit (p) {if(p = =NULL){//cannot inherit from null ThrowTypeError (); } if(object.create) {//If you have this method, use it directly . returnobject.create (P); } vart =typeofp; if(t!== "Object" | | t!== "function") {//the object type to inherit is to conform to the ThrowTypeError (); } functionF () {};//to define an empty constructorF.prototype = p;//the prototype points to the object to inherit P return Newf ();//creates an F object that inherits from the P}varobj = {X:1};varObj1 =inherit (obj); Obj1.y= 2; Console.log ("x =" +obj1.x+ "y =" +obj1.y);//x = 1 y = 2Deleteobj1.x;DeleteObj1.y;console.log ("x =" +obj1.x+ "y =" +obj1.y);//x = 1 y = undefined
Of course, configurable properties are used to delete
Like what
Delete // cannot remove non-configurable var x = 1; Delete This // Cannot delete this. y = 1; Delete // This allows you to delete function f () {} Delete This // Cannot delete
2. Detection Properties
Use "in"
The in operator expects that its left operand is a string or can be converted to a string, and that the right operand of it is an object
vardata = [5,6,7];console.log ("0"inchdata);//There are subscript 0Console.log (1inchdata);//1 can be converted to "1"Console.log ("4"inchdata);//Subscript only 1 2 3 varobj = {X:1};console.log ("X"inchOBJ);//trueConsole.log ("Y"inchOBJ);//falseConsole.log ("ToString"inchOBJ);//true Because obj inherits this method
Use hasOwnProperty () or propertyisenumerable ()---the latter is an enhancement of the former
Discussion on Gu Mingsi
var obj = {x:1};console.log (obj.hasownproperty (///true//False //false because obj inherits this method, but not its own
The latter returns true only if the free attribute is detected and is an enumerable property.
var obj = {x:1};console.log (obj.propertyisenumerable (///true// False//false because obj inherits this method, but not its own //false because the most primitive ToString is non-enumerable
Of course, you can also directly use the "!==" operator to determine
var obj = {x:1!== undefined); // trueconsole.log (obj.y!== undefined); // false // true
3. Enumeration properties
var obj = {x:1,y:2}; for inch obj) { console.log (p); // x y Console.log (OBJ.P); // undefined undefined Console.log (Obj[p]); // 1 2}
Expansion 1:
Each object has a prototype (prototype), class, extensibility (extensible) associated with it
To detect whether an object is a prototype of another object (or in a prototype chain), you can use the isPrototypeOf () method
var // p prototype object inherits from Object.prototype var // o object inherits from P Console.log (p.isprototypeof (o)); // trueconsole.log (Object.prototype.isPrototypeOf (o)); // trueconsole.log (Object.prototype.isPrototypeOf (p)); // true
Of course, the isprototypeof () method is very similar to the instanceof operator
The instanceof operator expects its left operand to be an object, and the right operand identifies the object's class. If the object on the left is an instance of the right-hand class, the expression returns true, otherwise it returns false
var p = {x:1instanceof Object); // true var New instanceof Date); // true instanceof Object); // true instanceof number); // false
Expansion 2:
The class property of an object is a string that represents the type information of the object
General call to ToString () method returns form as [object class]
Like what
var obj = {x:1,y:2};console.log (obj.tostring ()); // [Object Object]
So to get the class of the object, you can find the "class" field in the returned string using slice (8,-1)
Like what
functionClassof (obj) {//find the class name if(obj = = =NULL){ return"Null"; } if(obj = = =undefined) { return"Undefined"; } returnObject.prototype.toString.call (obj). Slice (8,-1);} Console.log (Classof (1));// Number//Note that these types of variables are actually called the ToString () method instead of calling directly through their own//Console.log (1.toString ());//Will errorvarA = 1; Console.log (Number (1). toString ());//1Console.log (A.tostring ());//1Console.log ({x:1}.tostring ());//[Object Object]Console.log (Classof (1));// NumberConsole.log (Classof (""));//StringConsole.log (classof ("str"));//StringConsole.log (Classof (NULL));//NullConsole.log (Classof (false));//BooleanConsole.log (Classof ({}));//ObjectConsole.log (Classof ([]));//ArrayConsole.log (Classof (NewDate ()));//Datefunctionf () {}console.log (Classof (Newf ()));//Object
JS Object Properties Related--check properties, enumeration properties, etc.