Как проверить, содержит ли строка текст из массива подстрок в JavaScript?

Question

Довольно прямо. В javascript мне нужно проверить, содержит ли строка какие-либо подстроки, содержащиеся в массиве.

Answer 1

Нет ничего встроенного, что сделает это за вас, вам придется написать для него функцию.

Если вы знаете , строки не содержат ни одной изсимволы, которые являются специальными в регулярных выражениях, тогда вы можете немного обмануть, например:

if (new RegExp(substrings.join("|")).test(string)) {
    // At least one match
}

..., который создает регулярное выражение, представляющее собой последовательность чередований для подстрок, которые выВы ищете (например, one|two) и проверяете, есть ли совпадения для любого из них, но если любая из подстрок содержит какие-либо символы, которые являются специальными в регулярных выражениях (*, [ и т. д.)вам нужно сначала их избежать, и вам лучше просто делать скучный цикл.

Бесплатный пример из жизни

---

Обновление:

В комментарии к вопросу Martin спрашивает о новой функции Array#map в ECMAScript5.map не так уж сильно помогает, но some это:

if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    // There's at least one
}

Живой пример (работает только в современных браузерах)

Имейте в виду,это означает некоторые накладные расходы, и вы имеете их только в ECMAScript5-совместимых реализациях (например, не в IE7 или более ранних, например; возможно, даже не в IE8), но все же, если вы действительно в этом стиле программирования ... (ИВы можете использовать шимку ECMAScript5, , эту или любую другую.)

Answer 2

var yourstring = 'tasty food'; // the string to check against


var substrings = ['foo','bar'],
    length = substrings.length;
while(length--) {
   if (yourstring.indexOf(substrings[length])!=-1) {
       // one of the substrings is in yourstring
   }
}

Answer 3

Решение в одну строку

substringsArray.some(substring=>yourBigString.includes(substring))

Возвращает true\false, если подстрока exists\does'nt exist

Требуется поддержка ES6

Answer 4

function containsAny(str, substrings) {
    for (var i = 0; i != substrings.length; i++) {
       var substring = substrings[i];
       if (str.indexOf(substring) != - 1) {
         return substring;
       }
    }
    return null; 
}

var result = containsAny("defg", ["ab", "cd", "ef"]);
console.log("String was found in substring " + result);

Answer 5

для людей, гуглящих,

Твердый ответ должен быть.

const substrings = ['connect', 'ready'];
const str = 'disconnect';
if (substrings.some(v => str === v)) {
   // Will only return when the `str` is included in the `substrings`
}

Answer 6

var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = 0, len = arr.length; i < len; ++i) {
    if (str.indexOf(arr[i]) != -1) {
        // str contains arr[i]
    }
}

редактировать: Если порядок тестов не имеет значения, вы можете использовать это (только с одной переменной цикла):

var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = arr.length - 1; i >= 0; --i) {
    if (str.indexOf(arr[i]) != -1) {
        // str contains arr[i]
    }
}

Answer 7

Функция Javascript для поиска в массиве тегов или ключевых слов, используя строку поиска или массив строк поиска. (Использует ES5 некоторые метод массива и ES6 функции стрелок )

// returns true for 1 or more matches, where 'a' is an array and 'b' is a search string or an array of multiple search strings
function contains(a, b) {
    // array matches
    if (Array.isArray(b)) {
        return b.some(x => a.indexOf(x) > -1);
    }
    // string match
    return a.indexOf(b) > -1;
}

Пример использования:

var a = ["a","b","c","d","e"];
var b = ["a","b"];
if ( contains(a, b) ) {
    // 1 or more matches found
}

Answer 8

Если массив не большой, вы можете просто зациклить и проверить строку для каждой подстроки в отдельности, используя indexOf(). В качестве альтернативы вы можете создать регулярное выражение с подстрокой в ​​качестве альтернативы, что может быть, а может и не быть более эффективным.

Answer 9

Не то чтобы я предлагал вам пойти и расширить / модифицировать прототип String, но это то, что я сделал:

String.prototype.includes ()

String.prototype.includes = function (includes) {
    console.warn("String.prototype.includes() has been modified.");
    return function (searchString, position) {
        if (searchString instanceof Array) {
            for (var i = 0; i < searchString.length; i++) {
                if (includes.call(this, searchString[i], position)) {
                    return true;
                }
            }
            return false;
        } else {
            return includes.call(this, searchString, position);
        }
    }
}(String.prototype.includes);

console.log('"Hello, World!".includes("foo");',          "Hello, World!".includes("foo")           ); // false
console.log('"Hello, World!".includes(",");',            "Hello, World!".includes(",")             ); // true
console.log('"Hello, World!".includes(["foo", ","])',    "Hello, World!".includes(["foo", ","])    ); // true
console.log('"Hello, World!".includes(["foo", ","], 6)', "Hello, World!".includes(["foo", ","], 6) ); // false

Answer 10

Если вы работаете с длинным списком подстрок, состоящих из полных «слов», разделенных пробелами или любым другим общим символом, вы можете быть немного умнее в своем поиске.

Сначала разделите вашу строку нагруппы X, затем X + 1, затем X + 2, ..., до Y. X и Y должны быть количеством слов в вашей подстроке с наименьшим и большинством слов соответственно.Например, если X равно 1, а Y равно 4, «Альфа-бета гамма-дельта» становится:

«Альфа» «Бета-версия» «Гамма» «Дельта»

«Альфа-бета» «Бета-гамма"" Гамма-дельта "

" Альфа-бета-гамма "" Бета-гамма-дельта "

" Альфа-бета-гамма-дельта "

Если X будет 2, а Y будет 3, товы бы пропустили первую и последнюю строку.

Теперь вы можете быстро выполнить поиск в этом списке, если вставите его в набор (или карту), намного быстрее, чем при сравнении строк.

Недостатком является то, что вы не можете искать подстроки, такие как "Ta Gamm".Конечно, вы можете учесть это, разделяя по символам, а не по словам, но тогда вам часто придется создавать массивный сет, и затраченное на это время / память перевешивает преимущества.