javascript数据类型和类型转换

一数据类型

1)typeof 查看数据类型

1.number 数字

取值范围：正无穷 - 负无穷、NaN 正无穷:Number.POSITIVE_INFINITY 负无穷:Number.NEGATIVE_INFINITY

 var v = NaN;

 alert(typeof v);//number

2.string 字符串

 var v = "";

 alert(typeof v);//string

3.boolean 布尔值 true | false

 var v = true;

 alert(typeof v);//boolean

4.undefined 未定义

var v;

alert(typeof v);//undefined

5.function 函数

 var v = function(){ };

 alert(typeof v);//function

6.object 对象: 元素、null、数组、json

 var v = [];

 alert(typeof v);//object

总结：number/string/boolean/function/object/undefined

2)标准：

基本类型: number/string/boolean/undefined/null 复合类型: object

二、强制类型转换

1）转换成数字

方法一：parseInt 解析成整型(整数)

解析规则：从第0位开始，一位一位的查看是否是数字，如果到某一位不是数字，就把这位之前的数字提取出来，如果第0就不是数组，返回NaN

注意：

parseInt的第二个参数：parseInt(要转换的内容,进制);
0x是16进制前缀；
可识别最开始空格、+、-、0

 alert(parseInt(' +00123'));//

 alert(parseInt('0xf'));//

 console.log(parseInt("12.724.12.234")); //

 console.log(parseInt("1a12s"));//

 console.log(parseInt(".123"));//NaN

 console.log(parseInt("s12345"));//NaN

 console.log(parseInt(true));//NaN

 console.log(parseInt(""));//NaN

 console.log(parseInt(" +00123"));//

方法二：parseFloat 解析成浮点型(小数)

解析规则：和parseInt一样，不一样的是，可以多解析一个小数点

 console.log(parseFloat("12.724.12.234")); //12.724

 console.log(parseFloat("1a12s"));//

 console.log(parseFloat(".123"));//0.123

 console.log(parseFloat("s12345"));//NaN

 console.log(parseFloat(true));//NaN

 console.log(parseFloat(""));//NaN

方法三：Number

解析规则：在进行数字转换时，完整的把要转换的内容看一遍，必须完全符合数字的规范才去进行转发，否则返回 NaN 特殊解析：

1.布尔值： true 1 false 0

2.字符串空字符串'' 0 只有空格的字符串' ' 0 最开始含空格、+、-、0 " +00123"->123

3.undefined NaN

4.function NaN

5.object null

 console.log(Number(null));//

6.json

 console.log(Number({}));//NaN

数组当数组只有一位时，就去转换这一位:这一位是数字，或者字符串，或者undefined，就会进行转换否则NaN

 var v = [];

 console.log(Number(v));//

 var v = [''];

 console.log(Number(v)); //

 var v = [' '];

 console.log(Number(v)); //

 var v = [' +00112'];

 console.log(Number(v)); //

2)转换成字符串 String

实际就是直接加上引号，变成字符串

 var a = 12323;

 console.log(String(a));//

 var a = true;

 console.log(String(a));//true

 var a = function(){};

 console.log(String(a));//function(){}

3)转换成布尔值 Boolean

true: 非0的数字, 非空字符串, 函数, 非空对象 false: 0, NaN , 空字符串, undefined, null

注意：

1.空对象不能进行属性操作

 var a = [];

 console.log(Boolean(a));//true

三、运算符

1）算术运算符

+ 加、- 减、* 乘、/ 除、% 取模（求余数）、++、--

2）赋值运算符

=、+=、-=、*=、/=、%= a += b; //a=a+b; a -= b; //a=a-b; a *= b; //a=a*b; a /= b; //a=a/b; a *= b; //a=a%b;

3）关系运算符

<、>、<=、>=、== 相等、!= 不等、===、!== 比较后都会返回布尔值

4）逻辑运算符

&& 与、|| 或、! 否 ?:三元运算符

1. && 两侧必须都为true 才会返回 true 否则返回false

 var a = 1;

 var b = 3;

 console.log(a!=b && a > b);//false

2. ||两侧有一侧为true 就会返回 true，否则返回false

 console.log(a!=b || a > b);//true

3. !

 console.log(!(a != b));//false

4. 三元运算符判断条件?成立的返回值:不成立的返回值;

 var a = 0;

 var b = 1;

 var c = a > b?a:b;

 console.log(c);//

 //利用逻辑运算符简化运算

 var a = 1;

 var b = 1;

 function fn(){

 alert("条件成立");

 }

 function fn2(){

 alert("条件不成立");

 }

 /*if(a != b){

 fn();

 } else {

 fn2();

 }*/

 //&&并且:(当第一个条件成立时，才会去执行第二条件) 当左侧成立时就会只执行右侧代码，否则直接返回 false

 //第一个条件为false,不会执行fn

 a!=b&&fn();

 //当第一个条件成立时，返回true，语句结束，条件不成立就会去 执行右侧

 //第一个条件为false,会执行fn2

 a!=b||fn2();

