您可以序列化简单数据以检查相等性：

data1 = {firstName: 'John', lastName: 'Smith'};
data2 = {firstName: 'Jane', lastName: 'Smith'};
JSON.stringify(data1) === JSON.stringify(data2)

这会给你类似的东西

'{firstName:"John",lastName:"Smith"}' === '{firstName:"Jane",lastName:"Smith"}'

作为函数...

function compare(a, b) {
  return JSON.stringify(a) === JSON.stringify(b);
}
compare(data1, data2);

编辑

如果您像您说的那样使用 chai，请查看http://chaijs.com/api/bdd/#equal-section

编辑 2

如果您只想检查密钥...

function compareKeys(a, b) {
  var aKeys = Object.keys(a).sort();
  var bKeys = Object.keys(b).sort();
  return JSON.stringify(aKeys) === JSON.stringify(bKeys);
}

应该这样做。

2 这是一个简短的ES6可变参数版本：

function objectsHaveSameKeys(...objects) {
   const allKeys = objects.reduce((keys, object) => keys.concat(Object.keys(object)), []);
   const union = new Set(allKeys);
   return objects.every(object => union.size === Object.keys(object).length);
}

一点性能测试（MacBook Pro - 2,8 GHz Intel Core i7, Node 5.5.0）：

var x = {};
var y = {};

for (var i = 0; i < 5000000; ++i) {
    x[i] = i;
    y[i] = i;
}

结果：

objectsHaveSameKeys(x, y) // took  4996 milliseconds
compareKeys(x, y)               // took 14880 milliseconds
hasSameProps(x,y)               // after 10 minutes I stopped execution

如果要检查两个对象是否具有相同的属性名称，可以执行以下操作：

function hasSameProps( obj1, obj2 ) {
  return Object.keys( obj1 ).every( function( prop ) {
    return obj2.hasOwnProperty( prop );
  });
}

var obj1 = { prop1: 'hello', prop2: 'world', prop3: [1,2,3,4,5] },
    obj2 = { prop1: 'hello', prop2: 'world', prop3: [1,2,3,4,5] };

console.log(hasSameProps(obj1, obj2));

通过这种方式，您可以确保只检查两个对象的可迭代和可访问属性。

编辑 - 2013.04.26：

前面的函数可以用以下方式重写：

function hasSameProps( obj1, obj2 ) {
    var obj1Props = Object.keys( obj1 ),
        obj2Props = Object.keys( obj2 );

    if ( obj1Props.length == obj2Props.length ) {
        return obj1Props.every( function( prop ) {
          return obj2Props.indexOf( prop ) >= 0;
        });
    }

    return false;
}

这样我们检查两个对象是否具有相同数量的属性（否则对象没有相同的属性，我们必须返回一个逻辑假）然后，如果数量匹配，我们去检查它们是否具有相同的属性特性。

奖金

一个可能的增强可能是引入类型检查来强制匹配每个属性。

如果你想要像@speculees 这样的深度验证，这里有一个使用的答案deep-keys（披露：我是这个小包的维护者）

// obj1 should have all of obj2's properties
var deepKeys = require('deep-keys');
var _ = require('underscore');
assert(0 === _.difference(deepKeys(obj2), deepKeys(obj1)).length);

// obj1 should have exactly obj2's properties
var deepKeys = require('deep-keys');
var _ = require('lodash');
assert(0 === _.xor(deepKeys(obj2), deepKeys(obj1)).length);

或与chai：

var expect = require('chai').expect;
var deepKeys = require('deep-keys');
// obj1 should have all of obj2's properties
expect(deepKeys(obj1)).to.include.members(deepKeys(obj2));
// obj1 should have exactly obj2's properties
expect(deepKeys(obj1)).to.have.members(deepKeys(obj2));

这是shirrmacher上面提供的函数的深度检查版本。下面是我的尝试。请注意：

• 解决方案不检查 null 并且不是防弹的
• 我还没有对其进行性能测试。也许 shirrmacher 或 OP 可以做到这一点并为社区分享。
• 我不是 JS 专家:)。

function objectsHaveSameKeys(...objects) {
  const allKeys = objects.reduce((keys, object) => keys.concat(Object.keys(object)), [])
  const union = new Set(allKeys)
  if (union.size === 0) return true
  if (!objects.every((object) => union.size === Object.keys(object).length)) return false

  for (let key of union.keys()) {
    let res = objects.map((o) => (typeof o[key] === 'object' ? o[key] : {}))
    if (!objectsHaveSameKeys(...res)) return false
  }
  return true
}

更新 1

在递归深检查版本A 90％的改善被跳过我的电脑上实现concat()，并直接添加的钥匙Set()。shirrmacher 对原始单级版本的相同优化也实现了约 40% 的改进。

优化的深度检查现在在性能上与优化的单级版本非常相似！

function objectsHaveSameKeysOptimized(...objects) {
  let union = new Set();
  union = objects.reduce((keys, object) => keys.add(Object.keys(object)), union);
  if (union.size === 0) return true
  if (!objects.every((object) => union.size === Object.keys(object).length)) return false

  for (let key of union.keys()) {
    let res = objects.map((o) => (typeof o[key] === 'object' ? o[key] : {}))
    if (!objectsHaveSameKeys(...res)) return false
  }
  return true
}

性能比较

var x = {}
var y = {}
var a = {}
for (var j = 0; j < 10; ++j){
  a[j] = j
}

for (var i = 0; i < 500000; ++i) {
  x[i] = JSON.parse(JSON.stringify(a))
  y[i] = JSON.parse(JSON.stringify(a))
}

let startTs = new Date()
let result = objectsHaveSameKeys(x, y)
let endTs = new Date()
console.log('objectsHaveSameKeys = ' + (endTs - startTs)/1000)

结果

A：递归/深度检查版本*

1. objectsHaveSameKeys = 5.185
2. objectsHaveSameKeysOptimized = 0.415

B：原始非深度版本

1. objectsHaveSameKeysOriginalNonDeep = 0.517
2. objectsHaveSameKeysOriginalNonDeepOptimized = 0.342