Shulou(Shulou.com)06/03 Report--

This article shows you what the three things that JavaScript objects can do are concise and easy to understand, which will definitely brighten your eyes. I hope you can get something through the detailed introduction of this article.

In addition to normal object property assignment and traversal, we can use the JavaScript object to perform many other operations.

1. Access internal properties

An "internal property" that the JavaScript object cannot access in a normal way. The Internal attribute name is surrounded by parentheses [[]] and is available when creating an object.

Internal Properties cannot be dynamically added to an existing object.

Internal properties can be used in some built-in JavaScript objects that store the internal state specified by the ECMAScript specification.

There are two "internal properties", one way to manipulate objects, and the other way to store data. For example:

[[Prototype]]-prototype of an object, which can be a null or an object

[[Extensible]]-indicates whether new attributes are allowed to be dynamically added to the object

[[PrivateFieldValues]]-used to manage private class fields

two。 Attribute descriptor object

The data property contains the location of a data value where the value can be read and written. That is, data properties can be passed through the object. Property access, that is, we usually come into contact with users assigned values, they will return what, will not do anything extra.

Data attributes have four properties that describe their behavior (in order to represent internal values, the attributes are placed in two square brackets), called "descriptor objects".

The value descriptor is the data value of the attribute. For example, we have the following objects:

Let foo = {a: 1}

Then, the value property descriptor of an is 1.

Writable refers to whether the value of the property can be changed. The default value is true, which means that the property is writable. However, we can make it unwritable in a number of ways.

Configurable means that you can delete the properties of an object or change its property descriptor. The default value is true, which means it is configurable.

Enumerable means that it can be for... In loop traversal. The default value is true, which means that attributes can be returned through the for-in loop.

The Object.keys method also checks the enumerable descriptor before adding the property key to the returned array. However, the Reflect.ownKeys method does not check this property descriptor, but returns all its own property keys.

The Prototype descriptor has other methods, and get and set are used to get and set values, respectively.

When creating a new object, we can use the descriptor set by the Object.defineProperty method, as follows:

Let foo = {a: 1} Object.defineProperty (foo, 'baked, {value: 2, writable: true, enumerable: true, configurable: true,})

So the new value of foo is {a: 1, b: 2}.

We can also use defineProperty to change the descriptor of an existing property. For example:

Let foo = {a: 1} Object.defineProperty (foo, 'asides, {value: 2, writable: false, enumerable: true, configurable: true,})

So when we try to assign a value to foo.a, such as:

Foo.a = 2

If strict mode is turned off, the browser will ignore it, otherwise an error will be thrown because we set writable to false, indicating that the property is unwritable.

We can also use defineProperty to convert properties to getter, as follows:

'use strict' let foo = {a: 1} Object.defineProperty (foo,' baked, {get () {return 1;}})

When we write like this:

Foo.b = 2

Because the b attribute is a getter attribute, when using strict mode, we get an error: the Getter property cannot be reassigned.

3. Unable to assign inherited read-only properties

Inherited read-only properties can no longer be assigned. This makes sense, because we set it this way, it is inherited, so it should be propagated to the object that inherits the property.

We can use Object.create to create an object that inherits properties from the prototype object, as follows:

Const proto = Object.defineProperties ({}, a: {value: 1, writable: false}}) const foo = Object.create (proto)

In the above code, we set the writable descriptor of proto.a to false, so we cannot assign other values to it.

If we write like this:

Foo.a = 2

In strict mode, we receive an error message.

We can use JavaScript objects to do a lot of things that we may not know.

First, some JavaScript objects, such as built-in browser objects, have internal properties, which are surrounded by parentheses, have internal states, and object creation cannot be added dynamically.

JavaScript object properties also have property descriptors that allow us to control their values, set their values, change their property descriptors, and so on.

We can use defineProperty to change the property descriptor of an attribute, which is also used to add a new attribute and its property descriptor.

Finally, the inherited read-only property remains read-only, which makes sense because it inherits from the parent prototype object.

What are the three things that JavaScript objects can do? have you learned any knowledge or skills? If you want to learn more skills or enrich your knowledge reserve, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.