Javascript：如何檢查數組是否包含另一個數組？

Question

假設我有數組父和子。 我想檢查一個子數組是否存在於父數組中。 訂購很重要。
例：

parent = ["x", "a", "b", "c", "d", "e", "f", "g"]
child = ["a", "b", "c"]
//returns true

例：
當父母有不同的順序時：

parent = ["x", "g", "b", "c", "d", "e", "f", "a"]
child = ["a", "b", "c"]
//It should return false   

我如何在Javascript中實現這一目標？
編輯：我試過這個如何檢查一個數組是否包含另一個數組？ 但它對我的情況不起作用

Answer 1

您可以為child運行循環並相應地更改索引。 您還可以使用match變量來檢測序列中的更改。

返回

 var parent = ["x", "a", "b", "c", "d", "e", "f", "g"] var child = ["a", "b", "c"]; var initIndex = parent.indexOf(child[0]); var match = true; for(var i=1; i<child.length; i++){ var varIndex = parent.indexOf(child[i]); if( varIndex === initIndex+1){ initIndex = varIndex; continue; } match = false; } console.log(match); 

返回錯誤

 var parent = ["x", "g", "b", "c", "d", "e", "f", "a"] var child = ["a", "b", "c"]; var initIndex = parent.indexOf(child[0]); var match = true; for(var i=1; i<child.length; i++){ var varIndex = parent.indexOf(child[i]); if( varIndex === initIndex+1){ initIndex = varIndex; continue; } match = false; } //return false console.log(match); 

使用字符串操作

您還可以將數組轉換為字符串以避免這些循環：

 var parent = ["x", "g", "b", "c", "d", "e", "f", "a"] var child = ["a", "b", "c"] var parentStr = parent.toString(); var match = parentStr.indexOf(child.toString()) !== -1; //return false console.log(match); parent = ["x", "a", "b", "c", "d", "e", "f", "g"] child = ["a", "b", "c"] parentStr = parent.toString(); match = parentStr.indexOf(child.toString()) !== -1; //return true console.log(match); 

Answer 2

 var parent = ["x", "g", "b", "c", "d", "e", "f", "a"] var child = ["a", "b", "c"] if(parent.join("").search(child.join("")) === -1) { console.log("Not found"); } else { console.log("found") } 

Answer 3

使用JSON.stringify()將數組轉換為字符串，並從子字符串中刪除方括號。

現在檢查父級中的indexOf子項以檢查它是否包含子級。

 let parent = ["x", "a", "b", "c", "d", "e", "f", "g"]; let child = ["a", "b", "c"]; var parStr = JSON.stringify(parent); var chldStr = JSON.stringify(child).replace('[', '').replace(']', '') console.log(parStr.indexOf(chldStr) !== -1); 

Answer 4

您可以迭代parent數組並使用children數組的索引，如果找到最后一個子數，則返回true 。

 function check(parent, children) { var index = 0; return parent.some(p => p === children[index] && ++index === children.length); } console.log(check(["x", "a", "b", "c", "d", "e", "f", "g"], ["a", "b", "c"])); console.log(check(["x", "g", "b", "c", "d", "e", "f", "a"], ["a", "b", "c"])); 

indexOf的另一種方法

 function check(parent, children) { return children.every((i => c => (i = parent.indexOf(c, i)) !== -1)(0)); } console.log(check(["x", "a", "b", "c", "d", "e", "f", "g"], ["a", "b", "c"])); console.log(check(["x", "g", "b", "c", "d", "e", "f", "a"], ["a", "b", "c"])); 

Answer 5

我有一個簡單的方法來解決這個問題的小型數組。

1. 首先將數組連接到字符串，請參閱Array / join
2. 搜索子字符串，請參閱String / indexOf

 parent = ["x", "a", "b", "c", "d", "e", "f", "g"]; child = ["a", "b", "c"]; function matchSubArray(parent, child) { parentStr = parent.join(''); childStr = child.join(''); return parentStr.indexOf(childStr) != -1; } matchSubArray(parent, child); 

Answer 6

我為此寫了一個函數，需要一些參數：

 Array.prototype.containsArray = function (child, orderSensitivity, caseSensitivity, typeSensitivity) { var self = this; if (orderSensitivity) return orderSensitiveComparer(); else return orderInsensitiveComparer(); function orderSensitiveComparer() { var resultArry = [], placeholder = 0; if (child.length > self.length) return false; for (var i = 0; i < child.length; i++) { for (var k = placeholder; k < self.length; k++) { if (equalityComparer(self[k], child[i])) { resultArry.push(true); if (resultArry.length === child.length) return true; placeholder = k + 1; break; } else resultArry = []; } } return false; } function orderInsensitiveComparer() { for (var i = 0; i < child.length; i++) { var childHasParentElement = false; for (var k = 0; k < self.length; k++) { if (equalityComparer(child[i], self[k])) { childHasParentElement = true; break; } } if (!childHasParentElement) return false; } return true; } function equalityComparer(a, b) { if (caseSensitivity && typeSensitivity) return caseSensitiveEq(a, b) && typeSensitiveEq(a, b); else if (!caseSensitivity && typeSensitivity) return caseInsensitiveEq(a, b) && typeSensitiveEq(a, b); else if (caseSensitivity && !typeSensitivity) return caseSensitiveEq(a, b) && typeInsensitiveEq(a, b); else if (!caseSensitivity && !typeSensitivity) return caseInsensitiveEq(a, b) && typeInsensitiveEq(a, b); else throw "Unknown set of parameters"; function caseSensitiveEq(a, b) { return a == b; } function caseInsensitiveEq(a, b) { return (a + "").toLowerCase() == (b + "").toLowerCase(); } function typeSensitiveEq(a, b) { return typeof(a) === typeof(b); } function typeInsensitiveEq(a, b) { return true; } } } var parent = [1, 2, 3, "a", "b", "c"]; var child = [1, 2, 3]; var child2 = ["1", "2", "3"]; var child3 = ["A", "b", "C"]; var child4 = ["a", "b", "c"]; var child5 = ["c", "b", "a"]; // Tests: console.log(parent.containsArray(parent)); console.log(parent.containsArray(child)); console.log(parent.containsArray(child2)); // parent to child 2, order sensitive, not case, not type. => true. console.log(parent.containsArray(child2, true, false, false)); // parent to child 2, order, not case, type. => false. b/c of type. console.log(parent.containsArray(child2, true, false, true)); // parent to child 3, order, not case, type. => true. console.log(parent.containsArray(child3, true, false, true)); // parent to child 4, order, case and type => true. console.log(parent.containsArray(child4, true, true, true)); // parent to child 4, not order, case and type. => true. console.log(parent.containsArray(child4, false, true, true)); // parent to child 5, not order case or type => true. console.log(parent.containsArray(child5));