JS之比较、布尔以及其他运算符

比较运算符

比较运算符用于比较两个值的大小，然后返回一个布尔值，表示是否满足指定的条件。
比较运算符可以比较各种类型的值，不仅仅是数值。
比较运算符可分为相等比较和非相等比较。对于非相等的比较，算法是先看两个运算子是否都是字符串，如果是的，就按照字典顺序比较（实际上是比较 Unicode 码点）；否则，将两个运算子都转成数值，再比较数值的大小。

非相等运算符

1. 字符串的比较
   字符串按照字典顺序进行比较。JS引擎内部首先比较首字符的 Unicode 码点。如果相等，再比较第二个字符的 Unicode 码点，以此类推。
2. 非字符串的比较
   如果两个运算子之中，至少有一个不是字符串，则可有以下两种情况：
   （1）原始类型值
   如果两个运算子都是原始类型的值，则是先转成数值再比较。比如，如果出现字符串和布尔值都会先转成数值，再进行比较。
   任何值（包括NaN本身）与NaN比较，返回的都是false。

3 > '2' //true
true > false //true
2 < true //false
1 > NaN //false;
'1' < NaN //false
NaN > NaN //false

（2）对象
如果运算子是对象，会转为原始类型的值，再进行比较。
对象转换成原始类型的值，是先调用valueOf方法；如果返回的还是对象，再接着调用toString方法。可参考JavaScript之运算符-算术运算符

var x = [3];
x > '11';
// 等同于 [3].valueOf().toString() > '11'
//[3].valueOf()=[3],[3].toString='3'
// 即 '3' > '11'
x.valueOf = function() {
return '2';
}
x > '11';
//true '2'>'11'
[2] > [1] // true
// 等同于 [2].valueOf().toString() > [1].valueOf().toString()
// 即 '2' > '1'
{ x: 2 } >= { x: 1 } // true
// 等同于 { x: 2 }.valueOf().toString() >= { x: 1 }.valueOf().toString()
// 即 '[object Object]' >= '[object Object]'

严格相等运算符（===）

JS中两种相等运算符：= =和= = =。
区别：
相等运算符（= =）比较两个值是否相等，严格相等运算符（= = =）比较它们是否为“同一个值”。
如果两个值不是同一类型，严格相等运算符（= = =）直接返回false，而相等运算符（==）会将它们转换成同一个类型，再用严格相等运算符进行比较。
对于严格相等符：

1. 不同类型的值
   如果两个值的类型不同，直接返回false。

1 === 1; //true
1 === '1'; //false
1 === [1]; //false
1 === true; //false
true === 'true' //false

2. 同一类的原始类型值
   同一类型的原始类型的值（数值、字符串、布尔值）比较时，值相同就返回true，值不同就返回false。
   NaN与任何值都不相等（包括自身）。
   正0等于负0。

1 === 0x1 // true
1 === 2 //false
NaN === NaN // false
+0 === -0 // true

3. 复合类型值
   两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个地址，即它们是否引用同一个内存地址。
   运算符两边的空对象、空数组、空函数的值，都存放在不同的内存地址，结果是false。

{} === {} // false
[] === [] // false
(function () {} === function () {}) // false

对于两个对象的比较，严格相等运算符比较的是地址，当两个变量引用同一个对象时，它们相等；而大于或小于运算符比较的是值。

var obj1 = {}; //obj1.valueOf()={}

var obj2 = {}; // obj1.valueOf().toString()="[object Object]"
//大于小于号比较的是值
obj1 > obj2 // false
obj1 < obj2 // false
//严格相等号比较的是地址
obj1 === obj2 // false

7. undefined 和 null

//undefined和null与自身严格相等
undefined === undefined // true
null === null // true
//由于变量声明后默认值是undefined，故两个只声明未赋值的变量是相等的。
var v1;
var v2;
v1 === v2 // true

严格不相等运算符（！= =）

算法就是先求严格相等运算符的结果，然后返回相反值。

1 !== '1' // true
// 等价于
!(1 === '1')

相等运算符（==）

1. 相同类型的数据
   相等运算符用来比较相同类型的数据时，与严格相等运算符完全一样。
2. 不相同类型的数据
   比较不同类型的数据时，相等运算符会先将数据进行类型转换，然后再用严格相等运算符比较。
   （1）原始类型值
   原始类型的值会转换成数值再进行比较。

1 == true // true
// 等同于 1 === Number(true)
'true' == true // false
// 等同于 Number('true') === Number(true)
// 等同于 NaN === 1
'' == 0 // true
// 等同于 Number('') === 0
// 等同于 0 === 0
'n
123
t' == 123 // true
// 因为字符串转为数字时，省略前置和后置的空格

