javaScript对象(Object)对比较和判断数组是否包含某对象

最新推荐文章于 2023-09-16 15:57:16 发布
最新推荐文章于 2023-09-16 15:57:16 发布
阅读量1k 收藏 1
点赞数
分类专栏： javaScript 文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X1123666/article/details/123096134
版权

JS中用 “ === ” 判断两个对象或数组返回都是false，虽然人眼看着是一模一样的，但JS返回就是不相等，无奈自己封装。代码如下：

获取数据的类型

getDataType(data) {
    const temp = Object.prototype.toString.call(data)
    const types = temp.match(/\b\w+\b/g)
    return (types.length === 2) ? types[1] : undefined
}

数组的比较

function AssertionArray(arrOne, arrTwo) {
    const arrOneType = getDataType(arrOne)
    const arrTwoType = getDataType(arrTwo)
    if (arrOneType !== 'Array') {
        throw new Error(`Error${arrOne} is not Array`)
    }
    if (arrTwoType !== 'Array') {
        throw new Error(`Error ${arrTwo} is not Array`)
    }
    arrOne.sort()
    arrTwo.sort()
    const arrOneLen = arrOne.length
    const arrTwoLen = arrTwo.length
    if (arrOneLen !== arrTwoLen) {
        return false
    }
    for (let i = 0; i < arrOneLen; i++) {
        const arrOneElType = getDataType(arrOne[i])
        const arrTwoElType = getDataType(arrTwo[i])
        if (arrOneElType !== arrTwoElType)
            return false
        if (arrOneElType === 'Array') {
            if (!AssertionArray(arrOne[i], arrTwo[i])) {
                return false
            }
            continue
        } else if (arrOneElType === 'Object') {
            if (!AssertionObject(arrOne[i], arrTwo[i])) {
                return false
            }
            continue
        } else if (arrOneElType === 'Function') {
            continue
        }
        if (arrOne[i] !== arrTwo[i]) {
            return false
        }
    }
    return true
}

对象之间的比较

function AssertionObject(objOne, objTwo) {
    const objOneType = getDataType(objOne)
    const objTwoType = getDataType(objTwo)
    if (objTwoType !== objOneType) {
        return false
    }
    if (objOneType !== 'Object') {
        throw new Error(`Error${objOne} is not Object`)
    }
    if (objTwoType !== 'Object') {
        throw new Error(`Error ${objTwo} is not Object`)
    }
    const objOneKeys = Object.keys(objOne)
    const objTwoKeys = Object.keys(objTwo)
    const arrOneLen = objOneKeys.length
    const arrTwoLen = objTwoKeys.length
    if (arrOneLen !== arrTwoLen || !AssertionArray(objOneKeys, objTwoKeys)) {
        return false
    }
    for (let el in objOneKeys) {
        const arrOneElValue = objOne[objOneKeys[el]]
        const arrTwoElValue = objTwo[objOneKeys[el]]
        const arrOneType = getDataType(arrOneElValue)
        const arrTwoType = getDataType(arrTwoElValue)
        if (arrOneType !== arrTwoType) {
            return false
        }
        if (arrOneType === 'Object') {
            if (!AssertionObject(arrOneElValue, arrTwoElValue)) {
                return false
            }
            continue
        } else if (arrOneType === 'Array') {
            if (!AssertionArray(arrOneElValue, arrTwoElValue)) {
                return false
            }
            continue
        } else if (arrOneType === 'Function') {
            continue
        }
        if (arrOneElValue !== arrTwoElValue) {
            return false
        }
    }
    return true
}

合在一块

function getDataType(data) {
    const temp = Object.prototype.toString.call(data)
    const types = temp.match(/\b\w+\b/g)
    return (types.length === 2) ? types[1] : undefined
}

