我有两个数组，我想检查arr2中的每个元素是否都在arr1。如果元素的值在arr2中重复，则它需要在arr1中相等的次数。这样做的最佳方式是什么？
arr1 = [1, 2, 3, 4]
arr2 = [1, 2]
checkSuperbag(arr1, arr2)
> true //both 1 and 2 are in arr1
arr1 = [1, 2, 3, 4]
arr2 = [1, 2, 5]
checkSuperbag(arr1, arr2)
> false //5 is not in arr1
arr1 = [1, 2, 3]
arr2 = [1, 2, 3, 3]
checkSuperbag(arr1, arr2)
> false //3 is not in arr1 twice
答案 0 :(得分：35)
你必须支持糟糕的浏览器吗？如果没有，every功能应该可以轻松实现。
如果arr1是arr2的超集，则arr2中的每个成员必须出现在arr1中
var isSuperset = arr2.every(function(val) { return arr1.indexOf(val) >= 0; });
这是fiddle
修改
所以你要定义超集，这样对于arr2中的每个元素，它在arr1中出现的次数相同吗？我认为filter将帮助您做到这一点（从前面的MDN链接中获取垫片以支持旧浏览器）：
var isSuperset = arr2.every(function (val) {
var numIn1 = arr1.filter(function(el) { return el === val; }).length;
var numIn2 = arr2.filter(function(el) { return el === val; }).length;
return numIn1 === numIn2;
});
结束编辑
如果你想支持旧版浏览器，上面的MDN链接有一个你可以添加的垫片，为了方便起见，我在这里重现：
if (!Array.prototype.every)
{
Array.prototype.every = function(fun /*, thisp */)
{
"use strict";
if (this == null)
throw new TypeError();
var t = Object(this);
var len = t.length >>> 0;
if (typeof fun != "function")
throw new TypeError();
var thisp = arguments[1];
for (var i = 0; i < len; i++)
{
if (i in t && !fun.call(thisp, t[i], i, t))
return false;
}
return true;
};
}
修改
请注意，这将是一个O（N 2 ）算法，因此请避免在大型数组上运行它。
答案 1 :(得分：23)
一个选项是对两个数组进行排序，然后遍历两个数组，比较元素。如果在超级包中没有找到子包候选中的元素，则前者不是子包。排序通常为O（n * log（n）），比较为O（max（s，t）），其中 s 和 t 是数组大小，总时间复杂度为O（m * log（m）），其中m = max（s，t）。
function superbag(sup, sub) {
sup.sort();
sub.sort();
var i, j;
for (i=0,j=0; i<sup.length && j<sub.length;) {
if (sup[i] < sub[j]) {
++i;
} else if (sup[i] == sub[j]) {
++i; ++j;
} else {
// sub[j] not in sup, so sub not subbag
return false;
}
}
// make sure there are no elements left in sub
return j == sub.length;
}
如果实际代码中的元素是整数，则可以使用专用整数排序算法（例如radix sort）来获得总体O（max（s，t））时间复杂度，但是如果包很小，内置的Array.sort可能比自定义整数排序运行得快。
时间复杂度较低的解决方案是创建行李类型。整数袋特别容易。翻转包的现有数组：创建一个对象或数组，其中整数为键，值为重复计数。使用数组不会通过创建arrays are sparse in Javascript来浪费空间。您可以使用行李操作进行子行李或超级行李检查。例如，从子候选中减去super并测试结果是否为非空。或者，contains操作应该是O（1）（或者可能是O（log（n））），因此循环在子袋候选者上并测试超级袋收容是否超过子袋的收容每个子袋元素应为O（n）或O（n * log（n））。
以下是未经测试的。执行isInt作为练习。
function IntBag(from) {
if (from instanceof IntBag) {
return from.clone();
} else if (from instanceof Array) {
for (var i=0; i < from.length) {
this.add(from[i]);
}
} else if (from) {
for (p in from) {
/* don't test from.hasOwnProperty(p); all that matters
is that p and from[p] are ints
*/
if (isInt(p) && isInt(from[p])) {
this.add(p, from[p]);
}
}
}
}
IntBag.prototype=[];
IntBag.prototype.size=0;
IntBag.prototype.clone = function() {
var clone = new IntBag();
this.each(function(i, count) {
clone.add(i, count);
});
return clone;
};
IntBag.prototype.contains = function(i) {
if (i in this) {
return this[i];
}
return 0;
};
IntBag.prototype.add = function(i, count) {
if (!count) {
count = 1;
}
if (i in this) {
this[i] += count;
} else {
this[i] = count;
}
this.size += count;
};
IntBag.prototype.remove = function(i, count) {
if (! i in this) {
return;
}
if (!count) {
count = 1;
}
this[i] -= count;
if (this[i] > 0) {
// element is still in bag
this.size -= count;
} else {
// remove element entirely
this.size -= count + this[i];
delete this[i];
}
};
IntBag.prototype.each = function(f) {
var i;
foreach (i in this) {
f(i, this[i]);
}
};
IntBag.prototype.find = function(p) {
var result = [];
var i;
foreach (i in this.elements) {
if (p(i, this[i])) {
return i;
}
}
return null;
};
IntBag.prototype.sub = function(other) {
other.each(function(i, count) {
this.remove(i, count);
});
return this;
};
IntBag.prototype.union = function(other) {
var union = this.clone();
other.each(function(i, count) {
if (union.contains(i) < count) {
union.add(i, count - union.contains(i));
}
});
return union;
};
IntBag.prototype.intersect = function(other) {
var intersection = new IntBag();
this.each(function (i, count) {
if (other.contains(i)) {
intersection.add(i, Math.min(count, other.contains(i)));
}
});
return intersection;
};
IntBag.prototype.diff = function(other) {
var mine = this.clone();
mine.sub(other);
var others = other.clone();
others.sub(this);
mine.union(others);
return mine;
};
IntBag.prototype.subbag = function(super) {
return this.size <= super.size
&& null !== this.find(
function (i, count) {
return super.contains(i) < this.contains(i);
}));
};
如果您希望禁止重复元素，请参阅“comparing javascript arrays”以获取一组对象的示例实现。
答案 2 :(得分：6)
还没有人发布递归功能，这些功能总是很有趣。将其称为arr1.containsArray( arr2 )。
演示：http://jsfiddle.net/ThinkingStiff/X9jed/
Array.prototype.containsArray = function ( array /*, index, last*/ ) {
if( arguments[1] ) {
var index = arguments[1], last = arguments[2];
} else {
var index = 0, last = 0; this.sort(); array.sort();
};
return index == array.length
|| ( last = this.indexOf( array[index], last ) ) > -1
&& this.containsArray( array, ++index, ++last );
};
答案 3 :(得分：4)
使用对象（读取：哈希表）而不是排序应该将摊销的复杂性降低到O（m + n）：
function bagContains(arr1, arr2) {
var o = {}
var result = true;
// Count all the objects in container
for(var i=0; i < arr1.length; i++) {
if(!o[arr1[i]]) {
o[arr1[i]] = 0;
}
o[arr1[i]]++;
}
// Subtract all the objects in containee
// And exit early if possible
for(var i=0; i < arr2.length; i++) {
if(!o[arr2[i]]) {
o[arr2[i]] = 0;
}
if(--o[arr2[i]] < 0) {
result = false;
break;
}
}
return result;
}
console.log(bagContains([1, 2, 3, 4], [1, 3]));
console.log(bagContains([1, 2, 3, 4], [1, 3, 3]));
console.log(bagContains([1, 2, 3, 4], [1, 3, 7]));
会产生true，false，false。
答案 4 :(得分：4)
在datepicker-api库上找到了这个。此功能使用内置函数来解决问题。 .includes()，.indexOf()和.every()
var array1 = ['A', 'B', 'C', 'D', 'E'];
var array2 = ['B', 'C', 'E'];
var array3 = ['B', 'C', 'Z'];
var array4 = [];
function arrayContainsArray (superset, subset) {
if (0 === subset.length) {
return false;
}
return subset.every(function (value) {
return (superset.includes(value));
});
}
function arrayContainsArray1 (superset, subset) {
if (0 === subset.length) {
return false;
}
return subset.every(function (value) {
return (superset.indexOf(value) >= 0);
});
}
console.log(arrayContainsArray(array1,array2)); //true
console.log(arrayContainsArray(array1,array3)); //false
console.log(arrayContainsArray(array1,array4)); //false
console.log(arrayContainsArray1(array1,array2)); //true
console.log(arrayContainsArray1(array1,array3)); //false
console.log(arrayContainsArray1(array1,array4)); //false
答案 5 :(得分：2)
如果arr2是arr1的子集，那么Length of set(arr1 + arr2) == Length of set(arr1)
var arr1 = [1, 'a', 2, 'b', 3];
var arr2 = [1, 2, 3];
Array.from(new Set(arr1)).length == Array.from(new Set(arr1.concat(arr2))).length
答案 6 :(得分：1)
至于另一种方法，您可以按如下方式进行;
function checkIn(a,b){
return b.every(function(e){
return e === this.splice(this.indexOf(e),1)[0];
}, a.slice()); // a.slice() is the "this" in the every method
}
var arr1 = [1, 2, 3, 4],
arr2 = [1, 2],
arr3 = [1,2,3,3];
console.log(checkIn(arr1,arr2));
console.log(checkIn(arr1,arr3));
答案 7 :(得分：1)
这是我的解决方案：
Array.prototype.containsIds = function (arr_ids) {
var status = true;
var current_arr = this;
arr_ids.forEach(function(id) {
if(!current_arr.includes(parseInt(id))){
status = false;
return false; // exit forEach
}
});
return status;
};
// Examples
[1,2,3].containsIds([1]); // true
[1,2,3].containsIds([2,3]); // true
[1,2,3].containsIds([3,4]); // false
答案 8 :(得分：0)
如果b长于不能超集，则快速解决方案需要两个数组，因此返回false。然后遍历b以查看a是否包含该元素。如果是这样，请将其从a中删除，如果不返回false则继续。更糟糕的情况是，b是一个子集，那么时间b.length。
function isSuper(a,b){
var l=b.length,i=0,c;
if(l>a.length){return false}
else{
for(i;i<l;i++){
c=a.indexOf(b[i]);
if(c>-1){
a.splice(c,1);
}
else{return false}
}
return true;
}
}
这假定输入并不总是有序，如果a为1,2,3且b为3,2,1，则仍会返回true。
答案 9 :(得分：0)
另一个简单的解决方法是：
let a = [1,2,'a',3,'b',4,5]
let b = [1,2,4]
console.log(b.every((i) => a.includes(i)))
希望有帮助