🌕 起因

记得当时我是有写过一个判断两个对象内的键值手否相同的文章
使用 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 进行判断两个对象

⚡判断两个对象的 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') {
           
        } 
    }
}

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

⚡递归条件判断两个对象的深层次对象是否符合本方法的所有条件，若不符合，返回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

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
}