Detailed explanation of the use of JavaScript wrapper objects_javascript skills

A JavaScript object is a composite value: it is a collection of properties and named values. Attribute values ​​are referenced through the "." symbol. When the property value is a function, it is called a method.

①A piece of code that you often use but may not understand its true underlying principle:

var s = "hello world!";
var word = s.substring(s.indexOf(" ")+1,s.length);
 

As mentioned before, the variable s here is just a primitive type of string. How can it have attributes (s.length) and methods (s.indexOf(), s.substring())? Yes, this is related to the packaging object we are about to introduce. The reason is: as long as the properties of string s are referenced, JavaScript will convert the string value into an object by calling new String(s). This object inherits the methods of the String object and is used to process it. A reference to the property. Once the property reference ends, the newly created object will be destroyed.

Like strings, numbers and Boolean values ​​also have their own methods: create a temporary object through the Number() and Boolean() constructors. A temporary object created when accessing a string, number, or Boolean property is a wrapper object. The remaining two of the five primitive types, null and undefined, have no wrapping objects: accessing their properties causes an Uncaught TypeError. After understanding the above code, then look at the following code:

var s = "test";
s.len = 4;//给它设置一个属性
var t = s.len;

Students who are not serious here will think that the final t is equal to 4. Isn't t equal to 4 in the end? Yes, the value of t at the end is undefined. If you want to know why, please continue reading the analysis: It turns out that the second line of code here just creates a temporary string object, assigns a value of 4 to the len attribute, and then destroys the object. The third line creates a new string object through the original string s (this is not the object created by the second line of code, the object created by the second line of code has been destroyed) and tries to read its len attribute, this attribute Naturally does not exist, so the result of the expression is undefined. This code illustrates that property values ​​or methods that read strings, numbers, and Boolean values ​​(actually their corresponding property values ​​or methods of the wrapped object) behave like objects. But if you try to assign a value to the property, this operation will be ignored: the modification only occurs on the temporary object, and the temporary object will not be retained.

Note: You can create wrapper objects explicitly through the String(), Number(), and Boolean() constructors:

var s = "test",n=1,b=true;//一个字符串、数字和布尔值
var S = new String(s);//一个字符串对象
var N = new Number(n);//一个数值对象
var B = new Boolean(b);//一个布尔对象

JavaScript will convert wrapped objects into primitive values ​​when necessary, so the objects S, N, and B in the above code often, but not always, behave the same as the values ​​​​s, n, and b. The "==" equality operator treats the original value and its wrapped object as equal, but the "===" equality operator treats them as unequal. You can also see the difference between the original value and its wrapped object through the typeof operator:

　　　　①typeof(s);　　->"string"
　　　　　typeof(S);　　->"object"
　　　　②typeof(n);　　->"string"
　　　　　typeof(N);　　->"object"
　　　　③typeof(b);　　->"string"
　　　　　typeof(B);　　->"object"

The above is the entire content of this article, I hope you all like it.