11

我需要比较两个代表 json 对象的字符串。出于测试目的，我需要一种方法来比较这些字符串，不仅忽略子元素顺序（这很常见），而且忽略 jsons 数组属性中元素的顺序。IE：

group: {
    id: 123,
    users: [
       {id: 234, name: John},
       {id: 345, name: Mike}
    ]
}

应该等于：

group: {
    id: 123,
    users: [
       {id: 345, name: Mike},
       {id: 234, name: John}
    ]
}

理想情况下，我需要一些 javascript lib，但也欢迎其他方法。

4

6 回答 6

13

使用JSONAssert

他们有一个松散的断言。

松动的：

JSONAssert.assertEquals(exp, act, false);

严格的：

JSONAssert.assertEquals(exp, act, true);
于 2015-05-06T22:45:47.163 回答
2

我不知道这样的事情是否存在，但你可以自己实现它。

var group1 = {
    id: 123,
    users: [
       {id: 234, name: "John"},
       {id: 345, name: "Mike"}
    ]
};

var group2 = {
    id: 123,
    users: [
       {id: 345, name: "Mike"},
       {id: 234, name: "John"}
    ]
};

function equal(a, b) {

    if (typeof a !== typeof b) return false;
    if (a.constructor !== b.constructor) return false;

    if (a instanceof Array)
    {
        return arrayEqual(a, b);
    }

    if(typeof a === "object")
    {
        return objectEqual(a, b);
    }

    return a === b;
}

function objectEqual(a, b) {
    for (var x in a)
    {
         if (a.hasOwnProperty(x))
         {
             if (!b.hasOwnProperty(x))
             {
                 return false;
             }

             if (!equal(a[x], b[x]))
             {
                 return false;
             }
         }
    }

    for (var x in b)
    {
        if (b.hasOwnProperty(x) && !a.hasOwnProperty(x))
        {
            return false;
        }
    }

    return true;
}

function arrayEqual(a, b) {
    if (a.length !== b.length)
    {
        return false;
    }

    var i = a.length;

    while (i--)
    {
        var j = b.length;
        var found = false;

        while (!found && j--)
        {
            if (equal(a[i], b[j])) found = true;
        }

        if (!found)
        {
            return false;
        }
    }

    return true;
}

alert(equal(group1, group2))
于 2011-11-11T20:01:06.737 回答
1

您可以对数组进行切片，按 Id 对它们进行排序，然后将它们字符串化为 JSON 并比较字符串。对于很多成员来说，它应该工作得很快。如果重复 Id，它将失败，因为 sort 不会更改顺序。

于 2011-11-11T20:16:35.923 回答
0

这是我对自定义实现的尝试：

var equal = (function(){
  function isObject(o){
    return o !== null && typeof o === 'object';
  }
  return function(o1, o2){
    if(!isObject(o1) || !isObject(o2)) return o1 === o2;
    var key, allKeys = {};
    for(key in o1)
      if(o1.hasOwnProperty(key))
        allKeys[key] = key;
    for(key in o2)
      if(o2.hasOwnProperty(key))
        allKeys[key] = key;
    for(key in allKeys){
      if(!equal(o1[key], o2[key])) return false;
    }
    return true;
  }
})();

带有测试用例的示例：

var p1 = {
  tags: ['one', 'two', 'three'],
  name: 'Frank',
  age: 24,
  address: {
    street: '111 E 222 W',
    city: 'Provo',
    state: 'Utah',
    zip: '84604'
  }
}
var p2 = {
  name: 'Frank',
  age: 24,
  tags: ['one', 'two', 'three'],
  address: {
    street: '111 E 222 W',
    city: 'Provo',
    state: 'Utah',
    zip: '84604'
  }
}
var p3 = {
  name: 'Amy',
  age: 24,
  tags: ['one', 'two', 'three'],
  address: {
    street: '111 E 222 W',
    city: 'Provo',
    state: 'Utah',
    zip: '84604'
  }
}
var p4 = {
  name: 'Frank',
  age: 24,
  tags: ['one', 'two', 'three'],
  address: {
    street: '111 E 222 W',
    city: 'Payson',
    state: 'Utah',
    zip: '84604'
  }
}
var p5 = {
  name: 'Frank',
  age: 24,
  tags: ['one', 'two'],
  address: {
    street: '111 E 222 W',
    city: 'Provo',
    state: 'Utah',
    zip: '84604'
  }
}

var equal = (function(){
  function isObject(o){
    return o !== null && typeof o === 'object';
  }
  return function(o1, o2){
    if(!isObject(o1) || !isObject(o2)) return o1 === o2;
    var key, allKeys = {};
    for(key in o1)
      if(o1.hasOwnProperty(key))
        allKeys[key] = key;
    for(key in o2)
      if(o2.hasOwnProperty(key))
        allKeys[key] = key;
    for(key in allKeys){
      if(!equal(o1[key], o2[key])) return false;
    }
    return true;
  }
})();

var cases = [
  {name: 'Compare with self', a: p1, b: p1, expected: true},
  {name: 'Compare with identical', a: p1, b: p2, expected: true},
  {name: 'Compare with different', a: p1, b: p3, expected: false},
  {name: 'Compare with different (nested)', a: p1, b: p4, expected: false},
  {name: 'Compare with different (nested array)', a: p1, b: p5, expected: false}
];

