What are the special data types in JavaScript?

In JavaScript, there are 6 major data types, including string, number, boolean, undefined, null and object. The following is an introduction to the special data types in JavaScript through this article. Friends who need it can refer to it

In JavaScript, there are 6 major data types, including string, number, boolean, undefined, null and object

1. Special types in JS: NaN

NaN is Not a Number, not a number, so what exactly is NaN? For JS, integers and floating point numbers are collectively called the number type. In addition, the number type also has a very special value, namely NaN, which is used to indicate whether it is a state of the number type, rather than An exact value (so, NaN is not equal to itself).

So, under what circumstances do NaN values ​​generally appear?

Generally there are two situations:

(1) If there are operators such as minus sign (-), multiplication sign (*) or division sign (/) in an expression, JS The engine will try to convert the variables on both sides of the operator into number type (use Number(x) for conversion) before calculation. If the conversion fails, the expression will return NaN; the plus () operator will not convert the variables on both sides of it. Convert to number type. This is because the execution order of JS expressions is from left to right according to the priority of the operator. If the variables on both sides of the plus sign () are of type number, the number addition operation will be performed. , if one of the variables is a string, both sides will be added as strings, such as: 5 4 "6"="96"

(2) Directly use parseInt, parseFloat or Number to add a When a non-numeric value is converted to a number, the expression returns NaN

"abc" - 3  // NaN
parseInt( "abc" ) // NaN
parseFloat( "abc" ) //NaN
Number( "abc" )  //NaN

For the value of a numeric character, the conversion result will be different:

Number( "123abc" ); //NaN
parseInt( "123abc" ); //123
parseInt( "123abc45" ); //123
parseFloat( "123.45abc" ); //123.45

This is because the entire value converted by Number, Instead of partial values, parseInt and parseFloat only convert the string up to the first invalid character.

Therefore, when a string cannot be successfully converted by Number, parseInt, parseFloat, NaN is returned, indicating that the string cannot be recognized as a numeric type. This is an exception status and not an exact value. .

So NaN != NaN , because it is an exception status, not an exact value.

In addition, there is a function related to NaN, namely isNaN(). Its function is to check whether a string can be successfully converted by Number(), that is, to force the entire string to be converted.

isNaN( "123" )  //false 能转换
isNaN( "abc" )  //true 不能转换
isNaN( "123abc" )  //true 部分可转换，但整体不能转换
isNaN( "123.45abc" ) //true 部分可转换，但整体不能转换

2. There are two other special types in JS: undeinfed and null

undefined is one of the 6 data types in JavaScript This type has only one value, which is undefined. undefined means `undefined`, that is, when a variable is declared using var but no value is assigned, the value of the variable is undefined. There are two reasons for this:

(1) The access object does not exist Attribute or method

(2) The variable is declared but never assigned a value

var v1,obj = {};
console.log(v1); //undefined
console.log(obj. get ); //undefined
typeof v1; // "undefined"
typeof v2; // "undefined"
typeof obj. get ; // "undefine"
typeof obj ; // "object"

The difference from NaN is that although undefined also represents a state of the variable, this state value is definitely unique. That is, when a variable is declared but not assigned a value, its status is undefined, so the following expression is true:

var b;
b == undefined; //true

After understanding undefined, it will be much easier to understand null, and there is only one null type. Value: null, indicating that a variable does not contain valid data. Null here means empty value or empty object. To be more precise, a variable assigned to null does not store a valid value, string, Boolean, array or object, etc. It can be solved by assigning null to a variable. Clear the contents of the variable. There is only one reason for null: that is, explicitly assigning null to a variable.

var p = null ;
console.log(p); //null
typeof p ; // "object"
typeof null ; // "object"

Let’s compare it with NaN. Null is also a certain and unique state value. When a variable is assigned to null, it is equal to null, so the following expression is also true:

var obj = null ;
obj == null ; //true

In addition:

var  v1 = null;
var v2;
console.log(v1 + 1 ); // 1
console.log(v2 + 1 ); //NaN
var i = i +1;
var j = i+ 1;
console.log(i); // NaN
console.log(j ); //NaN
console.log(i == j ); //false

The above is what I compiled for everyone. I hope it will be helpful to everyone in the future.

Related articles:

How to use fs.rename in node.js to implement forced renaming

Use npm to create a vue project ( Detailed tutorial)

Is there an error when calling fs.renameSync in Node.js?

How to configure the React Native development environment in VSCode

The above is the detailed content of What are the special data types in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!