比较 ECMA6集合的相等性

如何比较两个 javascript 集? 我试过使用 ==和 ===，但都返回 false。

a = new Set([1,2,3]);
b = new Set([1,3,2]);
a == b; //=> false
a === b; //=> false

这两个集合是等价的，因为根据定义，集合没有顺序(至少通常不是)。我查看了 在 MDN 上设置的文档，没有发现任何有用的东西。有人知道怎么做吗？

87649 次浏览
小开
最佳答案

试试这个:

const eqSet = (xs, ys) =>
xs.size === ys.size &&
[...xs].every((x) => ys.has(x));


const ws = new Set([1, 2, 3]);
const xs = new Set([1, 3, 2]);
const ys = new Set([1, 2, 4]);
const zs = new Set([1, 2, 3, 4]);


console.log(eqSet(ws, xs)); // true
console.log(eqSet(ws, ys)); // false
console.log(eqSet(ws, zs)); // false

小开

将两个对象与 = = ，= = 进行比较

当使用 ==或 ===运算符比较两个对象时，总是会得到 false 除非这些对象引用同一个对象。例如:

var a = b = new Set([1,2,3]); // NOTE: b will become a global variable
a == b; // <-- true: a and b share the same object reference

否则，即使对象包含相同的值，= = 也等于 false:

var a = new Set([1,2,3]);
var b = new Set([1,2,3]);
a == b; // <-- false: a and b are not referencing the same object

您可能需要考虑手动比较

在 ECMAScript 6中，您可以事先将集合转换为数组，这样您就可以发现它们之间的差异:

function setsEqual(a,b){
if (a.size !== b.size)
return false;
let aa = Array.from(a);
let bb = Array.from(b);
return aa.filter(function(i){return bb.indexOf(i)<0}).length==0;
}

注意: Array.from是 ECMAScript 6的标准特性之一，但是在现代浏览器中并没有得到广泛的支持。点击这里查看兼容性表格: < a href = “ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global _ Objects/Array/from # Browser _  rel = “ nofollow”> https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/array/from#browser_compatibility

小开

另一个答案也可以; 这里有另一个选择。

// Create function to check if an element is in a specified set.
function isIn(s)          { return elt => s.has(elt); }


// Check if one set contains another (all members of s2 are in s1).
function contains(s1, s2) { return [...s2] . every(isIn(s1)); }


// Set equality: a contains b, and b contains a
function eqSet(a, b)      { return contains(a, b) && contains(b, a); }


// Alternative, check size first
function eqSet(a, b)      { return a.size === b.size && contains(a, b); }

但是，请注意这样做 没有做深入的等式比较。那么

eqSet(Set([{ a: 1 }], Set([{ a: 1 }])

将会返回虚假。如果上面两个集合被认为是相等的，那么我们需要遍历这两个集合，对每个元素进行深度质量比较。我们承认 deepEqual程序的存在。那么逻辑就是

// Find a member in "s" deeply equal to some value
function findDeepEqual(s, v) { return [...s] . find(m => deepEqual(v, m)); }


// See if sets s1 and s1 are deeply equal. DESTROYS s2.
function eqSetDeep(s1, s2) {
return [...s1] . every(a1 => {
var m1 = findDeepEqual(s2, a1);
if (m1) { s2.delete(m1); return true; }
}) && !s2.size;
}

这样做的目的是: 对于 s1的每个成员，寻找 s2的一个深度相等的成员。如果找到了，删除它，这样它就不能再次使用。如果 s1中的所有元素都在 s2中，那么这两个集合就是深度相等的，还有s2耗尽。未经测试。

你可能会发现这个很有用: http://www.2ality.com/2015/01/es6-set-operations.html。

小开

Loash 提供了 _.isEqual()，它进行深度比较。如果你不想自己写的话，这很方便。在 lodash 4时，_.isEqual()正确地比较 Set。

const _ = require("lodash");


let s1 = new Set([1,2,3]);
let s2 = new Set([1,2,3]);
let s3 = new Set([2,3,4]);


console.log(_.isEqual(s1, s2)); // true
console.log(_.isEqual(s1, s3)); // false
小开

1)检查尺寸是否相等。如果不相等，那么它们就不相等。

2)遍历 A 中的每个元素并检入 B 中存在的元素。如果一个元素失败，返回 unequal