function AssertionArray(arrOne, arrTwo) {
    const arrOneType = getDataType(arrOne)
    const arrTwoType = getDataType(arrTwo)
    if (arrOneType !== 'Array') {
        throw new Error(`Error${arrOne} is not Array`)
    }
    if (arrTwoType !== 'Array') {
        throw new Error(`Error ${arrTwo} is not Array`)
    }
    arrOne.sort()
    arrTwo.sort()
    const arrOneLen = arrOne.length
    const arrTwoLen = arrTwo.length
    if (arrOneLen !== arrTwoLen) {
        return false
    }
    for (let i = 0; i < arrOneLen; i++) {
        const arrOneElType = getDataType(arrOne[i])
        const arrTwoElType = getDataType(arrTwo[i])
        if (arrOneElType !== arrTwoElType)
            return false
        if (arrOneElType === 'Array') {
            if (!AssertionArray(arrOne[i], arrTwo[i])) {
                return false
            }
            continue
        } else if (arrOneElType === 'Object') {
            if (!AssertionObject(arrOne[i], arrTwo[i])) {
                return false
            }
            continue
        } else if (arrOneElType === 'Function') {
            continue
        }
        if (arrOne[i] !== arrTwo[i]) {
            return false
        }
    }
    return true
}

function AssertionObject(objOne, objTwo) {
    const objOneType = getDataType(objOne)
    const objTwoType = getDataType(objTwo)
    if (objTwoType !== objOneType) {
        return false
    }
    if (objOneType !== 'Object') {
        throw new Error(`Error${objOne} is not Object`)
    }
    if (objTwoType !== 'Object') {
        throw new Error(`Error ${objTwo} is not Object`)
    }
    const objOneKeys = Object.keys(objOne)
    const objTwoKeys = Object.keys(objTwo)
    const arrOneLen = objOneKeys.length
    const arrTwoLen = objTwoKeys.length
    if (arrOneLen !== arrTwoLen || !AssertionArray(objOneKeys, objTwoKeys)) {
        return false
    }
    for (let el in objOneKeys) {
        const arrOneElValue = objOne[objOneKeys[el]]
        const arrTwoElValue = objTwo[objOneKeys[el]]
        const arrOneType = getDataType(arrOneElValue)
        const arrTwoType = getDataType(arrTwoElValue)
        if (arrOneType !== arrTwoType) {
            return false
        }
        if (arrOneType === 'Object') {
            if (!AssertionObject(arrOneElValue, arrTwoElValue)) {
                return false
            }
            continue
        } else if (arrOneType === 'Array') {
            if (!AssertionArray(arrOneElValue, arrTwoElValue)) {
                return false
            }
            continue
        } else if (arrOneType === 'Function') {
            continue
        }
        if (arrOneElValue !== arrTwoElValue) {
            return false
        }
    }
    return true
}

顺便判断一下某数组是否包含某个对象或元素

function AssertionExist(arr, el) {
    const arrLen = arr.length
    const elType = getDataType(el)
    for (let i = 0; i < arrLen; i++) {
        const arrElType = getDataType(arr[i])
        if (elType !== arrElType) {
            continue
        }
        if (elType === 'Object') {
            if (AssertionObject(arr[i], el)) {
                return true
            }
        } else if (elType === 'Array') {
            if (AssertionArray(arr[i], el)) {
                return true
            }
        }
    }
    return false
}

把方法《AssertionExist》改一下可以返回索引

function getIndex(arr, el) {
    const arrLen = arr.length
    const elType = getDataType(el)
    for (let i = 0; i < arrLen; i++) {
        const arrElType = getDataType(arr[i])
        if (elType !== arrElType) {
            continue
        }
        if (elType === 'Object') {
            if (AssertionObject(arr[i], el)) {
                return i
            }
        } else if (elType === 'Array') {
            if (AssertionArray(arr[i], el)) {
                return i
            }
        }
    }
}

测试一下

1. 测试数组，各种类型嵌套的

一模一样的数据

const arr1 = ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}, ["Banana", "Orange"], {'1': '1'}]
const arr2 = ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}, ["Banana", "Orange"], {'1': '1'}]

结果

console.log(AssertionArray(arr1, arr2)) // true

不一样的数据

const arr1 = ["Banana", "Orange", "Apple", () => {}, {'1': '2'}, {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}, ["Banana", "Orange"], {'1': '1'}]
const arr2 = ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}, ["Banana", "Orange"], {'1': '1'}]

结果

console.log(AssertionArray(arr1, arr2))  //false

2.测试对象（Object）

一模一样的数据，各种类型嵌套

const obj1 = {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}
const obj2 = {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}

结果

console.log(AssertionObject(obj1, obj2))  //true

不一样的数据

const obj1 = {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '2'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}
const obj2 = {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}

结果

console.log(AssertionObject(obj1, obj2))  //false

3. 测试某数组是否包含某对象

数据

