#57 shallowEqual


  • 0
    administrators

    @Sunjourney

    var a = {}
    var b = {}
    shallowEqual({ name: { a, b } }, { name: { a, b })
    

  • 0

    @胡子大哈 然而返回 true,应该没什么不对吧


  • 0
    administrators

    @Sunjourney 第一层,a b 在第二层


  • 0

    @胡子大哈 就是说 a.name !== b.name

    可是 shallowEqual 不应该是 is 的子集吗?
    is 说 true 的,shallowEqual 应该说 true,is 说 false 的,shallowEqual 可以是 true,也可以是 false 吧。


  • 0
    administrators

    @Sunjourney

    如果这两个参数的值相同、或者这两个参数都是对象并且对象的第一层数据相同,那么就返回 true

    两个值相同一定返回 true;如果不同而且是对象,那么判断它们第一层是否相同,如果相同,返回 true;

    除此以外都返回 false。

    不知道有没有表达上有问题。


  • 0
    administrators

    @Sunjourney 你说的是对的啊,但是

    shallowEqual({ name: { a, b } }, { name: { a, b } } // false
    

    这个情况,第一层对象都是的 name 都是字面量,所以第一层不一样,应该返回 false 吧。


  • 0

    @胡子大哈

    还是输入 {"name" 这个错。
    这个例子已经返回 false 了

    var a = {}
    var b = {}
    shallowEqual({ name: { a, b } }, { name: { a, b }})
    

  • 0
    administrators

    @Sunjourney 改了出错信息,再试试看。


  • 1
    administrators


  • 0

    对于输入null null 我无论返回 true 还是 false

    系统总显示 : 输入 null null 答案不正确


  • 0
    administrators

    @plm 应该是 NaN 和 NaN 不正确,提示信息有问题


  • 0

    const shallowEqual = (x, y) => {
      if (typeof x !== typeof y) return false
      if (typeof x !== 'object') {
        return Object.is(x, y)
      } else {
        if (x === null || y === null) return x === y
        let keys1 = Object.keys(x), keys2 = Object.keys(y)
        if (keys1.length !== keys2.length) return false
        return keys1.every(d => Object.is(x[d], y[d]))
      }
    }
    

  • 0

    好题目。

    /**
     * 判断两个对象到某一层之前,所有值/叶子结点是否都相等
     * @param {any} x 比较变量/对象x
     * @param {any} y 比较变量/对象y
     * @param {number} level 从本层算起,还需要比较的层数
     */
    function equal (x, y, level = 1) {
      if (level === 1) {
        // 这一层是需要比较的最后一层,直接比较变量的值/对象的地址
        return Object.is(x, y)
      }
      
      if ((typeof x !== 'object' || x === null) || (typeof y !== 'object' || y === null)) { // 若其中一个是基本类型,则使用Object.is
        return Object.is(x, y)
      } else { // 若两个都是对象,才进行属性遍历
        /**
         * 这里用Object.entries而不用Object.keys或Object.values,
         * 是想应对数组的情况:若两个数组所有值相等但顺序不一致,则不算相等。
         * 但普通对象的KV对的顺序不影响相等。
         */
        let xEntries = Object.entries(x)
        if (xEntries.length !== Object.entries(y).length) return false
        for (const [key, xValue] of xEntries) {
          let yValue = y[key]
          let isItemEqual = equal(xValue, yValue, level - 1)
          if (!isItemEqual) {
            return false // 某个子结点不相等,可以终止递归了
          }
        }
        return true
      }
    }
    
    var shallowEqual = (x, y) => equal(x, y, 2)
    
    

  • 0

    const is = (a, b) => {
      if (a === b) {
        return a !== 0 || 1 / a === 1 / b
      }
    
      return a !== a && b !== b
    }
    
    const eq = (a, b, deep) => {
      if (is(a, b)) {
        return true
      }
    
      if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {
        return false
      }
    
      const keysA = Object.keys(a)
      const keysB = Object.keys(b)
    
      if (keysA.length !== keysB.length) {
        return false
      }
    
      return keysA.every(k => Object.hasOwnProperty.call(b, k) && (deep ? eq(a[k], b[k]) : is(a[k], b[k])))
    
    }
    
    const shallowEqual = (a, b) => eq(a, b, false)
    
    

  • 0

    0_1549460982667_#57 shallowEqual.png


登录后回复
 

与 ScriptOJ 的连接断开,我们正在尝试重连,请耐心等待