Question

我有一个要比较的数组，一个数组有4个值，另一个数组有3个值。其中一些可以为null，例如：

[1,2,3]

[null,1,2,3] -> should return true
[1,2,3,null] -> should return true
[1,null,2,3] -> should return true
[1,2,2,3] -> should return false
[null,null,null,null] -> should return true
[1, null, 3, 2] -> should return true

实际上，null同时充当1,2,3，这是定义“您可以去”的通用值。

我不知道如何用JavaScript做到这一点，但我已经尝试过了：

            let shouldDisplay = colors.every(function(element){
                return element ? neededColors.includes(element) : true;
            });

能否正确实现？我可以对函数进行一些糟糕的检查，但这不是很好

谢谢！

Answer 1

您可以通过遍历数组来做到这一点：

function check(array, pattern){
  //Next index in the pattern
  let index=0
  for(const elem of array){
    if(elem===pattern[index++] || elem === null){
      if(index >= pattern.length)
        return true
    }else{
      //Didn't match, reset index of pattern
      index=0
    }
  }
  return false
}

console.log(check([1,2,null],[1,2,3]) //true
console.log(check([1,2,4,null],[1,2,3]) //false

Answer 2

如果我理解正确，那么null值就像一个通配符，因此应该可以使用-尽管它不是很好，但可能会有所改进。

const element  = [1, 2, 3];

function compare(a, b) {
  let k = 0;
  for (let i = 0; i < b.length && k < 3; i++) {
    if (b[i] === null || b[i] === a[k]) {
      k++;
    // this is needed for the `[null, 1, 2, 3]` scenario
    } else if (b[i] === a[0]) {
      k = 1;
    } else {
      k = 0;
    }
  }

  return k === 3

在这里您可以对其进行测试：

console.log(compare(element, [null, 1, 2, 3])) // true
console.log(compare(element, [1, 2, 3, null])) // true
console.log(compare(element, [1, null, 2, 3])) // false
console.log(compare(element, [1, 2, 2, 3])) // false
console.log(compare(element, [null, null, null, null])) // true
console.log(compare(element, [1, null, 3, 2])) // true
console.log(compare(element, [null, 2, null, 2])) // true

当然，它可以使用任何元素序列，例如：

console.log(compare(["cc", "22", "fe"], [null, "22", "fe", null]))

编辑： 根据注释，仍然存在一种情况，结果是错误的，[1, null, 2, 3]：这是因为上面的代码仅考虑了一条可能的路径，因此，如果我们已经处于一个序列的中间（1, null），代码需要序列的下一项（3），而应该在其中理解null, 2, 3仍然有效。

我尝试对上面的代码进行一些调整，结果如下：

function compare(a, b) {
  let last = b[0];
  let k = 0;
  for (let i = 1; i < 4 && k < 3; i++) {
    if (b[i] === a[k] || b[i] === null) {
      last = b[i];
      k++;
    } else if (b[i] === a[k + 1] && (last === null || last === a[k])) {
      last = b[i];
      k+=2;
    } else {
      return false;
    }
  }
  return k === 3
}

这将保存已分析的最后一项，并查看序列中的下一项：使用这些信息，可以更好地确定序列（包括通配符）是否为数组。这次我对循环号（3和4）进行了硬编码，但它也应该像以前一样工作。

让我知道是否还有其他情况！

Answer 3

一种简单的方法是使用join（）和indexOf（）。请参见以下示例：

let aOriginalArray = [1,2,3];
let arrayToCompare = [null, 1,2,3]
let isOffset = arrayToCompare.join('').indexOf(aOriginalArray.join('')) > -1;
console.log(isOffset);

检查数组是否包含正确偏移量的数组

3 个答案: