如何检测一个数组中的值是否与另一个数组中的值顺序相同？

Question

我想检测在以下情况下，数组1的值是否与数组2按相同顺序排列：

var array1 = ["Bob", "Jason", "Fred"];
var array2 = ["Bob", "Jason", "Fred"]; // result: true, expected: true
or
var array1 = ["Bob", "Jason", "Fred"];
var array2 = ["Bob", "Fred", "Jason"]; // result: false, expected: False
or 
var array1 = ["Bob", "Jason", "Fred"];
var array2 = ["Bob", "Jason"];         // result: true, expected: True
or 
var array1 = ["Jason", "Fred", "Bob"];
var array2 = ["Bob", "Jason"];         // result: false, expected: False
or 
var array1 = ["Jason", "Bob"];
var array2 = ["Jason", "Sue", "Bob"];  // result: false, expected: True - just because array 2 contains sue and array 1 doesn't, doesn't mean jason and bob aren't in the right order. They are. We need to ignore the fact sue is interrupting them.
or 
var array1 = ["Jason", "Sue", "Bob"];
var array2 = ["Jason", "Bob", "Sue"];  // result: false, expected: False
or 
var array1 = ["Sue", "Bob"];
var array2 = ["Jason", "Bob", "Sue"];  // result: false, expected: False
or 
var array1 = ["Bob", "Sue"];
var array2 = ["Jason", "Bob", "Sue"];  // result: false, expected: True - just because jason is playing third wheel doesn't mean bob and sue aren't in the correct order. they are. we need to ignore jason.
or 
var array1 = ["Bob", "Sue", "Bob"];
var array2 = ["Bob", "Bob", "Sue"];  // result: false, expected: False
or 
var array1 = ["Bob", "Sue", "Bob"];
var array2 = ["Bob", "Sue", "Bob"];  // result: true, expected: true
or 
var array1 = ["Bob", "Sue", "Bob"];
var array2 = ["Sue", "Bob"];  // result: false, expected: true - in this scenario, we have two Bobs. while Bob followed by Sue is false, sue followed by bob is true. we need to ignore the first Bob.

到目前为止，我已经完成了以下工作:

if (array1.length > array2.length) {
    var arrayLength = array1.length;
} else if (array1.length < array2.length) {
    var arrayLength = array2.length;
} else {
    var arrayLength = array1.length;
}


for (var i = 0; i < arrayLength; i++){
    if (array1[i] !== array2[i]) { 
        return false; 
    } else {
        return true;
    }
}

我的问题是，以上代码并不总是产生期望的结果。也就是说，如果这两个数组的长度相同，那么我会得到期望的结果，但如果它们的长度不同，我就无法得到期望的结果。

我需要忽略缺少或增加的数值，仅仅考虑它们是否按照相同的顺序排列，即使其中存在缺少或增加的数值。

- Sweepster

---

在循环中：if (array1[i] !== array2[i]) { return false; } - Felix Kling

可能是如何在JavaScript中比较数组？的重复问题。 - Steven Stark

在任何一个数组中，同一个值会出现多次吗？ - Gershom Maes

你的正面例子中两个数组都有相同的第一个元素。这是要求的一部分吗？那么 array1 = ["Jason", "Fred"]; array2 = ["Bob", "Jason", "Fred"]; 呢？ - Felix Kling

@GershomMaes 是的 - Sweepster

Answer 1

myArray 不是一个数组，而是两个数组共享的最小长度，所以请将它命名为minLength或类似的名称。然后，您需要使用索引 i 遍历所有条目，直到达到 minLength。但是， minLength[i] 没有意义。相反，您需要查找数组中的值，例如 array1[i] 和 array2[i] 并比较结果（使用 === 进行比较）。

通过这些信息，您应该能够用自己的方式解决它 :)

我会这样做：

const result = array1.every((el, i) => i >= array2.length || el === array2[i]);

- Jonas Wilms

Answer 2

