A brief discussion on the six data types of javascript and special attention points_javascript skills

Six common data types in js: String type, Null type, Number type, Boolean type, and Object type.

1. Notes on typeof

When it comes to data types, it is inevitable to mention the operator typeof. Note:

1. Typeof is an operator, not a method. Although we often use typeof() to obtain the data type of an object.

2. The typeof for null is object (this is because null is an empty object reference), and the typeof for function is function

Copy code The code is as follows:

alert(typeof null); //Return object
function demo(){
alert('demo');
}
alert(typeof demo); //return function

2. Set initial values ​​for object variables of various data types

Note that if the object variable of type Object does not know what to assign at first, do not use var demo={}; it is best to set it to null;

Copy code The code is as follows:

var d2=null;
d2={' key':"shit"};

var d3='';//String default
var d4=0; //The initial value of the Number type is set to 0
var d5=null; //The initial default value is set for the object type

3. The difference and points to note between undefined and null

1. If you use "==" to compare, they are equal because the comparison is value

2. There are two ways to distinguish them (their core is to compare their data types)

1) Use typeof to distinguish them

2) Use congruent "===": What is compared is the value and data type, and true will be returned only if they are all the same

Copy code The code is as follows:

alert(undefined == null); 🎜>alert(typeof undefined == typeof null); //false
alert(undefined === null); //true

4. Points to note about Boolean

1. The comparison between true and 1 is the same, and the comparison between false and 0 is the same (it is a "==" comparison), because the data type conversion is implemented internally, converting true into 1, and converting false into 0. js internal There are many automatic conversions of data types, which everyone must pay attention to. Many more will be mentioned later. But using "===" is not equal, because their data types are not equal.

2. Display conversion to Boolean, use the Boolean() method to display conversion. What needs to be noted is the various data types, when to convert to true and when to convert to false

1) String type, as long as it is not an empty string, it will be converted to true

2) Number type, as long as it is not 0, even a negative number will be converted to true

3) Object type, as long as it is not null type, will be converted to true

4) Undefined type will be converted to false

I won’t give a demonstration, you can try it yourself.

3. (***) The () inside the if() statement calls the Boolean function

5. Notes on Number type

1. Float type cannot perform precise calculations

Copy code The code is as follows:

alert(0.1 0.2);//Return 0.300000000000000004

2. Support scientific notation calculation

3. NaN（Not a Number）

1) var d=0/0; Note: In js, no error will be reported, but NaN

will be returned

2) Can be obtained through Number.NaN

3) The operation between NaN and any object will return NaN

4) isNaN() determines whether it is NaN

Copy code The code is as follows:

alert(isNaN(NaN));//true
alert(isNaN(12));//false
alert(isNaN('123'));//false: because of characters String type numbers can be automatically converted into numbers
alert(isNaN('lew'));//true
alert(isNaN(false));//(*)false: because bool values ​​can be converted into numbers , true changes to 1,, false changes to 0

5) Internal execution principle of isNaN(): The same applies to objects. Implementation principle: The prime minister calls the valueOf() method of the object. If it can be converted into a number, it will be directly judged; if not, it will call the toString() method again, and then test the return value.

valueOf() internally calls the toObject() method. The internal execution principle of the two methods is as follows:

Copy code The code is as follows:

var box={
//Rewrite box Object's toString() method
       toString:function(){
                                                                                                                                                               toString() method (box);//123 Internally alert() also first calls the object’s valueOf() and then calls the toString() method



6) Convert other data types into Number type

Contains three functions: Number(): can convert all data types; parseInt() and parseFloat() only convert strings.

Copy code

The code is as follows:alert(Number('123'));// 123alert(Number('0234'));//234

alert(Number(true));//1

alert(Number(null));//(**)0

//Except for the above, all others return NaN
alert(Number(undefined))//NaN

The internal implementation principle of Number(): Same as isNaN(), valueOf() is called first and then toString() is called. . So it can be imagined that the performance is relatively poor. . So as long as the object to be transformed is a string, call parseInt() or parseFloat() because they do not need to judge the type internally.

parseInt() and parseFloat() call note: starting from the first character that is a number and ending with the previous number of the first character that is a number, this part of the string is converted into a number

Copy code

The code is as follows:alert(parseInt('123leb'));// 123alert(parseInt('123leb345'));//123

alert(parseInt('len234'));//NaN

When the parameter in parseInt() is of float type, only the integer part of the number is obtained

Copy code

The code is as follows:alert(parseInt(56.12));//56

6. String type

1) (*Important*) In ECMAScript, strings are immutable: strings will not change after they are created. To change a string variable that has been assigned a value, first destroy the string in the variable, and then fill the variable with a string containing the new value.

Copy code

The code is as follows:var d='hello';d= d 'shit';//Execution process: first assign a value to 'hello', then clear the string in d, concatenate the strings 'hello' and 'shit', and then assign a value to the d variable. (So ​​the value of the string will not change once it is created)

2) toString() method converts other data types into String type. But if you operate on null or undefined, an error will be reported.

3) But the String() method can also achieve the effect of toString(), but can operate on null and undefined.

Internal principle: First call toString(), and if it can be converted into a string, the result will be returned directly. No, then judge whether it is null or undefined, and then return 'null' or 'undefined'

Summary: If you know that the variable cannot be null or undefined, use toString(), which is more performant than String(). Because String() has to make internal judgments, it will harm the performance.