Упорядоченный массив в Javascript с ближайшим отступлением

Question

У меня есть проблема, которую я пытаюсь решить, что я не совсем смог обернуть голову. Если бы кто-то мог указать мне правильное направление, я был бы признателен.

По сути, я сравниваю два упорядоченных массива в javascript. У меня есть индексный массив и массив для сопоставления. Если все элементы в массивах совпадают по порядку, я хочу вернуть совпадение. Но я также хочу вернуть ближайшее частичное совпадение. Например

Если мой индексный массив равен

var index = ['A', 'B', 'C', 'D']

и массив, который я сравниваю:

var compare = ['A', 'B', 'C', 'D']

очевидно, что должно совпадать. Но все они должны совпадать:

var compare = ['A']
var compare = ['A', 'B']
var compare = ['A', 'B', 'C']

Они не должны совпадать:

var compare = ['B']; //doesn't start with 'A'
var compare = ['B', 'C'];  //doesn't start with 'A'
var compare = ['B', 'A']; //not in correct order

Массивы всегда будут в одном и том же порядке, и порядок должен совпадать, чтобы получить значение true.

По сути, я пытаюсь вернуть самое точное совпадение, которое могу, но предоставлю ближайший запасной вариант, если такого совпадения не существует. Кто-нибудь знает, что я говорю? Любая помощь, которую могут оказать люди, будет высоко ценится

Answer 1

var index = ['A', 'B', 'C', 'D'];
var compare = ['A', 'B', 'C', 'D'];

function getMatches(array1, array2){
    var matches = [];
    array1.forEach((element, index) => {
        if(element == array2[index])
            matches.push(element);
        else
            return matches;
    });
    return matches;
}

getMatches(index, compare);

Answer 2

Просто используйте Array.prototype.every и получите обратный вызов true, если записи в индексе для двух массивов соответствуют или , если в массиве индекса есть запись для этого индекса, но в массиве compare не делает:

const flag = index.every((entry, n) => compare.length <= n || compare[n] === index[n]);

или в ES5:

var flag = index.every(function(entry, n) {
    return compare.length <= n || compare[n] === index[n];
});

Пример в реальном времени (ES2015 +):

function test(index, compare, expect) {
    const flag = index.every((entry, n) => compare.length <= n || compare[n] === index[n]);
    console.log(index.join(","), compare.join(","), ":", flag, "=>", !flag === !expect ? "Good" : "ERROR");
}

const index = ['A', 'B', 'C', 'D'];
test(index, ['A', 'B', 'C', 'D'], true);
test(index, ['A'], true);
test(index, ['A', 'B'], true);
test(index, ['A', 'B', 'C'], true);
test(index, ['B'], false); //doesn't start with 'A'
test(index, ['B', 'C'], false);  //doesn't start with 'A'
test(index, ['B', 'A'], false); //not in correct order

Если, как Тит предлагает , у вас есть массив массивов и вы хотите найти лучшее совпадение, просто прокрутите их и запомните самое длинное, которое соответствует:

let match = null;
for (const compare of arrayOfArraysToCompare) {
    // No need to compare ones that are shorter than a known match...
    if (!match || compare.length > match.length) {
        const flag = index.every((entry, n) => compare.length <= n || compare[n] === index[n]);
        if (flag && (!match || match.length < compare.length)) {
            match = compare;
        }
    }
}

или в ES5

var match = null;
arrayOfArraysToCompare.forEach(function(compare) {
    // No need to compare ones that are shorter than a known match...
    if (!match || compare.length > match.length) {
        var flag = index.every((entry, n) => compare.length <= n || compare[n] === index[n]);
        if (flag && (!match || match.length < compare.length)) {
            match = compare;
        }
    }
});

Пример в реальном времени (ES2015 +):

const index = ['A', 'B', 'C', 'D'];
const arrayOfArraysToCompare = [
  ['A'],          // Match, but not longest match
  ['A', 'B'],     // *** Longest match
  ['B', 'C', 'D'] // Longer, but not a match
];

let match = null;
for (const compare of arrayOfArraysToCompare) {
    // No need to compare ones that are shorter than a known match...
    if (!match || compare.length > match.length) {
        const flag = index.every((entry, n) => compare.length <= n || compare[n] === index[n]);
        if (flag && (!match || match.length < compare.length)) {
            match = compare;
        }
    }
}
console.log(match);