你如何比较两个javascript集?我尝试使用==
和===
,但都返回false。
a = new Set([1,2,3]);
b = new Set([1,3,2]);
a == b; //=> false
a === b; //=> false
这两组是等价的,因为根据定义,sets do not have order(至少通常不是)。我查看了the documentation for Set on MDN,发现没什么用处。有谁知道怎么做?
答案 0 :(得分:52)
试试这个:
var a = new Set([1,2,3]);
var b = new Set([1,3,2]);
alert(eqSet(a, b)); // true
function eqSet(as, bs) {
if (as.size !== bs.size) return false;
for (var a of as) if (!bs.has(a)) return false;
return true;
}

更具功能性的方法是:
var a = new Set([1,2,3]);
var b = new Set([1,3,2]);
alert(eqSet(a, b)); // true
function eqSet(as, bs) {
return as.size === bs.size && all(isIn(bs), as);
}
function all(pred, as) {
for (var a of as) if (!pred(a)) return false;
return true;
}
function isIn(as) {
return function (a) {
return as.has(a);
};
}

all
函数适用于所有可迭代对象(例如Set
和Map
)。
如果Array.from
得到更广泛支持,那么我们可以将all
函数实现为:
function all(pred, as) {
return Array.from(as).every(pred);
}
希望有所帮助。
答案 1 :(得分:29)
您也可以尝试:
var a = new Set([1,2,3]);
var b = new Set([1,3,2]);
isSetsEqual = (a, b) => a.size === b.size && [...a].every(value => b.has(value));
console.log(isSetsEqual(a,b))

答案 2 :(得分:24)
lodash提供_.isEqual()
,进行深入比较。如果您不想自己编写,这非常方便。从lodash 4开始,_.isEqual()
正确地比较了集合。
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
答案 3 :(得分:7)
另一个答案会很好;这是另一种选择。
// 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 }])
将返回false。如果要将上述两个集合视为相等,我们需要遍历两个集合,对每个元素进行深度质量比较。我们规定存在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完全相同的成员。如果找到,请将其删除,以便不能再次使用。如果在s2中找到s1中的所有元素,和 s2用尽,则两组完全相等。未经测试。
您可能会觉得这很有用:http://www.2ality.com/2015/01/es6-set-operations.html。
答案 4 :(得分:6)
这些解决方案都没有将预期的功能“反馈”到数据结构,例如集合。在当前状态下,Javascript Set对此无用,因为超集将包含重复的子集,Javascript错误地认为它们是不同的。我能想到的唯一解决方案是将每个子集转换为Array,对其进行排序,然后编码为String(例如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>
&#13;
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
&#13;
code {border: 1px solid #88f; background-color: #ddf; padding: 0 0.5em;}
&#13;
<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>
&#13;
答案 5 :(得分:2)
使用==,===
比较两个对象使用==
或===
运算符比较两个对象时,您将始终获得false
unless those object reference the same object。例如:
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功能之一,但现代浏览器并未广泛支持。在此处查看兼容性表:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from#Browser_compatibility
答案 6 :(得分:2)
我在测试中遵循这种方法:
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);
答案 7 :(得分:1)
答案 8 :(得分:1)
根据接受的答案,假设Array.from
的支持,这是一个单行:
function eqSet(a, b) {
return a.size === b.size && Array.from(a).every(b.has.bind(b));
}
答案 9 :(得分:0)
如果集合仅包含原始数据类型,或者集合内部的对象具有引用相等性,则有更简单的方法
const isEqualSets = (set1, set2) => (set1.size === set2.size) && (set1.size === new Set([...set1, ...set2]).size);
答案 10 :(得分:0)
根据@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
);
如果由于最新的babel的怪癖,其他人遇到了我遇到的问题,则必须在此处添加一个明确的条件。
(对于复数,我认为are
稍微大声读出?也会更直观)
答案 11 :(得分:0)
这种方法将两个集合合并为一个,然后愚蠢地比较大小。如果相同,则相同:
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);
上方:非常简单。
缺点:这可能比仅遍历值更慢,并且需要更多空间。
答案 12 :(得分:0)
也许有点晚,但是我通常会执行以下操作:
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())
答案 13 :(得分:0)
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>
答案 14 :(得分:-1)
1)检查尺寸是否相等。如果没有,那么他们就不平等了。
2)迭代A的每个元素并检入B中存在的元素。如果一个失败则返回map: L.Map;
mapOptions: L.MapOptions;
3)如果上述2个条件失败,则意味着它们是平等的。
unequal
&#13;
2)方法2
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));
&#13;