3)如果上述两个条件不成立，那就意味着它们是相等的。

let isEql = (setA, setB) => {
if (setA.size !== setB.size)
return false;
  

setA.forEach((val) => {
if (!setB.has(val))
return false;
});
return true;
}


let setA = new Set([1, 2, {
3: 4
}]);
let setB = new Set([2, {
3: 4
},
1
]);


console.log(isEql(setA, setB));

2)方法2

let isEql = (A, B) => {
return JSON.stringify([...A].sort()) == JSON.stringify([...B].sort());
}


let res = isEql(new Set([1, 2, {3:4}]), new Set([{3:4},1, 2]));
console.log(res);

小开

我在测试中采用这种方法:

let setA = new Set(arrayA);
let setB = new Set(arrayB);
let diff = new Set([...setA].filter(x => !setB.has(x)));
expect([...diff].length).toBe(0);
小开

这些解决方案都没有将预期的功能“返回”到像 一套，一套，一套。这样的数据结构中。在当前的状态下，Javascript 预备对此毫无用处，因为超集将包含重复的子集，而 Javascript 错误地认为重复的子集是截然不同的。我能想到的唯一解决方案是将每个子集转换为 数组，对它进行排序，然后编码为 绳子(例如 JSON)。

解决方案

var toJsonSet = aset /* array or set */ => JSON.stringify([...new Set(aset)].sort());
var fromJsonSet = jset => new Set(JSON.parse(jset));

基本用法

var toJsonSet = aset /* array or set */ => JSON.stringify([...new Set(aset)].sort());
var fromJsonSet = jset => new Set(JSON.parse(jset));


var [s1,s2] = [new Set([1,2,3]), new Set([3,2,1])];
var [js1,js2] = [toJsonSet([1,2,3]), toJsonSet([3,2,1])]; // even better


var r = document.querySelectorAll("td:nth-child(2)");
r[0].innerHTML = (toJsonSet(s1) === toJsonSet(s2)); // true
r[1].innerHTML = (toJsonSet(s1) == toJsonSet(s2)); // true, too
r[2].innerHTML = (js1 === js2); // true
r[3].innerHTML = (js1 == js2); // true, too


// Make it normal Set:
console.log(fromJsonSet(js1), fromJsonSet(js2)); // type is Set
<style>td:nth-child(2) {color: red;}</style>


<table>
<tr><td>toJsonSet(s1) === toJsonSet(s2)</td><td>...</td></tr>
<tr><td>toJsonSet(s1) == toJsonSet(s2)</td><td>...</td></tr>
<tr><td>js1 === js2</td><td>...</td></tr>
<tr><td>js1 == js2</td><td>...</td></tr>
</table>

最终测试: 集合集

var toSet = arr => new Set(arr);
var toJsonSet = aset /* array or set */ => JSON.stringify([...new Set(aset)].sort());
var toJsonSet_WRONG = set => JSON.stringify([...set]); // no sorting!


var output = document.getElementsByTagName("code");
var superarray = [[1,2,3],[1,2,3],[3,2,1],[3,6,2],[4,5,6]];
var superset;


