js 对象比较

Question

1. 在使用Mocha测试的时候，发现使用同步方法得到的对象之间的比较直接使用==能通过，而异步的方法得到的对象就必须要使用JSON.stringfy了。

// test.js
const memdb = require('..');
const assert = require('assert');
describe('synchronous .saveSync(doc)', () => { //描述.saveSync()方法的功能
        it('should save the document', () => { //描述期望值
            const pet = {
                name: 'Tobi'
            };
            memdb.saveSync(pet);
            const ret = memdb.first({
                name: 'Tobi'
            });
            console.log(ret == pet);
            assert(ret == pet); //确保找到了pet
        })
    })

    describe('asyncronous .save(doc)', () => {
        it('should save the document', (done) => {
            const pet = {
                name: 'Tobi'
            };
            memdb.save(pet, () => { //保存文档
                const ret = memdb.first({
                    name: 'Tobi'
                });
                console.log(ret == pet);
                assert(ret == pet); //断言文档正确保存了
                done(); //告诉Mocha这个测试用例做完了
            })
        })
    })
    
    
    
// index.js
exports.first = (obj) => {
  return db.filter((doc) => {
    for (let key in obj) {
      if (doc[key] != obj[key]) {
        return false;
      }
    }
    return true;
  }).shift();
};


exports.saveSync = (doc, cb) => {
  db.push(doc);
};


exports.save = (doc, cb) => {
  db.push(doc);

  if (cb) {
    setTimeout(() => {
      cb();
    }, 1000);
  }
};

1. 结果

 1) memdb
       asyncronous .save(doc)
         should save the document:

      Uncaught AssertionError [ERR_ASSERTION]: The expression evaluated to a falsy value:

  assert(ret == pet)

      + expected - actual

      -false
      +true

Answer 1

JSON.stringfy 把对象转化为字符串的过程中, 对象属性的顺序是不固定的, 可以用下面这个方法对比：

function sameObj (o1, o2) {
  let keys1 = Object.keys(o1).sort()
  let keys2 = Object.keys(o2).sort()
  if (JSON.stringify(keys1) !== JSON.stringify(keys2)) return false
  let isSame = true
  keys1.forEach(key => {
    let item1 = o1[key]
    let item2 = o2[key]
    if (typeof item1 !== typeof item2) {
      isSame = false
      return
    }
    if (isSame && typeof item1 === 'object') {
      isSame = sameObj(item1, item2)
      return
    }
    if (item1 !== item2) {
      isSame = false
    }
  })
  return isSame
}
sameObj({a:1, c:[{as:2, bs: 3}]}, {c: [{bs:3, as: 2}], a:1})