JS基础-基本数据之间类型如何转换

数据类型

分类：
	原始值数据类型
		Number数字类型:包括整数和小数 12 12.3
		String字符串：“” '' 输出的时候原样输出 
		Boolea布尔类型：true真值
		Undefined未定义

方法：
	isNaN 用来判断一个变量是否为非数字的类型
			返回是布尔变量
	typeof() 检测变量的数据类型
转义字符：
	\n 换行   \\表示 \   \t 制表符   \b 空格

<script>
        // 定义了值，分辨数据类型
        var num=123;
        var sex = true;
        alert("num的值"+num);
        // 未定义值
        var a;
        alert("第二个数a"+a);
        //prompt：弹出三种：输入值输入的值 空白 null
        //confirm:弹出两种：true false
        //alert:  一种：undefined
        var sname= alert("点击确定");
        alert(sname);
</script>

<script>
        var num1  = 1314;
        var num2  ="肯德基"
        var num3  = false;
        var num4 ;
        var num5 = "123456";
        document.write(num1+"                        ");//多个空格为一个空格
        document.write("<br/>")；//出现换行效果
        document.write(num2+"                        ");
        document.write("<input type='text' />")//输入框出现
        document.write(num3+"                        ");
        document.write(num4+"                        ");
        console.log(isNaN(num1));
        console.log(isNaN(num2));
        console.log(isNaN(num3));//false转换成0，true转换成1，都是数字
        console.log(isNaN(num4));
        console.log(isNaN(num5));
        console.log(typeof(num1));
        console.log(typeof(num2));
        console.log(typeof(num3));
        console.log(typeof(num4));//undefined
        console.log(typeof(num5));
    </script>

数据类型之间的转换

一、转换成字符串类型:使用.toString或者String。
1、**.toString()**方法：注意，不可以转null和undefined

//转为字符串-->toString方法
var bool=true;
console.log(bool.toString());
//注意，toString不能转null和underfined.

2.**String**方法：都能转

console.log(String(null));

3.隐式转换：num+"",当 + 两边一个是字符串类型，一个是其他类型时，会把其他类型转换成字符串再进行字符串拼接，返回字符串

var a=true;
var str= a+"";
console.log('str');

二、转换成数字类型
1.**Number()**:Number可以把任意值转换成数值，如果要转换的字符串中有一个不是数值的字符，返回NaN

		var num1="abc";
        console.log(Number(num1));//NaN
        var num1="12a";
        console.log(Number(num1));//NaN
        var num1 ="123";
        console.log(Number(num1));//123
        var num1 =123;
        console.log(Number(num1));//123
        var num1 =true;
        console.log(Number(num1));//1
        var num1 ="true";
        console.log(Number(num1));//NaN
        var num1 =Boolean;
        console.log(Number(num1));//NaN
        var num1;
        console.log(Number(num1));//NaN
        var num1=null;
        console.log(Number(num1));//0
        var num1="";
        console.log(Number(num1));//0
        var num1=undefined;
        console.log(Number(num1));//NaN

只有字符串里是纯数字，数字类型，布尔类型，null,"" 转换为数字类型是数字

2.**parseInt(变量名)**:转换为整数类型