四、隐式类型转换

1)+,++,+=:

1. 碰到字符串就执行字符串拼接

2. 如果可以转换成数字，就进行数字相加(Number转换成数字)

3. 如果不能把左右两边都转成数字，就执行字符串连接

 var a = function(){};

 var b = 1;

 alert(a + b);//function(){}1

2)- 减、* 乘、/ 除、% 取模（求余数）、--:

会把左右两侧都转成成数字，进行相关操作，不能转换成数字就返回NaN

 var a = function(){};

 var b = 1;

 alert(a - b);//NaN

3)==、!= 会进行类型转换

===、!== 类型不一样，直接返回false

 var a = true;

 var b = 1;

 alert(a == b);//true

对于string,number等基础类型，==和===是有区别的
- 不同类型间比较，==之比较“转化成同一类型后的值”看“值”是否相等，===如果类型不同，其结果就是不等
- 同类型比较，直接进行“值”比较，两者结果一样
对于Array,Object等高级类型，==和===是没有区别的
- 进行“指针地址”比较
基础类型与高级类型，==和===是有区别的
- 对于==，将高级转化为基础类型，进行“值”比较
- 因为类型不同，===结果为false

”==”与”===”是不同的,一个是判断值是否相等,一个是判断值及类型是否完全相等。

下面的规则用于判定===运算符比较的两个值是否相等的判断条件

如果两个值的类型不同，它们就不相同。
类型相同
- 如果两个值是数字，而且值相同，那么除非其中一个或两个都是NaN(这种情况它们不是等同的),否则它们是等同的。值NaN永远不会与其他任何值等同，包括它自身(奇怪的家伙),要检测一个值是否是NaN，可以使用全局函数isNaN()。
- 如果两个值都是字符串，而且在串中同一位置上的字符完全相同，那么它们就完全等同。如果字符串的长度或内容不同，它们就不是等同的。
- 如果两个值都是布尔型true，或者两个值都是布尔型false，那么它们等同。
- 如果两个值都是null或都是undefined，它们完全相同。
- 如果两个值引用的是同一个对象、数组或函数，那么它们完全等同。如果它们引用的是不同的对象（数组或函数），它们就不完全等同，即使这两个对象具有完全相同的属性，或两个数组具有完全相同的元素。

下面的规则用于判定==运算符比较的两个值是否相等的判断条件

如果两个值具有相同的类型，那么就检测它们的等同性。如果这两个值完全相同，它们就相等。如果它们不完全相同，则它们不相等。
如果两个值的类型不同，它们仍然可能相等。用下面的规则和类型转换来检测它们的相等性

如果一个值是null，另一个值是undefined，它们相等。
如果一个值是数字，另一个值是字符串，把字符串转换为数字，再用转换后的值进行比较。
如果一个值为true，将它转化为1，再进行比较。如果一个值为false，把它转化为0，再进行比较。
如果一个值是对象，另一个值是数字或字符串，将对象转换成原始类型的值，再埋比较。可以使用对象的toString()方法或valueOf()方法把对象转化成原始类型的值。JavaScript核心语言的内部类通常先尝试valueOf()方法转换，再尝试toString()方法转换，但是对于Date类，则先执行toString()方法再执行valueOf()方法转换。不属于JavaScript核心语言的对象则可以采用JavaScript实现定义的方式把自身转换成原始数值。
其他的数值组合是不相等的。

练习：

     console.log([] == ![])

     [] == ![]  // -> true

     1. 首先js引擎要计算的是等号右边的![]，右边到 [] 为true，![]取反得到 false

     2. 所以式子现在为 : [] == false

     3. 由第3条规则，所以 [] == ToNumber(false), 即 [] == 0

     4. 因为[]的typeof是Object，0的typeof是Number，所以根据第4条规则， ToPrimitive([]) == 0， 即 '' == 0

     5. 由第2条规则，''的typeof是String，0的typeof是Number，所以ToNumber('') == 0 ，即 0 == 0

     6. 所以打印出true

4)! 取反

 alert(!"");//true

五、NaN

NaN: (not a number) 这不是一个数字数据类型：number 注意：NaN 不等于任何数字，并且不等于它自己

 var a = "100px";

 var b = "100px";

 alert(Number(a));//NaN

 alert(Number(b));//NaN

 alert(Number(a)==Number(b));//false

六、isNaN

isNaN 检测一个数据转换成数字之后，是否是NaN，是返回true，否则返回false

 var a = true;

 alert(isNaN(a));//false

有一种可靠的并且准确的方法可以检测NaN：只有NaN是自己不等自己的，那么，我们就以使用不等于号（！==）来判断一个数是否等于自身，从而，可以检测到NaN了

 function isReallyNaN(x) {

     return x !== x;

 }