一种可能的方法是使用一个在任何字符串中都不出现的分隔符将两个数组连接起来，然后检查较长的数组是否包含较短的数组：.join，.includes。

const array1 = ["Jason", "Bob"];
const array2 = ["Jason", "Bob", "Sue"];

const str1 = array1.join('_');
const str2 = array2.join('_');

console.log(
  str1.length > str2.length
  ? str1.includes(str2)
  : str2.includes(str1)
);

- CertainPerformance

---

在真实世界的应用中，实际上很难找到不出现在任何字符串中的分隔符。 - Jonas Wilms

你的回答实际上是最接近我期望结果的，然而他们指出分隔符问题也没有错。 - Sweepster

Answer 3

你可以检查数组最小长度的切片元素。

function sameOrder(a, b) {
    return a
        .slice(0, Math.min(a.length, b.length))
        .every((v, i) => v === b[i]);
}

console.log(sameOrder(["Bob", "Jason", "Fred"], ["Bob", "Jason", "Fred"])); //  true
console.log(sameOrder(["Bob", "Jason", "Fred"], ["Bob", "Fred", "Jason"])); // false
console.log(sameOrder(["Bob", "Jason", "Fred"], ["Bob", "Jason"]));         //  true
console.log(sameOrder(["Jason", "Fred", "Bob"], ["Bob", "Jason"]));         // false
console.log(sameOrder(["Jason", "Bob"], ["Jason", "Sue", "Bob"]));          // false
console.log(sameOrder(["Jason", "Bob"], ["Jason", "Bob", "Sue"]));          //  true

- Nina Scholz

Answer 4

const sameSequence = (array1, array2) => {
  const longest = array1.length > array2.length ? array1 : array2;
  const shortest = array1.length <= array2.length ? array1 : array2;
  return shortest.every((item, index) => item === longest[index]);
};

array1 = console.log(sameSequence(["Bob", "Jason", "Fred"], ["Bob", "Jason", "Fred"]));
array1 = console.log(sameSequence(["Bob", "Jason", "Fred"], ["Bob", "Fred", "Jason"]));
array1 = console.log(sameSequence(["Bob", "Jason", "Fred"],  ["Bob", "Jason"]));
array1 = console.log(sameSequence(["Jason", "Fred", "Bob"], ["Bob", "Jason"]));
array1 = console.log(sameSequence(["Jason", "Bob"], ["Jason", "Sue", "Bob"]));
array1 = console.log(sameSequence(["Jason", "Bob"], ["Jason", "Bob", "Sue"]));

- Adrian Brand

Answer 5

澄清

本节包含我和原帖发表者之间的讨论摘录。

首先，我们重新定义了问题：

我： 所以你想比较共同元素的顺序吗？

原帖发表者： 如果这就是它被称为的东西，是的。请记住，名称可以在任一或两个数组中重复。我们正在尝试检测是否发生了倒置，尽管可能存在多余的元素。

然后，我们将问题简化为比较两个单词之间共同字母的顺序:

原帖发表者： [剪切]"AB" == "ACB"，"AB" == "ABC"，"AB" == "CAB"，"AB" !== "BCA"，"AB" !== "CBA"，"AB" !== "BAC"

最后，原帖发表者提出了以下建议：

原帖发表者： 我认为最简单的方法是检测不出现在另一个数组中的那些元素，并将它们移除。反向进行此操作，然后进行比较(去除C)。我只是不知道怎么做。

我还没有尝试过，但我认为它与下面的第一个算法非常接近，因为它将简单地忽略不在另一个数组中的元素。

算法＃1

思路是从左到右读取数组，删除共同元素对，然后检查剩余集合中是否仍有共同元素。

警告。 与“ABACD”和“BADCD”一起失败。

注意1。 这个反例很有趣，因为它揭示了无论给定给match函数的参数顺序如何，我们都会错过一对有效的数组。

注意2。 在相反的方式迭代在这种情况下可以解决问题，但使用回文可以证明它并不总是有用的，例如，“ABACDDCABA”和“BADCDDCDAB”。

注意3。 如果我们删除“ABACD”的第一个字母，则该算法会给出预期结果，这表明递归方法可能是合适的。

一张图片胜过千言万语：

a = "ABA", b = "BA" => a[i] != b[j] => x = 0b000, y = 0b00
     ^          ^                              ^         ^
     i          j                              i         j

a = "ABA", b = "BA" => a[i] == b[j] => x = 0b001, y = 0b10
     ^           ^                             ^        ^
     i           j                             i        j

> | a.split("").filter(function (_, i) {
  |   return bit(i, x) === 0;
  | })
< | ["B", "A"]
> | b.split("").filter(function (_, i) {
  |   return bit(i, y) === 0;
  | })
< | ["B"]

如果最终的数组包含相同的元素，我们会说存在逆序。在这种情况下，我们需要交换原始数组以再次进行比较：

a = "BA", b = "ABA" => a[i] != b[j] => x = 0b00, y = 0b000
     ^         ^                              ^          ^
     i         j                              i          j

a = "BA", b = "ABA" => a[i] == b[j] => x = 0b01, y = 0b010
     ^          ^                             ^         ^
     i          j                             i         j

a = "BA", b = "ABA" => a[i] == b[j] => x = 0b11, y = 0b110
      ^          ^                           ^         ^
      i          j                           i         j

> | a.split("").filter(function (_, i) {
  |   return bit(i, x) === 0;
  | })
< | []
> | b.split("").filter(function (_, i) {
  |   return bit(i, y) === 0;
  | })
< | ["A"]

考虑到最后的结果，我们可以说 "ABA" 和 "BA" 符合您的条件。

fails = 0;
N = !(Y = true)

// tests[3 * i] = expected result
// tests[3 * i + 1] = array A
// tests[3 * i + 2] = array B

tests = [
  N, "BAA".split(""), "ABA".split(""),
  N, "ABA".split(""), "BAA".split(""),
  Y, "ABA".split(""), "BA+".split(""),
  Y, "BA+".split(""), "ABA".split(""),
  Y, "ABACD".split(""), "BADCD".split(""),
  Y, ["Bob", "Jason", "Fred"], ["Bob", "Jason", "Fred"],
  N, ["Bob", "Jason", "Fred"], ["Bob", "Fred", "Jason"],
  Y, ["Bob", "Jason", "Fred"], ["Bob", "Jason"],
  N, ["Jason", "Fred", "Bob"], ["Bob", "Jason"],
  Y, ["Jason", "Bob"], ["Jason", "Sue", "Bob"],
  N, ["Jason", "Sue", "Bob"], ["Jason", "Bob", "Sue"],
  N, ["Sue", "Bob"], ["Jason", "Bob", "Sue"],
  Y, ["Bob", "Sue"], ["Jason", "Bob", "Sue"],
  N, ["Bob", "Sue", "Bob"], ["Bob", "Bob", "Sue"],
  Y, ["Bob", "Sue", "Bob"], ["Bob", "Sue", "Bob"],
  Y, ["Bob", "Sue", "Bob"], ["Sue", "Bob"]
];

for (i = 0; i < tests.length; i += 3) {
  a = tests[i + 1];
  b = tests[i + 2];
  shouldMatch = tests[i];
  doesMatch = match(a, b) || match(b, a);
  if (shouldMatch !== doesMatch) fails++;
  console.log(
    shouldMatch ? "Y" : "N",
    doesMatch ? "Y" : "N",
    JSON.stringify(a),
    JSON.stringify(b)
  );
}

console.log(
  "fails =", fails
);

function bit (i, n) {
  return n >> i & 1;
}

function match (a, b) {
  var offset = 0, x = 0, y = 0;
  for (var i = 0; i < a.length; i++) {
    for (var j = offset; j < b.length; j++) {
      if (a[i] === b[j]) {
        x += 1 << i;
        y += 1 << j;
        offset = j + 1;
        j = b.length; // break
      }
    }
  }
  a = a.filter(function (_, i) {
    return bit(i, x) === 0;
  });
  b = b.filter(function (_, i) {
    return bit(i, y) === 0;
  });
  return !a.some(function (x) {
    return b.some(function (y) {
      return x === y;
    });
  });
}

