javascript类型转化和操作符

类型的强制转化

指将一个数据类型强制转换为其他数据类型

将其他数据类型转换为String

显性转换
方式一：
调用被转换数据类型的toString()方法
该方法不会影响到原变量，它会将转换的结果返回
但是注意：Null和Undefined这俩个值没用toString()方法

var a = 1156;
a = a.toString();
console.log(a);					//a = 1156  是字符串
console.log(typeof a);         //string   

布尔转字符

a = true;
a = String(a);
console.log(a);			//true  字符串			false同是
console.log(typeof a);	//string

a = null;
a = a.toString();
console.log(a);				
console.log(typeof a);		//报错  undefined 也会报错

方式二：
使用String()函数进行数据转换
对于Number和Boolean实际上就是调用的toString()方法
对于Null和Undefined

1.会将null，直接转换为字符串"null";

a = null;
a = String(a);
console.log(a);			//null(字符串)	
console.log(typeof a);	//string

2.将undefined，直接转换为字符串"undefined"

a = undefined;
a = String(a);
console.log(a);				//undefined(字符串)           
console.log(typeof a);		//string

隐形转换
+" " / +""

var x = 100; //数值类型的--->字符串
console.log(x);					//"100"
x = console.log(typeof(x + ''));		//string

将其他类型转换为Number

方式一：
使用Number()函数
显性转换

1.如果纯数字的字符串，则直接将其转换为数字

var a = "123";
a = Number(a);
console.log(a);			//123
console.log(typeof a);	//number

2.如果字符串中有非数字的内容，则转换为NaN

a = "abc";
a = Number(a);
console.log(a);			//NaN
console.log(typeof a);	//number

3.如果字符串是一个空串或者全是空格的字符串时，则转换为0

a = "";
a = Number(a);
console.log(a);			//0  数字零
console.log(typeof a);	//number

布尔转数值
true是1，false是0

a = true;
a = Number(a);
console.log(a);			//1     false是0
console.log(typeof a);	//number

null转换为数字是0

undefined转数字为NaN

方式二：parseInt()
方式三：parseFloat()
三者之间的区别：
Number()只能将纯数字的字符串转为数字类型
parseInt()只能将数字开头的字符串转为整数类型
parseFloat()只能将数字开头的字符串转为小数类型

var x = '100.256px';
console.log(Number(x));		//NaN
console.log(parseInt(x));	//100
console.log(parseFloat(x));	//100.256      //都是number类型

隐形转换
隐式转换 +（特殊,放在变量前面） - * / %

var x = 200;
console.log(x - 0); //隐式转换		200
console.log(x * 1); //隐式转换		200
console.log(x / 1); //隐式转换		200
console.log(x%101); // 除以一个比它大的数字		200
console.log(+x);// 正号				200

将其他的数据类型转换为Boolean

使用Boolean()函数

数字转成布尔

1.除了0和NaN是false，其余全是true

var a = 123;
a = Boolean(a);				//true

var a = 0;
a = Boolean(a);				//false  

var a = NaN;
a = Boolean(a);				//false  

字符串转成布尔
**1.除了空串，其余全是true

var a = "你是猪！";
a = Boolean(a);		//true

var a = " ";
a = Boolean(a);		//false

2.null和undefined都会转换为false**

var a = null;
a = Boolean(a);		//false

var a = false;
a = Boolean(a);		//false

隐形转换

var a = "";
a = !!a;			//false

运算符（操作符）

通过运算符可以对一个或者多个值进行运算，并获取运算结果

算术运算符

当对于非Number类型的值进行运算时，会将这些值转换为Number，然后进行在进行运算。

**+**可以对俩个值进行加法运算，并将结果返回

var a = 123;
result = a + 1;
console.log(result);			//124

任何值和NaN做运算都得NaN

var result = 
result = 2 + NaN;
console.log(result);		//NaN

1.任何值和字符串做加法运算，都会先转换为字符串，然后在和字符串做拼串操作

var result = "123" + "456"; 
console.log(result);			//123456

result = true + null;
console.log(result);			// 1

任何值和字符串做加法运算，都会先转换为字符串，然后在和字符串做拼串操作

result = true + 1;
console.log(result);			//2

result = "你好！" + "大帅哥";
console.log(result);			//你好大帅哥