var a="12.3px";
console.log(parseInt(a);
//结果：12.3.  如果第一个字符是数字会解析知道遇到非数字结束.
var a="abc2.3";
console.log(parseInt(a);
//结果：返回NaN，如果第一个字符不是数字或者符号就返回NaN.
var num1 = "9.8";
console.log(parseInt(num1));//9
//使用parseInt，是向下取整，计算器中没有四舍五入。

3.**parseFloat()**:parseFloat()把字符串转换成浮点数，parseFloat()和parseInt非常相似，不同之处在与parseFloat会解析第一个. 遇到第二个.或者非数字结束如果解析的内容里只有整数，解析成整数。

		var num1 = 0.200;
        var num2 = true;
        console.log(parseFloat(num1));//10.9
        //使用parseFloat,10.9变为10.9，10.0变为10，0.200变为0.2

4.隐式转换：

var str="123";
var num=str-0;
console.log(num);
//结果为数值型；

三、转换成布尔类型:0  ''(空字符串) null undefined NaN 会转换成false  其它都会转换成true

1.**Boolean()**:

		var num1 = true;
        var num2 = "a";
        var num3 = 123;
        var num4 = 0;
        var num5 ="0";
        var num6 ="1";

        console.log(Boolean(num1));//true
        console.log(Boolean(num2));//true
        console.log(Boolean(num3));//true
        console.log(Boolean(num4));//false
        console.log(Boolean(num5));//true
        console.log(Boolean(num6));//true

布尔：1.只有大小比较:只有布尔才会转为数字类型。
* 2. 只有0 false转换为boolean类型为false，
* 1 true转换为boolean类型为true。

算术运算符

+= -= *= /= %=
优先级：() 大于 % * / 大于 + - 大于 =（一个等于号是赋值优先级最低）

+：1.加法运算 2.拼接

		var a = "a" + true + 1;
        console.log(a);//atrue1

        var b = 1+"b" + 1 +1;
        console.log(b);//1b11

        var c = 1+1+"c"+1+1;
        console.log(c);//2c11

        var d = 1+1+"d"+(1+2);
        console.log(d);//2d3

结论：只有两边都是Number类型才会进行加法运算

		var a='10',b='8';
        console.log(a+b);//输出108
        console.log(a-b);//输出2

结果1：两边是字符串。发现只有 减乘除 才会自动转化为数字。

		console.log(typeof(a+b));//输出string
        console.log(typeof(a-b));//输出number

结果2：两边是字符串。发现加法需要通过 Number,parseFloat进行显示转化。

引申，如果一边为数字类型，用+，另一边会不会自动类型转化呢？没有

		console.log(a+Number(b));//输出108
        console.log(typeof(a)+typeof(Number(b)));//string number
        console.log(Number(a)+b);//输出108

减乘除取余运算：

		var a = 0-1;//-1
        var a = 2*1;//2
        var a = 0/0;//NaN
        var a = 1/0;//Infined正无穷
        var a = -1/0;//-Infined
        console.log(a);
        //优先级：乘除 大于 加减

复合运算符

    ++ --   += -= *= /= %=

+= -= *= /= %=

		a+=10;//a=a+10
        a-=10;//a=a-10
        //同理乘除取余相同
        a=a+=10=a-=10
        a=a+=10=a=a-10//页面出错。原因：不能将a赋值给表达式a+=10 */
```js
++、--
		a++  ++a
        //++在前先自增后运算  ++在后先运算再自增
    

```js
		var a = 10;
	    var b = 20;
	    console.log(a++);
	    // 上面结果为 10  解释： ++在后是先运算后自增
	    console.log(a);
	    // 在上面输出后a已经进行自增所以此处为11

关系运算符(比较运算符)

!= == ！== === > < >= <=
获取到的值始终是boolean

 类型1             类型2           方式
    数字        布尔          进行数字的比较
    数字        字符串      把字符串转换为数再比较（视情况而定）
    布尔        布尔         把两边都转换为数字在进行比较
    null         undefined   true
    null、undefined      其他类型比较    都是false

<script>
		/* 1.布尔和数字比较，进行数字的比较 */
        console.log(true == 1);//true。1==1
        console.log(true>0);//true。
        /* 2.数字和字符串比较，把字符串转换为数再比较（视情况而定） */
        console.log("123">10);//true
        console.log("123">"abc");//false。比较ASCII码值。
        console.log("123000">"12a");//false。字符串不全是数字，将字符串转换为NaN。
        //两个都是纯字符串，则按照一个个字符串比较。
        console.log('aac'>'ab')//false,短的比较完毕就结束
        console.log('aqa'>'bob')//false,第一个比较为false就为false
        console.log('bq'>'bb')//true,除第一位以外，存在真就为真
        console.log('bqa'>'bbb')//true，
        console.log('bac'>'aff')//true,存在真了，后面为假不管用
        /* 3.布尔和布尔，把两边都转换为数字在进行比较 */
        console.log(true>false);//true
        /* 4.null、undefined与其他类型比较，都是false */
        console.log(Number(true));//1
        console.log(Number(null));//0
        console.log(Number(undefined));//NaN
        console.log(null>0);//false。0>0错
        console.log(null>false);//false。NaN和任意比较都为false。
        /* 5.null、undefined */
        console.log(null==undefined);//true
        /* 拓展:关系运算符跟相等运算符在针对null，undefined这两个特殊数据类型时，所呈现的结果都不一样 */
        //关系运算符:null，undefined会被Number()强制转换成数字类型
        console.log(null>=0);//true
        console.log(undefined>=0);//false
        console.log(null>=null);//true
        console.log(undefined>=undefined);//true
        //Number(null)  //0,即0 >= 0  --true
        //Number(undefined) //NaN,即NaN >= 0  --false
        //Number(null)  >=  Number(null)  即 0>=0，true！
        //Number(undefined) >= Number(undefined)  即 NaN>=NaN，false!（注意：NaN不等于NaN）
        //相等运算符:null与undefined对比，即都为true
        console.log(null==0);//false
        console.log(undefined==0);//false
        console.log(null  == undefined);//true
</script>        

逻辑运算符

&& || ！ 与 或 非 and or not
逻辑运算符两边可以是表达式，可以是变量，不能是等式。

五大假值：null、undefined、""、false、NaN

&& 与运算：两边的表达式，只要有一边为假，结果为假。只有两边都为真，结果才为真。

<script>
        console.log(false&&0);//false
        console.log(false&&-1);//false
        console.log(true&&0);//0
        console.log(true&&-1);//-1
        console.log(0&&-1);//0
        console.log(0&&2);//0
        console.log(1&&2);//2
        console.log(2&&"abc");//abc
         /** &&总结：1.只有都为真，结果才为真。只要有一边为假，结果为假
                2.左边为真值（true或任意非0值），结果为右边的值。
                3.左边为假值（false或0)，结果为假值原样输出。
                4.所有非0的数，从左至右执行，都是真值，取最右边的数。
         */
 </script>

|| 或运算：两边的表达式，有一边为真，结果就为真。

		console.log(6<5||undefined);//undefined
		//都为false,取后面的。
        console.log(6<5||undefined||null);//null
        //都为false,取最后的，从左往右执行
        console.log(6<5||true);//true
        //有一个为true,结果为真
        console.log(1+4||5+6);//5
        //有一个为true,后面不执行
        /** ||总结：1.从左往右顺序执行，表达式都为假，取最后一个表达式的假值
                2.只要有一个表达式为真，结果为真，后面不再执行。
				3.有表达式为真时，取真值，输出。
         */

! 非运算：取反

console.log(!true);//false
console.log(!4>5);//false//!4是NaN,假值大于真值
console.log(!(1>3&&4>5)||false);//true.//（！true||false）为真

位运算符

& | 位与 位或
>> << 右移 左移

& 位与：将数据转换为2进制并且逐位相与

<script>
	console.log(3&7);//3
	//3: 0   0   0
	//7: 1   1   1
	//&: 0   1   1
	//二进制数011是3
</script>

| 位或：将数据转换为2进制并且逐位相或

console.log(17|35);//51
	//17: 0   1   0   0   0   1
	//35: 1   0   0   0   1   1
	//| : 1   1   0   0   1   1
	//二进制数110011是51