算法 #2

注意。 必须验证此算法的正确性（目前没有反例）。

思路是比较从 N 个元素中取 K 个的每种组合，其中 K 从 N 到 0。

特定情况

让我们专注于 N = 3 和 K = 2 的特定情况。为了保持代码简单，我已经用一个 + 符号填充了最小的单词，以便从相同长度的单词开始：

rmDots = w => w.replace(/\.+/g, ""); // dots remover
a = "ABA"; b = "BA+"; // words
n = 3; // words length

for (i = 0; i < n; i++) {
  for (j = 0; j < n; j++) {
    // explode `a` and `b`
    x = a.split("");
    y = b.split("");
    // hide one letter starting
    // from the rightmost one
    x[n - (i + 1)] = ".";
    y[n - (j + 1)] = ".";
    // implode `a` and `b`
    x = x.join("");
    y = y.join("");
    // print out
    console.log(
      // match ? "Yes" : "No"
      rmDots(x) === rmDots(y) ? "Y" : "N",
      JSON.stringify(x), JSON.stringify(y)
    );
  }
}

接下来，您需要检查配对的组合，过滤掉没有剩余公共字母的组合。例如，使用 "ABA" 和 "BAA"，并且 K = 2（因为 N 是字符串的长度，所以 N = 3），您将得到 3 对匹配的组合：

Y "A.A" ".AA"
Y ".BA" "BA."
Y ".BA" "B.A"

然而，它们总是有一个共同的剩余字母（在点后面），分别是".B."和"B.."，"A.."和"..A"，以及"A.."和".A."。因此，当K = 2时，实际上没有一对组合符合您的标准，您必须再次尝试K = 1。

常规化

以下代码片段应该有助于理解最终算法：

function C (n, k) {
  var acc = 1, i = 0;
  while (++i <= k) acc *= (n - k + i) / i;
  return acc;
}

function Ci (n, k, i) {
  var j, c, flags = new Array(n);
  for (j = 1; j <= n; j++) {
    if (k > 0 && (c = C(n - j, k - 1)) > i) {
      k -= 1; flags[j - 1] = true;
    } else {
      i -= c; flags[j - 1] = false;
    }
  }
  return flags;
}