Experiment1:
superset = toSet(superarray.map(toSet));
output[0].innerHTML = superset.size; // incorrect: 5 unique subsets
Experiment2:
superset = toSet([...superset].map(toJsonSet_WRONG));
output[1].innerHTML = superset.size; // incorrect: 4 unique subsets
Experiment3:
superset = toSet([...superset].map(toJsonSet));
output[2].innerHTML = superset.size; // 3 unique subsets
Experiment4:
superset = toSet(superarray.map(toJsonSet));
output[3].innerHTML = superset.size; // 3 unique subsets
code {border: 1px solid #88f; background-color: #ddf; padding: 0 0.5em;}
<h3>Experiment 1</h3><p>Superset contains 3 unique subsets but Javascript sees <code>...</code>.<br>Let’s fix this... I’ll encode each subset as a string.</p>
<h3>Experiment 2</h3><p>Now Javascript sees <code>...</code> unique subsets.<br>Better! But still not perfect.<br>That’s because we didn’t sort each subset.<br>Let’s sort it out...</p>
<h3>Experiment 3</h3><p>Now Javascript sees <code>...</code> unique subsets. At long last!<br>Let’s try everything again from the beginning.</p>
<h3>Experiment 4</h3><p>Superset contains 3 unique subsets and Javascript sees <code>...</code>.<br><b>Bravo!</b></p>

小开

你也可以试试:

var a = new Set([1,2,3]);
var b = new Set([1,3,2]);


let areSetsEqual = (a, b) => a.size === b.size && [...a].every(value => b.has(value));


console.log(areSetsEqual(a,b))

小开

我为 Set.Prototype.isequals ()创建了一个快速的 polyfill

Set.prototype.isEqual = function(otherSet) {
if(this.size !== otherSet.size) return false;
for(let item of this) if(!otherSet.has(item)) return false;
return true;
}

Github Gist-Set.Prototype.isequals

小开

基于公认的答案，假设 Array.from得到支持，以下是一句俏皮话:

function eqSet(a, b) {
return a.size === b.size && Array.from(a).every(b.has.bind(b));
}
小开

如果集合只包含基本数据类型，或者集合内部的对象具有引用相等性，则有更简单的方法

const isEqualSets = (set1, set2) => (set1.size === set2.size) && (set1.size === new Set([...set1, ...set2]).size);

小开

根据@Aadit M Shah 的回答，做了很小的修改:

/**
* check if two sets are equal in the sense that
* they have a matching set of values.
*
* @param {Set} a
* @param {Set} b
* @returns {Boolean}
*/
const areSetsEqual = (a, b) => (
(a.size === b.size) ?
[...a].every( value => b.has(value) ) : false
);

如果有人像我一样因为最新的巴别塔的一些怪异而遇到问题，必须在这里添加一个明确的条件。

(对于复数，我认为 are读起来更直观一些)

小开

方法返回 false 的原因是您比较了两个不同的对象(即使它们得到了相同的内容) ，因此比较两个不同的对象(不是引用，而是对象)总是返回 false。

下面的方法将两个集合合并为一个，然后愚蠢地比较大小。如果是一样的，那就是一样的:

const a1 = [1,2,3];
const a2 = [1,3,2];
const set1 = new Set(a1);
const set2 = new Set(a2);


const compareSet = new Set([...a1, ...a2]);
const isSetEqual = compareSet.size === set2.size && compareSet.size === set1.size;
console.log(isSetEqual);

优点 : 它非常简单和短小，没有外部库，只有普通的 JS

缺点 : 它可能比仅仅迭代值要慢，而且需要更多的空间。

小开

也许有点晚了，但我通常会这么做:

const a = new Set([1,2,3]);
const b = new Set([1,3,2]);


// option 1
console.log(a.size === b.size && new Set([...a, ...b]).size === a.size)


// option 2
console.log([...a].sort().join() === [...b].sort().join())

小开

与 拉姆达: equals(set1, set2)

const s1 = new Set([1, 2, 3]);
const s2 = new Set([3, 1, 2]);


console.log( R.equals(s1, s2) );
<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.27.1/ramda.min.js"></script>

小开

我相信这是性能最好的版本，因为它没有创建新的数组，而是使用了 Set 自己的迭代器:

function isEqualSets(a, b) {
if (a === b) return true;
if (a.size !== b.size) return false;
for (const value of a) if (!b.has(value)) return false;
return true;
}

提交答案