【JavaScript 递归】判断两个对象的键值是否完全一致，支持深层次查询，教你玩转JavaScript脚本语言

博主：東方幻想郷 Or _LJaXi
专栏分类：JavaScript | 脚本语言

🎃 自荐一下我写的一个 npm包

此包名为 objects-comparison, 可以进行两个对象的浅判断以及深判断，若两个对象有任意一个地方不同，则返回 false，反之为true, 我们可以用来判断一些平常碰不太到的问题，此包使用的就是递归语法

下载包
npm install objects-comparison

// 引入包
import { objectComparison } from 'objects-comparison'
// 使用包
objectComparison(obj1, obj2); // true / false

🌕 起因

记得当时我是有写过一个判断两个对象内的键值手否相同的文章
使用 md5-js 判断两个对象键值是否相同
但是当时比较菜，递归也看不太懂，所以就用了别人的包

🌓 代码流程

💨 💨💨 首先明确一下需求
首先要有两个 Object
封装一个方法来判断两个对象内的keys，并且要支持深层次判断

⭐ 第一步 判断两个对象的长度是否一致

首先 声明一个判断对象的方法，我们就叫他 objectsComparison，提供两个形参： obj_one，obj_two
理一下思路：既然要判断两个对象中的每一项 且 每一项中的深层次对象都一致的话

1.⚡先判断两个对象keys的长度是否相同

function objectsComparison(obj_one, obj_two) {
	// 判断两个对象的key长度是否一致，若不一致返回false
    // 此时 key 长度不会监听到深层次的key
    if (Object.keys(obj_one).length !== Object.keys(obj_two).length) {
		return false
	}
}

⭐ 第二步 循环 obj 进行判断两个对象

2. ⚡判断两个对象的 prop 是否为 object

function objectsComparison(obj_one, obj_two) {
	// 判断两个对象的key长度是否一致，若不一致返回false
    // 此时 key 长度不会监听到深层次的key
    if (Object.keys(obj_one).length !== Object.keys(obj_two).length) {
		return false
	}
	// 循环对象，判断每一项
    for (let prop in obj_one) {
        // 判断两个对象每一项是否为object
        if (typeof obj_one[prop] === 'object' && typeof obj_two[prop] === 'object') {
           
        } 
    }
}

⭐ 第三步 递归条件判断两个对象深层次对象

3. ⚡递归条件判断两个对象的深层次对象是否符合本方法的所有条件，若不符合，返回false

function objectsComparison(obj_one, obj_two) {
	// 判断两个对象的key长度是否一致，若不一致返回false
    // 此时 key 长度不会监听到深层次的key
    if (Object.keys(obj_one).length !== Object.keys(obj_two).length) {
		return false
	}
	// 循环对象，判断每一项
    for (let prop in obj_one) {
        // 判断两个对象每一项是否为object
        if (typeof obj_one[prop] === 'object' && typeof obj_two[prop] === 'object') {
            // 使用递归条件监听两个深层次的对象
            if (!objectsComparison(obj_one[prop], obj_two[prop])) {
				return false
		    }
        } 
    }
}

⭐ 第四步 判断两个对象的值是否相同

4. ⚡判断两个对象值是否相同，不相同返回false

function objectsComparison(obj_one, obj_two) {
	// 判断两个对象的key长度是否一致，若不一致返回false
    // 此时 key 长度不会监听到深层次的key
    if (Object.keys(obj_one).length !== Object.keys(obj_two).length) {
		return false
	}
	// 循环对象，判断每一项
    for (let prop in obj_one) {
        // 判断两个对象每一项是否为object
        if (typeof obj_one[prop] === 'object' && typeof obj_two[prop] === 'object') {
            // 使用递归条件监听两个深层次的对象
            if (!objectsComparison(obj_one[prop], obj_two[prop])) {
				return false
		    }
		    // 对象键不相等，也会返回false
        } else if (obj_one[prop] !== obj_two[prop]) {
			return false
		}
    }
}

⭐ 第五步 若以上步骤都不符合，返回true

function objectsComparison(obj_one, obj_two) {
    // 判断两个对象的key长度是否一致，若不一致返回false
    // 此时 key 长度不会监听到深层次的key
    if (Object.keys(obj_one).length !== Object.keys(obj_two).length) {
        return false
    }
    // 循环对象，判断每一项
    for (let prop in obj_one) {
        // 判断两个对象每一项是否为object
        if (typeof obj_one[prop] === 'object' && typeof obj_two[prop] === 'object') {
           // 使用递归条件监听两个深层次的对象
           if (!objectsComparison(obj_one[prop], obj_two[prop])) {
               return false
           }
           // 对象键不相等，也会返回false
        } else if (obj_one[prop] !== obj_two[prop]) {
            return false
        }
    }
    // 若以上条件都不成立，返回true，两个对象完全一致
    return true
}

🌑 完整代码

function objectsComparison(obj_one, obj_two) {
    if (Object.keys(obj_one).length !== Object.keys(obj_two).length) {
        return false
    }
    for (let prop in obj_one) {
        if (typeof obj_one[prop] === 'object' && typeof obj_two[prop] === 'object') {
           if (!objectsComparison(obj_one[prop], obj_two[prop])) {
               return false
           }
        } else if (obj_one[prop] !== obj_two[prop]) {
            return false
        }
    }
    return true
}

🌠 以上是 使用递归 判断连个对象是否完全一致的判断方法
🌠 希望能够帮助到你