Check if an array contains another array with the same consecutive ordering of elements

Question

For example,

const target = [1,2,3,4,5,"abc", "def", [10,1000]]

test(target, [2,3,4]) === true
test(target, [4,5,"abc"]) === true
test(target, ["def", [10, 1000]) === true
test(target, [0,1,2]) === false
test(target, ["abc",5,4]) === false
test(target, [2,4]) === false
test(target, ["def", [1000, 10]]) === false

Currently I'm using JSON.stringify to accomplish this (and with replacer function if the elements contain things like BigInt values):

`,${JSON.stringify(target).slice(1, -1)},`.includes(`,${JSON.stringify(arr).slice(1, -1)},`)

to check if target contains arr with the same consecutive ordering of elements, however this seems a bit too hacky so I wonder if there are better ways to accomplish it?

EDIT:

I'm not sure why this question is marked as a duplicate of Check if an array includes an array in javascript since it's a completely different question?

EDIT 2：

I have edited the title to be more precise, to match what I really meant and what the examples here have shown. And I still don't think it's a duplicate of Javascript array contains/includes sub array since "sub array" doesn't sound like the same thing and it says The order of the subarray is important but the actual offset it not important which again not sure if it's about the same question.

Also I'm aware that this can be done by brute force loop/recursion kind of solutions instead of the JSON.stringify "hack" I use, I'm more interested in whether there are more performant, or safer, or more idiomatic ways to do it than this "hackish" solution (And I know JSON.stringify cannot serialize things like BigInt, which needs a replacer function to make it work)

EDIT 3:

Add more examples to illustrate what I try to accomplish better.

Answer 1

To check for an ordered sub-array, including rejecting non-consecutive elements, we can use recursion: Array (A) is ordered inside another array (B) if first element of A is found, and if the rest of A, is inside the rest of B immediately after the found element.

function test(b, a, bIndex) {
  if (!a.length) return true;
  bIndex ??= b.findIndex(el => el === a[0]);
  return a[0] !== b[bIndex] ? false : test(b.slice(bIndex+1), a.slice(1), 0);
}

const target = [1,2,3,4,5,"abc", "def"]

console.log(test(target, [2,3,4]) === true)
console.log(test(target, [4,5,"abc"]) === true)
console.log(test(target, [0,1,2]) === false)
console.log(test(target, ["abc",5,4]) === false)
console.log(test(target, [2,4]) === false)

The original version, that isn't sensitive to non-consecutive elements, relaxing the immediately after constraint.

function isOrderedSubArray(b, a) {
  if (!a.length) return true;
  let index = b.findIndex(el => el === a[0]);
  return index === -1 ? false : isOrderedSubArray(b.slice(index + 1), a.slice(1));
}

// testing it...

let bigArray = [0, 1, 2, 3, 4, 5, 6];
let smallA = [2, 5, 6];
let smallB = [2, 5, 12];
let smallC = [4, 3, 5];
let smallD = [6, undefined];

console.log(isOrderedSubArray(bigArray, smallA)===true)
console.log(isOrderedSubArray(bigArray, bigArray)===true)
console.log(isOrderedSubArray(bigArray, smallB)===false)
console.log(isOrderedSubArray(bigArray, smallC)===false)
console.log(isOrderedSubArray(bigArray, smallD)===false)

Answer 2

You could get the start index and check every item of the second array.

const
    test = (a, b) => {
        let offset = a.indexOf(b[0]);
        while (offset !== -1) {
            if (b.every((v, i) => (i + offset) in a && v === a[i + offset])) return true;
            offset = a.indexOf(b[0], offset + 1);
        }
        return false;
    },
    target = [1, 2, 3, 4, 5, "abc", "def"];

console.log(test(target, [2, 3, 4]));                  //  true
console.log(test(target, [4, 5, "abc"]));              //  true
console.log(test(target, [0, 1, 2]));                  // false
console.log(test(target, ["abc", 5, 4]));              // false
console.log(test(target, [2, 4]));                     // false
console.log(test(target, []));                         // false
console.log(test(target, [ "abc", "def", undefined])); // false

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

This could be tidied up but I think it will be quite performant.

1. If the first element of the sub array does not appear in the target return false
2. iterate over the target for the length of sub, from the starting position x
3. If the position of the sub element is not equal to its relative position in the target element, or we go beyond the length of the target array, return false
4. If all these checks pass return true

const target = [1,2,3,4,5,"abc", "def"]

function test(arr, sub) {
    x = arr.indexOf(sub[0])
    i = 0
    while(i < sub.length ) { 
    if(i != sub.indexOf(arr[x],i) || x >= arr.length) return false;
        x+=1
        i+=1
    }
    return true;
}

console.log(test(target, [2,3,4]))// === true
console.log(test(target, [4,5,"abc"]))// === true
console.log(test(target, [0,1,2]))// === false
console.log(test(target, ["abc",5,4]))// === false
console.log(test(target, [2,4]))// === false
console.log(test(target, [])) // === true
console.log(test(target, [ "abc", "def", undefined ])) // === false
console.log(test([ 4, 5, 5, 6 ], [ 5, 5 ])) /// === true