About the problems of congruence and inequality, equality and inequality in JS

Congruent and Incongruent

The comparison of the operands on both sides of the symbol is the same as the operator. For example, if the operands are equal, it returns true, otherwise it returns false. The equality and inequality operators do not convert the operands when comparing for equality, that is, they directly compare for equality or inequality without conversion.

congruent

Symbol: ===

let str1="1"
let str2=1
console.log(str1===str2) //false

Not all equal

symbol:! ==

let str1="1"
let str2=1
console.log(str1!==str2) //true

Equal and unequal

The equality and inequality operators also compare two operands. For example, the equality operator returns true if the two operands are equal, otherwise it returns false. However, the difference between the equality and inequality operators is that the equality and inequality operators will first perform forced type conversion on the operands, and then compare the converted operands.

equal

Symbol: ==

let str1="1"
let str2=1
console.log(str1==str2) //true
console.log(str1===str2) //false

let flag=true
let num=1
console.log(flag==num) //true
console.log(flag===num) //false

Not equal

symbol:! =

let str1="1"
let str2=1
let str3="hello"
console.log(str1!=str2) //false First type conversion, then comparison console.log(str1!==str2) //true For the equality operation, the two operands are not necessarily equal without forced type conversion.	
console.log(str2!=str3) //true	  
console.log(str2!==str3) //true

The rules for type conversion of operands for equality and inequality operators are as follows:

Boolean values ​​are directly converted to numeric values ​​for comparison: false: 0; true: 1

When a string encounters a number, it will be converted to a number and then compared.

For objects, if both operands are objects, compare whether they are the same object. If the two operands refer to the same object, return true; otherwise, return false. If one of the operands is an object, the valueOf method is called to get the original value, and then the comparison is performed (according to the above rules)

const p = new Object('zhangsan') // equivalent to const p = new String('zhangsan')
console.log(p.valueOf() == 'zhangsan') //true
console.log(p == 'zhangsan') //true

const p1={name:'zhangsan'}
let p2=p1
console.log(p1==p2) //true
p2={}
console.log(p1==p2) //false

For null and undefined, null and undefined are equal, but they will not be coerced no matter who they are compared to.

console.log(null==undefined) //true
console.log(null===undefined) //false For all equals, the return result is still false

For NaN, NaN is not equal to any value including itself. Comparison involving operators that are NaNs returns false if they are equal, and true if they are not equal.

console.log(NaN==NaN) //false
console.log(NaN!='') //true
console.log(NaN!=1) //true
console.log(NaN!={}) //true

This is the end of this article about congruence and inequality, equality and inequality in JS. For more relevant JS content about congruence and inequality, equality and inequality, please search previous articles on 123WORDPRESS.COM or continue to browse the related articles below. I hope you will support 123WORDPRESS.COM in the future!