const arr1 = ["Banana", "Orange", "Apple", () => {}, {'1': '2'}, {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}, ["Banana", "Orange"], {'1': '1'}]
const obj1 = {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}

结果

console.log(AssertionExist(arr1,obj1))  //true

4. 测试某对象在某数组中位置

数据

const arr1 = ["Banana", "Orange", "Apple", () => {}, {'1': '2'}, {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}, ["Banana", "Orange"], {'1': '1'}]
const obj1 = {'2': ["Banana", "Orange", "Apple", () => {}, {'1': '1'}, {'2': '2'}, ["Banana", "Orange"], {'1': '1'}]}

结果

console.log(getIndex(arr1,obj1))  // 5

哪位大佬看到有不对的地方，帮忙优化，感谢哦！

䴺矏
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS判断两个数组或对象是否相同的方法示例
12-08
在JavaScript中，有时我们需要判断两个数组或对象是否完全相同，这在编程中是常见的需求。以下是一些在JS中实现这种判断的方法。 首先，我们来看如何判断两个数组是否相同。通常，我们可以采取以下两种方式： 1. *...
js判断一个对象是否在一个对象数组中
qq_49080170的博客
10-30 1926
js判断一个对象是否在一个对象数组中
JS判断对象、数组是否包含某个属性、某个值
DiuWang的博客
07-24 5513
对象是否包含某个属性。 数组是否包含某个值。
3.js中判断数组中是否存在某个对象/值，判断数组里的对象是否存在某个值 的五种方法 及应用场景|判断数组里有没有某对象，有不添加，没有则添加到数组
热门推荐
yangyangdt的博客
01-15 2万+
js中判断数组中是否存在某个对象/值，判断数组里的对象是否存在某个值 的五种方法 逻辑及应用场景（购物车）
js判断两个数组是否存在相同元素的四种方法
最新发布
不定时分享最优质的网络技术与教程，满满的干货。
09-16 3294
以上就是vue项目打包开启gzip压缩具体使用方法的详细内容，更多关于vue打包开启gzip压缩的资料请关注其它相关文章！webpack配置Compression-webpack-plugin压缩gzip文件。作用：提升网络传输率->优化web页面加载时间。
在 TypeScript 中，{}，object 和 Object 表示三个不同的类型，它们的区别和用途
JackChan
03-17 798
在 TypeScript 中，{}，object 和 Object 表示三个不同的类型，它们的区别和用途
javascript判断数组内是否重复的方法
10-24
在处理数组时，有时我们需要判断数组中的元素是否存在重复。本篇文章将详细讲解如何利用JavaScript实现这个功能。 首先，我们可以通过遍历数组来检查是否有重复的元素。一个简单的方法是使用双重循环，将数组中的每...
javascript判断一个变量是数组还是对象
10-17
因此，`typeof`不能作为判断数组和对象的可靠方式。 其次，`instanceof`运算符可以根据原型链来判断一个对象是否是由特定的构造函数创建的。数组也是对象，它们都继承自`Object`，但`instanceof`可以帮助我们区分...
js判断数组是否相等的方法
03-14
在JavaScript中，判断两个数组是否相等是一个常见的需求，尤其在处理数据比较或者验证时。根据标题和描述，我们可以区分两种不同的场景： 1. **数组完全相等**：在这种情况下，不仅要求数组中的元素相同，而且元素...
JavaScript比较两个数组的内容是否相同(推荐)
11-28
这个`equals`方法首先检查比较的对象是否是数组，然后比较它们的长度，最后遍历数组中的每个元素，包括处理嵌套数组的情况。这样可以确保即使数组结构复杂也能正确判断内容是否相同。 对于比较对象的`equals`方法，...
js 判断字符串中是否包含某个字符串
xiaoshen66的博客
05-07 4192
String对象的方法 方法一: indexOf() (推荐) var str = "123"; console.log(str.indexOf("3") != -1 ); // true indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。如果要检索的字符串值没有出现，则该方法返回 -1。 方法二: search() ...
3种方法快速查找两个数组是否在Javascript中包含任何公共项
web前端开发
05-14 1250
英文 |https://www.geeksforgeeks.org/how-to-find-if-two-arrays-contain-any-common-item-in-javas...
java 判断两个List是否包含 判断两个list相等
zhangshuzu的博客
09-15 5157
java 判断两个List是否包含 判断两个list相等众所周知，两个列表具有完全相同的元素并且具有完全相同的顺序时，它们是相等的。即使list1的和项目list3包含相同的元素{1，2，3}，但是元素顺序不一样，所以list1和list3还是不相等的。注意：有的业务要求元素顺序不必要求一致 我们要做的就是检查两个列表是否包含相同的元素，而不管它们在列表中的顺序，那如何去实现呢？
js判断对象数组中是否存在某个对象
lgdaren的博客
07-06 9124
如果要判断数组中是否存在某个元素的话很好判断，直接用数组的indexOf方法就好，存在返回当前索引不存在返回-1 var arr=[1,2,3,4] arr.indexOf(3) // 2 arr.indexOf(5) // -1 要只是判断的话是可以遍历后判断对象的属性是否相同的，像这种： arr.forEach(item=>{ if(item.name=='Alex'){ alert('存在这个元素'); } }) 但实际中往往是需要动态添加或删除对象.
JS - 判断数据是不是Object类型的数据
技术共享，共同进步！
01-27 4652
function isObject(obj) { return Object.prototype.toString.call(obj) === '[object Object]' } let val={} var res = isObject(val); console.log((res))//true
判断object类是否为空、是否包含某个key
weixin_39288821的博客
07-04 1084
当定义Map<String, Object> map这种变量。如果从中get一个不存在的参数的话就会报错，所以需要加判断。用isObjectNotEmpty()函数来判断，例如 if (isObjectNotEmpty(map.get(“MEDICAL”))) { medical = map.get(“MEDICAL”).toString().split(","); } else { ...
Do not access Object.prototype method ‘hasOwnProperty‘ from target object
哈哈hyc的博客
08-13 599
今天用对象的属性hasOwnProperty，去判断对象是否包含该值，我这里主要判断对象是否为空，出现了以上错误，之前也遇到过类似的错误，如parseInt（‘24.5’），必须要给转换的进制类型，改为parseInt（‘24.5’，10）则正常 通过上述文字提示发现，不要从目标对象访问 Object 原型方法”，想到一种解决方案——直接找到这个方法，用 call 改变指向调用： Object.prototype.hasOwnProperty.call(obj, 'key') 在ECMAScript.
判断对象中是否包含另一个对象
crsitin_spade的博客
01-11 2381
お早う，盆友们。 有的时候可能我们需要去进行一些对象（object）的判断。 var obj1 = { a: 1 } var obj2 = { a: 1 } console.log(obj1 === obj2); // false 如上，在长度、内容相等时，我们去判断，依然不会像等，这是关于堆的问题，两个对象不在同一个堆中时，即使我们看着值是相等的，但是我们获取到的判断依然不会是true。 但是如果我们需要判断的对象更长，在不知道他的键的时候，该如何判断一个对象是否包含一个对象时，这又是一个问
如何比较两个数组/对象或数组对象是否相等
z1783883121的博客
07-13 6614
如何比较两个数组/对象或数组对象是否相等？ 我们可以通过使用JSON.stringify()方法来转换比较 具体示例： 1.比较两个数组（数组中是对象）是否全等： let objArr = [{ nema: "123", age: "19" }, { name: "234", age: "22" }]; let obj2Arr = [{ nema: "123", age: "19" }, { name: "234", ...
判断数组对象中是否有属性等于某个值
07-15
要判断数组对象中是否有属性等于某个值，你可以使用以下代码： ```javascript const arr = [ { paymentMethod: "EPSCO-PPS", totalNum: 20, totalPaymentAmount: 6400 }, { paymentMethod: "BOC-FPS", totalNum: 140, totalPaymentAmount: 44800 }, { paymentMethod: "Online Credit Card", totalNum: 40, totalPaymentAmount: 12800 } ]; const hasPropertyWithValue = arr.some(item => Object.values(item).includes("EPSCO-PPS")); console.log(hasPropertyWithValue); // 输出 true 或 false ``` 上述代码使用了数组的 `some` 方法和 `Object.values` 方法。`some` 方法遍历数组中的每个元素，并返回一个布尔值，表示是否有满足条件的元素。`Object.values` 方法返回对象中所有属性的值组成的数组。在这里，我们判断每个元素的属性值数组是否包含 "EPSCO-PPS"。如果存在满足条件的元素，则返回 `true`，否则返回 `false`。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值