/* ignore this line */ (function(){for(var n=/^ */,e=">",t="<",r="!",o="+",i=Array.prototype.map,l=Array.prototype.slice,a=document.getElementsByTagName("pre"),u=0,c=arguments.length;u<c;u++)a[u].innerHTML=i.call(arguments[u],function(n){return p(n[0])+f(n[2])+s(n[1])}).join("");function p(t){var r=t.split("\n"),o=r[0].match(n)[0].length;return y(e,d(r.map(function(n){return n.slice(o)}).join("\n")))}function s(n){return n instanceof Error?y(r,g("#F00",n+"")):y(t,void 0===n?g("#999","undefined"):d(JSON.stringify(n)))}function f(n){return n.reduce(function(n,e){var t="string"!=typeof e[0],r=l.call(e).map(function(n){return"string"!=typeof n||t?JSON.stringify(n):n}).join(" ");return n+y(o,t?d(r):r)},"")}function y(n,e){return'<span style="display:block"><span style="display:inline-block">'+e.split("\n").map(function(e,t){return(0===t?n:" ")+" | "}).join("\n")+'</span><span style="display:inline-block">'+e+"</span></span>"}function g(n,e){return"<span "+('style="color:'+n+'"')+">"+e+"</span>"}function d(n){return"<code>"+n+"</code>"}}).apply(this,eval("["+function(){var n=/("|\\)/g,e=/^.*?\n|\n.*?$/g,t=Array.prototype.map,r=Array.prototype.filter,o=document.getElementsByTagName("pre");return t.call(o,function(t){return"["+r.call(t.childNodes,function(n){return 8===n.nodeType&&n.nodeValue.split("\n").length>2}).map(function(t){return["function(b,i,o){","return console.log=b[0],[","i,o,b[1]","];","}(function(f,l){","return console.log=function(){","return l.push(arguments),(","f.apply(console,arguments)",");","},[f,l];","}(console.log,[]),",t=JSON.stringify(t.nodeValue.replace(e,"")),',eval("try{',"eval(",t.replace(n,"\\$1"),")",'}catch(e){e}"))'].join("")}).join(",")+"]"}).join(",")}()+"]"));

/* ignore this line */ body{padding:1em !important}html,body{min-width:auto !important}

<link href="https://cdn.sstatic.net/Shared/stacks.css?v=58428843e325" rel="stylesheet"/>
<link href="https://cdn.sstatic.net/Sites/stackoverflow/primary.css?v=2ed743cc91af" rel="stylesheet"/>
<link href="https://cdn.sstatic.net/clc/styles/clc.min.css?v=768595a6d237" rel="stylesheet"/>
<blockquote>
  <p><strong>Help.</strong> Run this snippet then press "Full page".</p>
</blockquote>
<blockquote>
  <p><strong>Help.</strong> <code>&gt;</code> = "input", <code>&lt;</code> = "output", <code>+</code> = "log".</p>
</blockquote>
<p>Taking 2 things among 3:</p>
<pre>
<!--
n = 3
--><!--
k = 2
--><!--
Ci(n, k, 0) // 1st combination
--><!--
Ci(n, k, 2) // 3rd combination
-->
</pre>
<p>Enumerating combinations:</p>
<pre>
<!--
c = C(n, k) // how many combinations?
--><!--
for (i = 0; i < c; i++) {
  console.log(i, Ci(n, k, i));
}
-->
</pre>
<p>Hiding 2 letters among 3:</p>
<pre>
<!--
letters = "ABC".split("")
--><!--
for (i = 0; i < c; i++) {
  flags = Ci(n, k, i);
  console.log(i, letters.map(function (letter, i) {
    var hide = flags[i];
    return hide ? "." : letter;
  }).join(""), flags);
}
-->
</pre>
<p>Taking 2 letter among 3:</p>
<pre>
<!--
letters = "XYZ".split("")
--><!--
for (i = 0; i < c; i++) {
  flags = Ci(n, k, i);
  console.log(i, letters.filter(function (_, i) {
    var take = flags[i];
    return take;
  }).join(""), flags);
}
-->
</pre>

请谨记这是一种暴力破解的方法。每个K都有C(n,k)*C(n,k)个组合可能性（有关C(n,k)的详细信息，请参见Wikipedia），因此，比较字符串所需的时间可能会随着字符串大小（n）的增加呈指数级增长（C(n,k)^2）。换句话说，较大的字符串可能会耗尽您的CPU...

fails = 0;
N = !(Y = true);

// tests[3 * i] = expected result
// tests[3 * i + 1] = array A
// tests[3 * i + 2] = array B

tests = [
  N, "BAA".split(""), "ABA".split(""),
  N, "ABA".split(""), "BAA".split(""),
  Y, "ABA".split(""), "BA+".split(""),
  Y, "BA+".split(""), "ABA".split(""),
  Y, "ABACD".split(""), "BADCD".split(""),
  Y, "ABACDDCABA".split(""), "BADCDDCDAB".split(""),
  Y, ["Bob", "Jason", "Fred"], ["Bob", "Jason", "Fred"],
  N, ["Bob", "Jason", "Fred"], ["Bob", "Fred", "Jason"],
  Y, ["Bob", "Jason", "Fred"], ["Bob", "Jason"],
  N, ["Jason", "Fred", "Bob"], ["Bob", "Jason"],
  Y, ["Jason", "Bob"], ["Jason", "Sue", "Bob"],
  N, ["Jason", "Sue", "Bob"], ["Jason", "Bob", "Sue"],
  N, ["Sue", "Bob"], ["Jason", "Bob", "Sue"],
  Y, ["Bob", "Sue"], ["Jason", "Bob", "Sue"],
  N, ["Bob", "Sue", "Bob"], ["Bob", "Bob", "Sue"],
  Y, ["Bob", "Sue", "Bob"], ["Bob", "Sue", "Bob"],
  Y, ["Bob", "Sue", "Bob"], ["Sue", "Bob"]
];

for (i = 0; i < tests.length; i += 3) {
  a = tests[i + 1];
  b = tests[i + 2];
  shouldMatch = tests[i];
  doesMatch = match(a, b);
  if (shouldMatch !== doesMatch) fails++;
  console.log(
    shouldMatch ? "Y" : "N",
    doesMatch ? "Y" : "N",
    JSON.stringify(a),
    JSON.stringify(b)
  );
}

console.log(
  "fails =", fails
);

function C (n, k) {
  var acc = 1, i = 0;
  while (++i <= k) acc *= (n - k + i) / i;
  return acc;
}

function Ci (n, k, i) {
  var j, c, flags = new Array(n);
  for (j = 1; j <= n; j++) {
    if (k > 0 && (c = C(n - j, k - 1)) > i) {
      k -= 1; flags[j - 1] = true;
    } else {
      i -= c; flags[j - 1] = false;
    }
  }
  return flags;
}

function match (a, b) {
  var n, c, i, j;
  var k; // drop `k` elements
  var a2, b2, a3, b3, aFlags, bFlags;
  n = Math.max(a.length, b.length);
  if (a.length < n) a = a.concat(
    new Array(n - a.length).fill(null)
  );
  if (b.length < n) b = b.concat(
    new Array(n - b.length).fill(null)
  );
  for (k = 0; k < n; k++) {
    c = C(n, k);
    for (i = 0; i < c; i++) {
      aFlags = Ci(n, k, i);
      a2 = a.filter(function (_, i) {
        return !aFlags[i];
      });
      for (j = 0; j < c; j++) {
        bFlags = Ci(n, k, j);
        b2 = b.filter(function (_, i) {
          return !bFlags[i];
        });
        // a2[i] = b2[i] (i in [0-(n-k)])
        // means that we found the biggest
        // sequence of common elements.
        // Therefore, we can stop searching
        // and check if there is at least
        // one pair of common elements
        // in the remaining set.
        if (a2.every(function (x, i) {
          return x === b2[i];
        })) {
          a3 = a.filter(function (_, i) {
            return aFlags[i];
          });
          b3 = b.filter(function (_, i) {
            return bFlags[i];
          });
          return !a3.some(function (x) {
            return b3.some(function (y) {
              return x === y;
            });
          });
        }
      }
    }
  }
  return false;
}

请注意，我使用null值填充最小的数组，以便开始具有相同长度的数组。如果数组已经包含null值，则可能会出现问题，但是找到解决方法并不是什么大问题。

- user1636522

Answer 6

这段代码将帮助您查找数组的顺序。checkOrder函数将返回true，如果数组是相同的顺序，并返回false，如果两个数组不是有序的。

let v = ['bathri','nathan',2];
let x = ['bathri','nathan'];
let value = [];

let checkOrder = function(one, two){

  if(one.length != two.length){
     value = one.length < two.length ? one : two;
  }
  else{
    value = one;
  }
  
  for(let i = 0; i < value.length; i++){
    if(v[i] != x[i])
    {
      return false;
      break;
    }
  }
  return true;
}

console.log(checkOrder(v,x));

---

从Leaf编辑

感谢您的贡献，但它并没有帮助到我们 :-\

N = !(Y = true);

// tests[3 * i] = expected result
// tests[3 * i + 1] = array A
// tests[3 * i + 2] = array B

tests = [
  N, "BAA".split(""), "ABA".split(""),
  N, "ABA".split(""), "BAA".split(""),
  Y, "ABA".split(""), "BA+".split(""),
  Y, "BA+".split(""), "ABA".split(""),
  Y, "ABACD".split(""), "BADCD".split(""),
  Y, "ABACDDCABA".split(""), "BADCDDCDAB".split(""),
  Y, ["Bob", "Jason", "Fred"], ["Bob", "Jason", "Fred"],
  N, ["Bob", "Jason", "Fred"], ["Bob", "Fred", "Jason"],
  Y, ["Bob", "Jason", "Fred"], ["Bob", "Jason"],
  N, ["Jason", "Fred", "Bob"], ["Bob", "Jason"],
  Y, ["Jason", "Bob"], ["Jason", "Sue", "Bob"],
  N, ["Jason", "Sue", "Bob"], ["Jason", "Bob", "Sue"],
  N, ["Sue", "Bob"], ["Jason", "Bob", "Sue"],
  Y, ["Bob", "Sue"], ["Jason", "Bob", "Sue"],
  N, ["Bob", "Sue", "Bob"], ["Bob", "Bob", "Sue"],
  Y, ["Bob", "Sue", "Bob"], ["Bob", "Sue", "Bob"],
  Y, ["Bob", "Sue", "Bob"], ["Sue", "Bob"]
];

for (i = 0; i < tests.length; i += 3) {
  a = tests[i + 1];
  b = tests[i + 2];
  shouldMatch = tests[i];
  doesMatch = checkOrder(a, b);
  console.log(
    shouldMatch ? "Y" : "N",
    doesMatch ? "Y" : "N",
    JSON.stringify(a),
    JSON.stringify(b)
  );
}

function checkOrder (one, two) {
  if (one.length != two.length) {
    value = one.length < two.length ? one : two;
  } else {
    value = one;
  }
  for (let i = 0; i < value.length; i++) {
    if (one[i] != two[i]) {
      return false;
      break;
    }
  }
  return true;
}

- Bathri Nathan

---

我已编辑了你的答案，以向你展示你的函数未能给出预期结果（带有“Y N”或“N Y”的行表示失败）。更多细节请参见此处：https://dev59.com/jrLma4cB1Zd3GeqPbXrC#55153120。 - user1636522

Answer 7

如果我继续采用你的方法，下面的函数就可以工作了。

function matchArrays(arr1, arr2){

    //First result is true

    var result= true;

    //Get minimum length
    var iteration= Math.min(arr1.length, arr2.length);

    //For loop
    for(var i = 0; i<iteration;i++){

       //if not matched
       if(arr1[i]!=arr2[i]){
         result=false;
         break;
       }
    }
    return result;
}

array1 = ["Bob", "Jason", "Fred"];
array2 = ["Bob", "Jason", "Fred"]; // true
document.write(matchArrays(array1, array2));
document.writeln("<br>");
//or

array1 = ["Bob", "Jason", "Fred"];
array2 = ["Bob", "Fred", "Jason"]; // False
document.write(matchArrays(array1, array2));
document.writeln("<br>");
//or 

array1 = ["Bob", "Jason", "Fred"];
array2 = ["Bob", "Jason"];         // True
document.write(matchArrays(array1, array2));
document.writeln("<br>");
//or 

array1 = ["Jason", "Fred", "Bob"];
array2 = ["Bob", "Jason"];         // False
document.write(matchArrays(array1, array2));
document.writeln("<br>");
//or 

array1 = ["Jason", "Bob"];
array2 = ["Jason", "Sue", "Bob"];  // False
document.write(matchArrays(array1, array2));
document.writeln("<br>");
//or 

array1 = ["Jason", "Bob"];
array2 = ["Jason", "Bob", "Sue"];  // True
document.write(matchArrays(array1, array2));
document.writeln("<br>");

function matchArrays(arr1, arr2){
 var result= true;
 var iteration= Math.min(arr1.length, arr2.length);
    for(var i = 0; i<iteration;i++){
     if(arr1[i]!=arr2[i]){
         result=false;
            break;
        }
    }
    return result;
}

- Hasan BINBOGA