There are 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. To note:
1. typeof is an operator, not a method. Although we often use typeof() to obtain the data type of an object.
2. Typeof for null is object (this is because null is an empty object reference), and typeof for function is function.
Copy the code code 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 the code code as follows:
var d2=null;
d2={'key':"shit"};
var d3='';//String default
var d4=0; //Number type initial value is set to 0
var d5=null; //Set initial default value for object type
3. The difference and points to note between undefined and null
1. If you use "==" to compare, they are equal because they compare values.
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 "===": the comparison is between the value and the data type, and true will be returned only if they are all the same.
Copy the code code as follows:
alert(undefined == null); //true
alert(typeof undefined == typeof null); //false
alert(undefined === null); //true
4. Notes on 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. There is a lot of data inside js Automatic conversion of types is something that 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 the 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 Boolean function is called inside () of the if() statement.
5. Points to note about Number type
1. The float type cannot perform precise operations.
Copy the code code as follows:
alert(0.1+0.2);//Return 0.3000000000000000004
2. Support scientific notation operations
3. NaN (Not a Number)
1) var d=0/0; Note: No error will be reported in js, but NaN will be returned.
2) Can be obtained through Number.NaN
3) Any operation between NaN and any object will return NaN.
4) isNaN() determines whether it is NaN
Copy the code code as follows:
alert(isNaN(NaN));//true
alert(isNaN(12));//false
alert(isNaN('123'));//false: Because string type numbers can be automatically converted into numbers
alert(isNaN('lew'));//true
alert(isNaN(false));//(*)false: Because the bool value can be converted into a number, true becomes 1, false becomes 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 the code code as follows:
var box={
//Override the toString() method of the box object
toString:function(){
return '123';
}
};
alert(isNaN(box));//false
alert(box);//123 internally alert() first calls the object's valueOf() and then calls the toString() method
6) Convert other data types to Number type
Contains three functions: Number(): can convert all data types; parseInt() and parseFloat() only convert strings.
Copy the code code as follows:
alert(Number('123'));//123
alert(Number('0234'));//234
alert(Number(true));//1
alert(Number(null));//(**)0
//Except for the above, everything else returns 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.
Note when calling parseInt() and parseFloat(): The part of the string starting from the first numeric character to the number before the first numeric character is converted into a number.
Copy the code code as follows:
alert(parseInt('123leb'));//123
alert(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 the code code as follows:
alert(parseInt(56.12));//56
6. String type
1) (*Important*) Strings are immutable in ECMAScript: 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 the code code 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) The toString() method converts other data types into String type. But if you operate on null or undefined, an error will be reported.
3) However, the String() method can also achieve the effect of toString(), but can operate on null and undefined.
Internal principle: Call toString() first, 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() still has to make internal judgments, it will harm performance.