运算符与逻辑分支

运算符与逻辑分支

1.一元运算符

++ 自增 --自减

字符串类型 对于字符串来说自增或自减会自动进行类型转换

var str='10'
str++ //str = Number(str)+1 自动转换 从String转为number
str = 'abc'
str++ //NaN 对于转换不成功的String类型数据会变为NaN

关于布尔类型

var bol = true //1为true 0 为false
bol++ //number类型 非0和NaN就是true

关于null类型

var no = null 
no-- //自动转换对应boolean类型 然后再从boolean转为number

关于undefined

var und 
und++ //undefined 转换不成功 NaN

关于Number类型

var num = 10 
console.log(num++)//10
console.log(num--)//11
console.log(num)//10

复杂的自增 自减

var str1 = '123'
//Boolean布尔类型转换
var bool = Boolean(str1)
console.log(bool--)//1
console.log(--str)//122
//123ab
var str2 = str1+'ab'
console.log(str2--)//NaN

一元运算符只能和变量一起 不能出现其他运算符

关系运算符

比较运算符 ==

返回都是Boolean类型 要么是true 要么是false

==比较是值

console.log(null==undefined) //true
console.log(Boolean(null)==Boolean(undefined))//true   

大于 > 小于 <

number比较 直接比较大小

number和boolean比较 将boolean转为number(0,1)

如果是number类型和字符串类型比较 如果字符串里面存储的是数值 对应的就是数值比较

如果对应的字符串里面存储的是字符串 会自动转化为number类型 转不了就是NaN

字符串跟字符串比较 比较的是ascii码 一套固定的编码 每个字母都有一个对应的编码值（区分大小写）

a 97 A 65 0 48

console.log(5>4) //true

boolean 自动转换 true对应1 number类型转布尔类型 true

console.log(true>3) //false
console.log(true==1) //true 自动转换是boolean转为number
console.log(null==false) //null不会自动转换为boolean类型
console.log(undefined==false) //undefined也不会自动转换为boolean类型

大于等于 >= 小于等于 <= 只要满足其一就为true

console.log(true>=1) //true
console.log(true<=1) //true

不等于

console.log(2!=3) //true
console.log(3!=3) //false

=赋值

var b = 10 
var a = b++
console.log(a) //10
var c = ++b
console.log(c) //12

NaN 特性 不能进行比较 返回结果false

var na = Number('abc')
console.log(NaN==Number('abc'))
console.log(na==NaN)

恒等 === 比较值还要比较地址

var a = '123'
var b = 123
console.log(a==b) //true
console.log(a===b) //false

逻辑运算符

&& & 断路与（效率低 不用）

与 同true则为true 其他都是false

与 只有所有条件都是true的时候返回才是true && 断路与 &

console.log('A'<'a' && 2>1) //true
console.log('A'>'a' && 2>1) //false

|| 或

一个为true就是true || 断路或 |

console.log('A'<'a' || 2<1) //true
console.log('A'>'a' || 2<1) //false

! 非

取反 true变false false变true

console.log(!('A'>'a')) //true
console.log(!('A'<'a')) //false

undefined转为number NaN

undefined值 不需要转换的 !=

var number1,number2=10
console.log(number1!=number2 && number1<number2) //false
console.log(number1!=number2 || number1<number2) //true
console.log(number1!<number2 || !(number1<number2)) //true

三元运算符 三目运算符

布尔类型表达式?true的结果:false的结果

console.log(!0?10:20)
console.log(1!=1?10:20)
var number = 1!=1?0:null
console.log(number?'a':'b') //b

位移运算

<< >> 针对二进制

2怎么快速变成8

10 1000 后面补零

console.log(2<<2)

1+1 1-1 运行哪个快2 //一减一 因为一加一要进位

分支结构

浏览器解析的结构为顺序结构 从上到下 从左到右

分支结构 多个分支 进行其中一个

if else

条件会找最先满足的if块 都不满足进入else块

保持缩进 代码规范 方便他人阅读

if(布尔类型表达式){

分支一

}else{

不满足上述条件进入的分支

}

如果我有五块钱 我就买冰淇淋 如果没有我就去搬砖

var myMoney = 10 
if(myMoney>=5){
	console.log('买冰淇淋')
}else{
	console.log('搬砖')
}

多个分支

myMoney = 200

if(myMeney>=20){ //一旦进行其中一个分支就不会再进行下一个
	console.log('上网')
}else if(myMoney>200){
	console.log('唱ktv')
}else{
	console.log('搬砖')
}

简化写

if(myMoney){
	console.log('有钱任性')
}else{
	console.log('没钱搬砖')
}

分支块里面执行的语句只有一句就可以省略对应的{}

if(myMoney)
	console.log('有钱任性')
else
	console.log('没钱搬砖')

分支语句的嵌套 无限嵌套的 但是嵌套的越多 他的时间复杂度越大（执行越慢）

var t1 = 10=='10' //true
var t2 = 20!=='20'?0:1 //0 false
var t3 = 30+'10'==3010?null:10 //null false
if(t1){
	console.log('进入第一个if块')
	if(t2){
		console.log('进入第二个if块')
		if(t3){
			console.log('进入第三个if块')
		}else{
			console.log('进入第三个else块')
		}
	}else{
		console.log('进入第二个else块')
	}
}else{
	console.log('进入第一个else块')
}

switch

switch 属于分支结构

if里面的表达式为boolean表达式 switch为值表达式 有确定的值

switch case一起使用

switch(值表达式){

case 值1:

case 值2:

case 值3:

default: //默认的

}

case 值 break 跳出这个switch块

当不存在break的时候 他会从匹配的选项走到底

switch支持任意类型值 NaN除外

var a
switch(a){
	case undefined:
		console.log('这个是一条语句')
		console.log('这个是结束的语句')
		break
	case 'undefined':
		console.log('undefined的string值')
		break
	default:
		console.log('这个是默认值')
		break
}

判断一个成绩 59 60都算及格

var s = 59
switch(s){
	case 60: case 59:
		console.log('恭喜你及格了')
		break
}