result = "锄禾日当午，" +   //双引号不能换行    +号可以进行拼串操作	 
		 "汗滴禾下土。" +
		 "谁知盘中餐，" +
		 "粒粒皆辛苦。";
		 console.log(result)  //锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦。

- * / %
除了加法之外，在其他运算中，会将其他类型转换为数值类型进行计算
- 减法

result = 100 - "10";  //90
result = 100 - true;  //99
result = 100 - "true"; //NaN 字符串转数字，字符串中有非数字的内容会转成NaN

* 乘法运算
字符串转数字，字符串中有非数字的内容会转成NaN

result = 2 * 2;  //4
			
result = 2 * "8";  //16
			
result = 2 * undefined;  //NaN
			
result = 2 * null;  //0
			
result = 2 * false; //0

/ 除法

result = 2 / 2;		//1
result = 9 / 2;		//4.5

% 求余（取模）

result = 9 % 3;		//0
			
result = 9 % 5;		//4

赋值运算符

= += -= /= *= %=

+=

var a = 10;
a += 10;
console.log(a); //=> 20
a += 10 等价于 a = a + 10

%=

var a = 10;
a %= 10;
console.log(a); //=> 0
a %= 10 等价于 a = a % 10

其他赋值运算符类似
*=

var a = 10;
a *= 10;
console.log(a); //=> 100
a *= 10 等价于 a = a * 10

-=

var a = 10;
a -= 10;
console.log(a); //=> 0
a -= 10 等价于 a = a - 10

/=

var a = 100;
a /= 10;
console.log(a); //=> 10
a /= 10 等价于 a = a / 10

关系运算符

== 比较符号两边的值是否相等，不管数据类型

1 == '1';		//两个的值是一样的，所以得到 true

=== 比较符号两边的值和数据类型是否都相等

1 === '1';		//两个值虽然一样，但是因为数据类型不一样，所以得到 false

!= 比较符号两边的值是否不等

1 != '1'			//因为两边的值是相等的，所以比较他们不等的时候得到 false

>= 比较左边的值是否 大于或等于 右边的值

1 >= 1 true
1 >= 0 true
1 >= 2 false

<= 比较左边的值是否 小于或等于 右边的值

> 比较左边的值是否 大于 右边的值

< 比较左边的值是否 小于 右边的值

逻辑运算符

&& 与运算
自左向右

都是true则返回true

var result = true && true;
console.log(result);			//true

俩个值中只要有一个值为false,就返回false

result = true && false;
console.log(result);			//false
result = false && false;
console.log(result);			//false
result = false && true;
console.log(result);			//false

true && alert("你看我出不出来!"); 		//第一个值为true,会检查第二个值
false && alert("你看我出不出来!");		//第一个值为false,不会检查第二个值

|| 或运算

俩个值都是flase,则返回false

result = false || false;
console.log(result);			//false

俩个值中只要有一个true,则返回true

result = true || false;
console.log(result);			//true
result = false || true;
console.log(result);			//true
result = true || true;
console.log(result);			//true

true || alert("123");			//第一个值为true,则不会检查第二个值
false || alert("123");			//第一个值为false,则会检查第二个值

!非运算
！可以对一个值进行非运算
true变false；false变true

var b = 0;			//0是false
b = !!b;			//所有!!b也是false
console.log("b = "+b);		//b = false
console.log(typeof b);		//boolean

对非布尔值进行运算，则会将其转换为布尔值，然后在取反。
可以为一个任意数据类型取反俩次,来将其转换为布尔值.

一元运算符

自加自减
后置++，会先把值返回，在自动+1/-1

var n1 = 10, n2 = 20;
var n = n1++;
console.log("n = "+n);  			//10
console.log("n1 = "+n1);			//11  n1等于n1++运算完成之后的值：11

自减
后置- -

n = n2--;             
console.log("n = "+n);  //20
console.log("n2 = "+n2);//19

前置++
前置++，会先把值自动 +1/-1，在返回

n = ++n1;                       
console.log("n = "+n);  	//12
console.log("n1 = "+n1);	//12

前置- -

n = --n2;
console.log("n = "+n);  //18
console.log("n2 = "+n2);//18

调试

• 操作步骤：
  在浏览器中–>进入检查模式–>sources–>文件名–>打断点（需要观察代码的行数）–>刷新页面–>step over–>结束调试，取消断点