沙茶酱
主 题
1.array.includes(),和array.indexOf()可以判断一个对象是否存在于数组中?可以
const arr = [{ a: 1, b: { c: 2 }}, { d: 3, e: { f: 4 }}]
const b1 = obj1.b
const b2 = obj1.b
const obj3 = obj1
console.log(obj1 === obj3)// true
console.log(b1 === b2)// true
console.log('b' in obj1) // true 判断一个对象的属性是否存在
console.log('=============')
const item2 = arr[1]
const bool = arr.includes(item2)
const index = arr.indexOf(item2)
/* 判断内存地址相等的话就是为true,内部实现原理也是用到了相等运算符*/
console.log(bool, index) // true 1
console.log(item2 === arr[1]) // true
2.相等运算符1.NaN不会与任何值等同,包括它自己
2.只有两个操作数引用的是同一个对象、数组、函数时, 才会返回true。
如果两个操作数引用的不是同一个对象,哪怕这两个对象的属性完全相同,也会返回false。
数组也是如此,只要两个操作数引用的不是同一个数组,哪怕两个数组的元素完全相同,
也会返回false。(虽然他们从表面上看都是一样的,但是在内存中的地址是不同的,故为false)
1.array.includes(),和array.indexOf()可以判断一个对象是否存在于数组中?可以
const arr = [{ a: 1, b: { c: 2 }}, { d: 3, e: { f: 4 }}]
const b1 = obj1.b
const b2 = obj1.b
const obj3 = obj1
console.log(obj1 === obj3)// true
console.log(b1 === b2)// true
console.log('b' in obj1) // true 判断一个对象的属性是否存在
console.log('=============')
const item2 = arr[1]
const bool = arr.includes(item2)
const index = arr.indexOf(item2)
/* 判断内存地址相等的话就是为true,内部实现原理也是用到了相等运算符*/
console.log(bool, index) // true 1
console.log(item2 === arr[1]) // true
2.相等运算符1.NaN不会与任何值等同,包括它自己
2.只有两个操作数引用的是同一个对象、数组、函数时, 才会返回true。
如果两个操作数引用的不是同一个对象,哪怕这两个对象的属性完全相同,也会返回false。
数组也是如此,只要两个操作数引用的不是同一个数组,哪怕两个数组的元素完全相同,
也会返回false。(虽然他们从表面上看都是一样的,但是在内存中的地址是不同的,故为false)
1.array.includes(),和array.indexOf()可以判断一个对象是否存在于数组中?可以
const arr = [{ a: 1, b: { c: 2 }}, { d: 3, e: { f: 4 }}]
const b1 = obj1.b
const b2 = obj1.b
const obj3 = obj1
console.log(obj1 === obj3)// true
console.log(b1 === b2)// true
console.log('b' in obj1) // true 判断一个对象的属性是否存在
console.log('=============')
const item2 = arr[1]
const bool = arr.includes(item2)
const index = arr.indexOf(item2)
/* 判断内存地址相等的话就是为true,内部实现原理也是用到了相等运算符*/
console.log(bool, index) // true 1
console.log(item2 === arr[1]) // true
2.相等运算符1.NaN不会与任何值等同,包括它自己
2.只有两个操作数引用的是同一个对象、数组、函数时, 才会返回true。
如果两个操作数引用的不是同一个对象,哪怕这两个对象的属性完全相同,也会返回false。
数组也是如此,只要两个操作数引用的不是同一个数组,哪怕两个数组的元素完全相同,
也会返回false。(虽然他们从表面上看都是一样的,但是在内存中的地址是不同的,故为false)
const arr = [{ a: 1, b: { c: 2 }}, { d: 3, e: { f: 4 }}]
const b1 = obj1.b
const b2 = obj1.b
const obj3 = obj1
console.log(obj1 === obj3)// true
console.log(b1 === b2)// true
console.log('b' in obj1) // true 判断一个对象的属性是否存在
console.log('=============')
const item2 = arr[1]
const bool = arr.includes(item2)
const index = arr.indexOf(item2)
/* 判断内存地址相等的话就是为true,内部实现原理也是用到了相等运算符*/
console.log(bool, index) // true 1
console.log(item2 === arr[1]) // true
1.NaN不会与任何值等同,包括它自己
2.只有两个操作数引用的是同一个对象、数组、函数时, 才会返回true。
如果两个操作数引用的不是同一个对象,哪怕这两个对象的属性完全相同,也会返回false。
数组也是如此,只要两个操作数引用的不是同一个数组,哪怕两个数组的元素完全相同,
也会返回false。(虽然他们从表面上看都是一样的,但是在内存中的地址是不同的,故为false)
全部评论(0)