Javascript Object object study notes_basic knowledge-JS Tutorial-php.cn

Constructor new Object()

new Object(value)

Parameters value Optional parameter that declares the original value (i.e. number, Boolean value or string) to be converted into a Number object, Boolean object or String object. This object is not supported by JavaScript versions prior to 1.1 and ECMAScript Vl.

Return value

If no value parameter is passed to the constructor, it will return a newly created Object instance. If the original value parameter is specified, the constructor will create and return a wrapper object of the original value, that is, a Number object, a Boolean object, or a String object. When the Object() constructor is called as a function without using the new operator, it behaves the same as when using the new operator.

Properties constructor A reference to a JavaScript function that is the object’s constructor

Method

1.hasOwnProperty( ) Checks whether an object has a locally defined (non-inherited) property with a specific name.

Copy code The code is as follows: var o = new Object(); o.name="Tom"; alert(o.hasOwnProperty("name")); //true alert(o.hasOwnProperty("age")); //false 2.isPrototypeOf()

Grammar object.isPrototypeOf(o)

Parameters o Any object.

Return value Returns true if object is the prototype of O. If o is not an object, or object is not a prototype of o, false is returned.

Description JavaScript objects inherit the properties of the prototype object. An object's prototype is referenced through the prototype attribute of the constructor used to create and initialize the object. The isPrototypeOf() method provides a method to determine whether an object is the prototype of another object. This method can be used to determine the class of an object.

Example

Copy code The code is as follows: var o = new Object( ); Object.prototype.isPrototypeOf(o) // true: o is an object Function.prototype.isPrototypeOf(o.toString); // true: toString is a function Array.prototype.isPrototypeOf([1,2,3]); // true: [1,2,3] is an array //Here is another way to perform the same test (o.constructor == Object); // true: o was created with Object( ) constructor (o.toString.constructor == Function); // true: o.toString is a function /Prototype The object itself is the prototype object. The following call returns true //Describe the function following Function.prototype and Object.prototyp properties. Object.prototype.isPrototypeOf(Function.prototype);

3.ProertyIsEnumerable() Grammar

object.propertyIsEnumerable(propname)

Parameters

propname A string containing the name of the object prototype.

Return value

Returns true if object has a non-inherited property named propname and the property is enumerable (that is, it can be enumerated using a for/in loop). Description

You can use the for/in statement to traverse the "enumerable" properties of an object. But not all properties of an object are enumerable. Properties added to an object through JavaScript code are enumerable, while predefined properties of internal objects (such as methods) are usually not enumerable. The propertylsEnumerable() method provides a way to distinguish between enumerable and non-enumerable properties. But be aware that the ECMAScript standard stipulates that the propertyIsEnumerable() method does not detect the prototype chain, which means that it only applies to local properties of the object and cannot detect the enumerability of inherited properties. Example

Copy code The code is as follows: var o = new Object( ); // Create an object o.x = 3.14; o.propertyIsEnumerable("x"); // true property x is local and enumerable o.propertyIsEnumerable("y"); //false: o has no attribute y o.propertyIsEnumerable("toString"); //false: toStrlng property is inherited Object.prototype.propertyIsEnumerable("toString"); // false: enumerated

Bug

It is obviously wrong when the standard restricts the propertiesEnumerable() method to only detect non-inherited properties. Internet Explorer 5.5 implements this method as standard. The propertyIsEnumerable() method implemented in Nestacpe 6.0 takes the prototype chain into account. While this approach is desirable, it conflicts with the standard, so Netscape 6.1 modified it to match IE 5.5. Because of this bug in the standard, this method is not that useful.

Copy code The code is as follows: var obj = new Object(); Obj.title = 'aaa'; Obj.funb = function(a, b) alert(a b); } alert(obj.title); Obj.funb(1,2);

Here is a way ******************************

Copy code The code is as follows: function object(value,a,b){ This.title = value; This.funb = function(){ This.a = a; This.b = b; alert(a b); } var obj = new object("aaa",1,2); alert(obj.title); obj.funb(); //Add new methods to the object here object.prototype.name = "123456"; alert(obj.name);

This is another way