function runTests(tests){
  var outEl = document.getElementById('out');
  for(var i=0; i < tests.length; i++){
    var actual = equal(tests[i].a, tests[i].b),
        result = tests[i].expected == actual
          ? 'PASS'
          : 'FAIL';
    outEl.innerHTML += 
      '<div class="test ' + result + '">' + 
        result + ' ' +
        tests[i].name + 
      '</div>';
  }
}
runTests(cases);
body{
  font-family:monospace;
}
.test{
  margin:5px;
  padding:5px;  
}
.PASS{
  background:#EFE;
  border:solid 1px #32E132;
}
.FAIL{
  background:#FEE;  
  border:solid 1px #FF3232;
}
<div id=out></div>

于 2015-11-19T20:54:04.013 回答
0

此答案描述了使用DeltaJSON REST API 解决问题的方法。DeltaJSON 是一种商业产品，可将 API 作为服务 (SaaS) 或通过可在本地运行的 REST 服务器提供：

  1. 启动DeltaJSON Rest Server（需要 Java 安装和许可文件）：
java -jar deltajson-rest-1.1.0.jar
  1. arrayAlignment在您的 JavaScript 中，调用属性设置为的 DeltaJSON REST API orderless。

下面的示例代码显示了如何使用此属性设置调用 API：

async function runTest() {
  const group1 = {
    id: 123,
    users: [
      { id: 234, name: "John" },
      { id: 345, name: "Mike" }
    ]
  };
  const group2 = {
    id: 123,
    users: [
      { id: 345, name: "Mikey" },
      { id: 234, name: "John" }
    ]
  };

  // call wrapper function that makes the REST API call:
  const isEqual = await compare(group1, group2);
  // log the comparison result: true
  console.log("isEqual", isEqual);
}

async function compare(aData, bData) {
  const aString = JSON.stringify(aData);
  const bString = JSON.stringify(bData);
  const blobOptions = { type: "application/json" };

  var formdata = new FormData();
  formdata.append("a", new Blob([aString], blobOptions));
  formdata.append("b", new Blob([bString], blobOptions));
  formdata.append("arrayAlignment", "orderless");

  const myHeaders = new Headers();
  myHeaders.append("Accept", "application/json");

  var requestOptions = {
    method: "POST",
    headers: myHeaders,
    body: formdata,
    redirect: "follow"
  };

  try {
    const response = await fetch(
      "http://localhost:8080/api/json/v1/compare",
      requestOptions
    );
    const jsonObj = await response.json();
    console.log(jsonObj);
    const dataSets = jsonObj.dx_deltaJSON.dx_data_sets;
    const isEqual = dataSets === "A=B";
    return isEqual;
  } catch (e) {
    console.error(e);
  }
}

// run the test:
runTest(); // true

解释：

DeltaJSON Rest API 响应是 JSON 输入的注释形式。添加了额外dx_的前缀属性来描述更改。元数据dx_deltaJSON属性也包含在 JSON 中。

属性的值dx_deltaJSON是一个具有属性的对象dx_data_sets，我们可以测试该属性以查看（在双向比较中）该值是A=B.

这是与问题中的输入略有不同的结果。在这里，除了更改数组项的顺序外，“Mike”已更改为“Mikey”：

{
  "dx_deltaJSON": {
    "dx_data_sets": "A!=B",
    "dx_deltaJSON_type": "diff",
    "dx_deltaJSON_metadata": {
      "operation": {
        "type": "compare",
        "input-format": "multi_part",
        "output-format": "JSON"
      },
      "parameters": {
        "dxConfig": [],
        "arrayAlignment": "orderless",
        "wordByWord": false
      }
    },
    "dx_deltaJSON_delta": {
      "id": 123,
      "users": [
        {
          "id": 345,
          "name": {
            "dx_delta": {
              "A": "Mike",
              "B": "Mikey"
            }
          }
        },
        {
          "id": 234,
          "name": "John"
        }
      ]
    }
  }
}
于 2021-04-20T13:56:15.353 回答
0

我喜欢弗朗西斯的解决方案，而且效果很好。

只需在函数开头添加以下空检查，equal以防止出现空或未定义输入的错误。

if (a == null && b == null) {
  return true;
}
if (a == null || b == null) {
  return false;
}

所以整个解决方案看起来像：

function equal(a, b) {
    if (a == null && b == null) {
      return true;
    }
    if (a == null || b == null) {
      return false;
    }
    if (typeof a !== typeof b) return false;
    if (a.constructor !== b.constructor) return false;

    if (a instanceof Array)
    {
        return arrayEqual(a, b);
    }

    if(typeof a === "object")
    {
        return objectEqual(a, b);
    }

    return a === b;
}

function objectEqual(a, b) {
    for (var x in a)
    {
         if (a.hasOwnProperty(x))
         {
             if (!b.hasOwnProperty(x))
             {
                 return false;
             }

             if (!equal(a[x], b[x]))
             {
                 return false;
             }
         }
    }

    for (var x in b)
    {
        if (b.hasOwnProperty(x) && !a.hasOwnProperty(x))
        {
            return false;
        }
    }

    return true;
}

function arrayEqual(a, b) {
    if (a.length !== b.length)
    {
        return false;
    }

    var i = a.length;

    while (i--)
    {
        var j = b.length;
        var found = false;

        while (!found && j--)
        {
            if (equal(a[i], b[j])) found = true;
        }

        if (!found)
        {
            return false;
        }
    }

    return true;
}
于 2019-10-10T15:33:45.283 回答