（2）对象与原始类型值
对象（这里指广义，包括数组和函数）与原始类型的值比较时，对象转换成原始类型的值，再进行比较。

// 对象与数值比较时，对象转为数值
[2] == 2 // true
// 等同于 Number([2]) == 2
// 对象与字符串比较时，对象转为字符串
[1] == '1' // true
// 等同于 String([1]) == '1'
[1, 3] == '1,3' // true
// 等同于 String([1, 3]) == '1,3'
// 对象与布尔值比较时，两边都转为数值
[1] == true // true
// 等同于 Number([1]) == Number(true)
[5] == true // false
// 等同于 Number([5]) == Number(true)

（3）undefined 和 null
undefined和null与其他类型的值比较时，结果都为false，它们互相比较时结果为true。

不相等运算符（！=）

算法是先求相等运算符的结果，然后返回相反值。

2 != '2' // false
// 等价于
!(2 == '2')

布尔运算符

布尔运算符用于将表达式转为布尔值

1. 取反运算符（!）
   取反运算符是一个感叹号，用于将布尔值变为相反值，即true变成false，false变成true。

!undefined // true
!null // true
!0 // true
!NaN // true
!"" // true
!54 // false
!'hello' // false
![] // false
!{} // false

如果对一个值连续做两次取反运算，等于将其转为对应的布尔值，与Boolean函数的作用相同。

2. 且运算符（&&）
   往往用于多个表达式的求值。
   运算规则是：
   如果第一个运算子的布尔值为true，则返回第二个运算子的值（注意是值，不是布尔值）；
   如果第一个运算子的布尔值为false，则直接返回第一个运算子的值，且不再对第二个运算子求值。
   运算符可以多个连用，这时返回第一个布尔值为false的表达式的值。如果所有表达式的布尔值都为true，则返回最后一个表达式的值。

't' && '' // 第一个为true,所以取""
't' && 'f' // 第一个为true,所以取"f"
't' && (1 + 2) //第一个为true,所以取 3
'' && 'f' // 第一个为false,所以取""
'' && '' // 第一个为false,所以取""
var x = 1;
(1 - 1) && ( x += 1) // 第一个为false,所以取0
x // 1
if (i) {
doSomething();
}
// 等价于
i && doSomething();//若i为true，则执行相关函数，若i为false，则返回i的值即可，不会执行有关函数

3. 或运算符（||）
   用于多个表达式的求值。
   运算规则：
   如果第一个运算子的布尔值为true，则返回第一个运算子的值，且不再对第二个运算子求值；
   如果第一个运算子的布尔值为false，则返回第二个运算子的值。
   或运算符可以多个连用，这时返回第一个布尔值为true的表达式的值。如果所有表达式都为false，则返回最后一个表达式的值。

4. 三元条件运算符（?:）
   三元条件运算符由问号（?）和冒号（:）组成。它是 JavaScript 语言唯一一个需要三个运算子的运算符。
   如果第一个表达式的布尔值为true，则返回第二个表达式的值，否则返回第三个表达式的值。

'm' ? 'hello' : 'world' // "hello"
0 ? 'hello' : 'world' // "world"

其他运算符

void运算符

执行一个表达式，然后不返回任何值，或者说返回undefined。
用途是浏览器的书签工具，以及在超级链接中插入代码防止网页跳转。

<script>
function f() {
console.log('Hello World');
}
</script>
//点击链接后，会先执行onclick的代码，由于onclick返回false，所以浏览器不会跳转到#页面。
<a href="#" onclick="f(); return false;">提交</a>
//等价于
<a href="javascript: void(f())">提交</a>

逗号运算符

用于对两个表达式求值，并返回后一个表达式的值。
其他内容暂略，后续用到再补充。

运算顺序

1. 优先级
   优先级高的运算符先执行，优先级低的运算符后执行。
   优先级从高到低依次为：小于等于（<=)、严格相等（===）、或（||）、三元（?:）、等号（=）
2. 圆括号
   优先级是最高的，即圆括号中的表达式会第一个运算，所以 圆括号可以用来提高运算的优先级。
   圆括号之中，只能放置表达式，如果将语句放在圆括号之中，就会报错。
3. 左结合VS右结合
   “左结合”是将左侧两个运算数结合在一起，“右结合”是将右侧两个运算数结合在一起。
   JavaScript 语言的大多数运算符是“左结合”，少数运算符是“右结合”，包括赋值运算符（=）、三元条件运算符（?:）和指数运算符（**）。

本篇讲的是JavaScript中相关运算符。

最后

以上就是哭泣店员为你收集整理的JS之比较、布尔以及其他运算符的全部内容，希望文章能够帮你解决JS之比较、布尔以及其他运算符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。