在学习 整理一些运算符

一元运算符

x++

会只按数值运算，不会进行字符拼接

var x=3;
console.log(x++);        //x++等同于 x=x+1,它和 x+=1 不同	

var x="4";
console.log(x++);		//5
console.log(x+=1);		//字符串41

​

x++ 和 ++x

对x来说是一样的，但是它俩的返回值是不同的

var x=1;
console.log(x++);			 // 1  先返回x,再让x+1
console.log(++x); 			 // 2  先让x+1,然后返回x+1的结果
// 同理，--x 与 x-- 也是如此

var x=1;
var y=x+++x+++x+++x---x+x+++x+++x-x+++2;
console.log(x,y);

关系运算符

关系运算符 > >= < <= == ==== != !== 关系运算符返回的是布尔值

隐式转换为数值

var a="5";
console.log(a>6);		//false    与6进行比较，将字符串"5"转换为数值5，再与6比较，输出false

var a="b";
console.log(a>4);		//NaN    与数值4进行比较，将变量a转换为数值，转换后是NaN，NaN与任何数值比较都是false

// 如果关系运算符两边都是字符串，那么就会隐式转换为Unicode编码后再进行比较
console.log("a">"F");	//true
console.log("aa">"ab");		//true	第一个比完就比第二个

console.log(true>null);		// true  true会转换为1,null转换为0
console.log(1>false);		//true    false会隐式转换为0
console.log(true>undefined);		//false		undefined转换为字符串，然后转换为数值，转换后是NaN，NaN与任何数值比较都是false

有数组参与

console.log([]>-2);		//true	[]转换为数值是0,0>-2
console.log(![]>0);		//false    ![]的意思是布尔型，而![]转换为布尔型是false，再用false 和0进行比较，false转换为0，比较结果false
console.log(![]>[]);		//false		![]是false,[]转换为布尔型是true，再进行比较，转换为数值false为0，true为1

涉及到优先级的关系运算符运算

var x=3;
var y=3;
//	优先级中，赋值是最低的    赋值 低于 > < 低于 + - 
x+=3-x>2;	// 先算3-x为0,再算0>2为false,最后x+=false,即x+=0
console.log(x);		//3

y+=(3-x>2)+"";		// 先算括号里的,括号里的先算3-x为0,再算0>2为false,然后再加上空字符串隐式转换为字符串类型,即x+="false"
console.log(y);		// 字符串 3false

判断相等

两种方法

1. == 判断的时候会把两边的内容进行主动地隐式转换，转换之后再进行比较
2. === 进行判断的时候是直接进行比较

// 两边内容类型相同，直接比较内容
console.log({}=={a:1});		// false  类型相同，都是对象，内容不同

// 两边类型不同，隐式转换成字符串或数值或布尔型
console.log("[object Object]"=={a:1});		// true 进行隐式转换，对象转换换为[object Object]
console.log([1]==1);		// true  前面是数组，后面是数值，进行隐式转换，数组转换为数值1
console.log([]==0);		// true  前面是空数组，后面是数值，隐式转换，空数组转换为0

// 两个空数组，比较地址
console.log([]==[]);		// false


console.log(![]==[]);		// false
// ![]是布尔值，[]为true，![]为false       
// 此时，要把右边的[]也转换为布尔值   []先转字符串"",再由""转为布尔型false

console.log(5+([]+0));		// 字符串50  加法，转换为字符串    

var y=3;
var x=y>3;
console.log(x);		// false

==的隐式转换规则：

0==false;
0=="";
false=="";
undefined==null;		//undefined和null在进行相等判断时是相等的，都是表示变量没有值

 var x=1;
if(!x){
// 能进来的有   "" NaN  null undefined 0 false
}

if(x==undefined){
// 能进来的有null  undefined
}

if(x===undefined){
// 能进来的  undefined
}

//因为 == 的转换规则很麻烦，所以在比较时一律使用 ===

逻辑运算符

逻辑与 &&

// true   && true      true    
// true   && false     false
// false  && true      false
// false  && false     false   

// &&  遇到false即返回，没有false继续往后找直到最后

console.log(1 && 0);
console.log("" && "a");

console.log(3 && 5);
console.log(0 && "");

var x=3;
var y=x-3 && 3;			// 当x=3时y返回值为0，其他情况y返回值都是3
var y=x-3 && x-2 && 3;		// 当x=3时或y=2时y返回值为0，其他情况y返回值都是3
console.log(y);

逻辑或 ||

