Introduction to Javascript writable features_javascript skills

When talking about the feature tags in js, I always feel a little weird. So why do we talk about this attribute? It originated from a question. We all know that the window object is actually

An instance of the browser window. Since it is an instance, then this instance should have "properties" and "methods", such as the following:

When we usually use functions, we will define some attributes, such as name, age, etc., and we can also perform delete, set and update operations on them.

Then the next question comes. Since the name of my person object can be modified dynamically, according to this principle, I should also be able to modify the undefined value under the window, and then I am very interested in taking a look.

The result is still predictable. I did not successfully modify the undefined value, so why is this happening? It makes no sense. It is not the packaging type mentioned in the previous article, but we have to respect the result. This means that the bottom layer of js must have done something to lead to such a result. In fact, the bottom layer of js uses Writable= by default. The false mark makes the undefined attribute unwritable. Let’s take a look at it in detail.

1: [Writable] feature

When talking about whether a property is writable, you may think of the get/set accessor in C#, or the readonly keyword. You will definitely be interested in how I should achieve the read-only operation of the property. In js you just need to use the defineProperty method.

Three interesting things can be seen from the above example:

<1>: I used the defineProperty method to turn person.name into a read-only field. Someone will say, this is obviously a method, how can it be a feature? In my mind, the feature is

                                                                                                                                                                                                                                   Mode, so this is the difference of js. After all, js has no syntactic sugar, so defining properties can only be defined through the underlying public method, which is defineProperty.

<2>: I saw not only writable but also a configurable in the method. What does this do? In fact, this is the basic configuration, which tells the js engine whether it can delete and update attributes. When I set configurable to false, you cannot delete p.Name, because this will be an invalid operation.

　

After reading this, I think you should understand why undiffed cannot delete or update. They are all made of strange marks. Don’t you think it’s interesting?

<3>: The next question worth thinking about is how the js engine does it. There is also Atrribute in C#, and this Atrribute will be recorded in the metadata after being compiled by the compiler, and then you can Feel free to use reflection to get any value in your Atrribute, such as the Serializable serialization class. It tells SerializableFormat how to read the class reflectively, which fields can be serialized and which cannot. If not, you need to use NonSerialized mark.

Copy code The code is as follows:

[Serializable]
Public class Test
{
         [NonSerialized]
          public string Name;
}

You can see from the picture that the Name is not serialized feature has been recorded in IL. We know that there is no reflection in js, so the breakthrough is naturally in the defineProperty method, but unfortunately, we cannot see the underlying source code of this method. What exactly is it like, so I don’t know what it does to the Name field to dynamically cause it to be unwritable. I can only guess the possible behavior of the js engine based on understanding.