// true   || true      true   
// true   || false     true
// false  || true      true
// false  || false     false
// 遇到true直接返回第一个true      没有true则继续向后找，直到最后

console.log(0 || "");		// ""

var o={a:10};
console.log(o=o || {a:1});		// {a:10}
// 这句 o=o || {a:1} 其实就相当于下面的这个条件判断
if(!o){			// 如果为false    因为o是对象，布尔值为true，!o就是false
    o={a:1};		// 对o进行赋值操作
}

// 使用逻辑或就可以实现以下功能
class Box{
    static _instance;
    static getInstance(){
        return Box._instance || (Box._instance=new Box());		// 如果Box._instance为空，那么就创建一个新的Box._instance
    }
}

位运算符

进制运算

// 二进制
// 1  0

// 八进制	
//	0	1	 2	  3	 	4	  5		 6		7
//	0	1	10	 11	   100	  101	 110	111
// 二进制和十六进制的转换		三位一分
// 111 011 010 110
// 7	3	2	6        
// 转换结果 二进制数 111011010110 就是八进制数 7326

// 十六进制
//	0	1	 2	  3	 	4	  5		 6		7		8		9	  10    11	 12	  13   14	15
//	0	1	10	 11	   100	  101	 110	111		1000	1001	a	 b	  c    d	e	 f
// 二进制和十六进制的转换		四位一分
// 110 1011 0110 1101 0110
// 6	 b	  6	  d		6
// 转换结果 二进制数 110101101101101011 转换为十六进制为 6b6d6

位与运算 &

// 1	&	1	=	1
// 1	&	0	=	0
// 0	&	1	=	0
// 0	&	0	=	0
// 同时为 1 则为1    表现出 0 的特征

var a=true;
for(var i=10;i<100;i++){
    console.log(i&1);		// 实现开关的效果    即交叉输出 true 和 false
    // console.log(a=!a);		
}

位或运算 |

// 1	|	1	=	1
// 1	|	0	=	1
// 0	|	1	=	1
// 0	|	0	=	0
// 同时为 0 才为 0		表现出 1 的特征

for(var i=1;i<100;i++){
    console.log(i|7);		// 输出值的间隔是8      7 是 111  所以可以进行锁位
}

var x=3;  
x&=2;		//x=x&2
console.log(x);		// 2

var x=7;
x|=10;		//x=x|10;
console.log(x);		// 15

异或运算

异或加密

// 	1	^	1	=	0
// 	0	^	1	=	1
//	1	^	0	=	1
//	0	^	0	=	0
// 异或运算，相同为 0，不同为 1 


//用来加密		确定密钥后，异或一次得到密文，再异或一次即可实现解密

// 设置 秘钥 key 53672
console.log(43657^53672);		// 密码
console.log(31521^53672);		// 解密

var str="i love javascript";
// String.fromCharCode(i)   将第i个的Unicode编码转换为字符串
// String.charCodeAt(i)     将第i个字符转化为Unicode编码
// 随便设置一个  密钥  如下面的是设的173
var s="";
for(var i=0;i<str.length;i++){
    s+=String.fromCharCode(str.charCodeAt(i)^173);
}
console.log(s);     // 得到密文

var s1="";
for(var j=0;j<s.length;j++){
    s1+=String.fromCharCode(s.charCodeAt(j)^173);
}
console.log(s1);        // 进行解密

位非操作 ~

对数值

简单来说，对数值，位非操作就是对数值 +1 再取相反数 根据这个，就可以用它作为条件进行判断

var arr=[1,2,3,4,5];
// array.indexOf(x)  在数组array中查找x，找到就返回1，没找到就会返回-1
if(~(arr.indexOf(-2))){		// 数组中没有2，返回值是-1    位非操作后是0  那么这个的意思就是，如果是false，就输出aaa
	console.log("aaa");
}

~~

~~可以实现取整功能

// 在取整的时候不会进行四舍五入
console.log(~~3.25);
console.log(~~278.7812);
// 过大数据不要使用     会发生错误
console.log(~~127312371237123.23);

位移操作

// << 左移     >> 右移
console.log(1<<8);
console.log(1<<4);
console.log(1<<16);
console.log(1<<3);
console.log(1<<31);
console.log(256>>6);
console.log(17>>1);

三目运算符

var x=3;
// y=条件?条件是true返回这个结果:条件是false返回这个结果
var y=x>2 ? 4 : 5;
x+=x>0 ? 3 : 4;
console.log(x);

x+=5 ? x+=3 : 4;
console.log(x);