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

Обычно я ожидал бы String.contains(), но, похоже, его нет.

Каков разумный способ проверить это?

Ответы

Ответ 1

ES6 представил String.prototype.includes:

var string = "foo",
    substring = "oo";

console.log(string.includes(substring));

Ответ 2

Вы можете легко добавить метод contains к String с помощью этого оператора:

String.prototype.contains = function(it) { return this.indexOf(it) != -1; };

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

В качестве альтернативы:

if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }

Ответ 3

В ES6 есть String.prototype.includes:

"potato".includes("to");
> true

Обратите внимание, что это не работает в Internet Explorer или некоторых других старых браузерах с отсутствующей или неполной поддержкой ES6. Чтобы это работало в старых браузерах, вы можете использовать транспортер, например Babel, библиотеку shim, например, es6-shim, или этот полифилл из MDN:

if (!String.prototype.includes) {
  String.prototype.includes = function(search, start) {
    'use strict';
    if (typeof start !== 'number') {
      start = 0;
    }

    if (start + search.length > this.length) {
      return false;
    } else {
      return this.indexOf(search, start) !== -1;
    }
  };
}

Ответ 4

Проблема с вашим кодом заключается в том, что JavaScript чувствителен к регистру. Вызов метода

indexof()

должен быть

indexof()

Попробуйте его исправить и посмотрите, помогает ли это:

if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}

Ответ 5

var index = haystack.indexOf(needle);

Ответ 6

Вы можете использовать метод JavaScript search().

Синтаксис: string.search(regexp)

Возвращает позицию совпадения или -1, если совпадение не найдено.

См. примеры: jsref_search

Вам не нужен сложный синтаксис регулярных выражений. Если вы не знакомы с ними, это сделает простой st.search("title"). Если вы хотите, чтобы ваш тест был нечувствительным к регистру, вы должны сделать st.search(/title/i).

Ответ 7

String.prototype.includes() был введен в ES6.

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

Синтаксис

var contained = str.includes(searchString [, position]);

Параметры

searchString

Строка, которую нужно искать внутри этой строки.

position

Позиция в этой строке, в которой нужно начинать поиск searchString по умолчанию 0.

Пример

var str = "To be, or not to be, that is the question.";

console.log(str.includes("To be"));    // true
console.log(str.includes("question")); // true
console.log(str.includes("To be", 1)); // false

Ответ 8

Если вы искали альтернативу для написания некрасивого чека -1, вы вместо этого добавляете тильду.

if (~haystack.indexOf('needle')) alert('found');

От Джо Циммермана Великая Тайна Тильды (~):

вы увидите, что использование ~ on -1 преобразует его в 0. Число 0 - это ложное значение, означающее, что оно будет оценено как false при преобразовании в логическое значение. indexOf это может показаться не очень indexOf, но помните, что функции, такие как indexOf будут возвращать -1, когда запрос не найден. Это означает, что вместо того, чтобы писать что-то похожее на это:
if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}
Теперь в вашем коде может быть меньше символов, поэтому вы можете написать его так:
if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}

Ответ 9

Общий способ записи метода contains в JavaScript:

if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

Оператор побитового отрицания (~) используется, чтобы превратить -1 в 0 (falsey), а все остальные значения будут отличными от нуля (правда).

Операторы с двойным булевым отрицанием используются для перевода числа в логическое.

Ответ 10

Эта часть кода должна хорошо работать:

var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
}

Ответ 11

В ES5

var s = "foo";
alert(s.indexOf("oo") > -1);

Ответ 12

Вместо использования фрагментов кода, найденных здесь и там в Интернете, вы также можете использовать хорошо протестированную и задокументированную библиотеку. Два варианта, которые я бы рекомендовал:

1-й вариант: Используйте Lodash: у него есть includes:

_.includes('foobar', 'ob');
// → true

Lodash - самая популярная зависимость библиотеки javascript для npm и имеет множество полезных методов утилиты javascript. Так что для многих проектов вы все равно захотите этого; -)

Вторая опция: Или используйте Underscore.string: у нее есть include метод:

_.str.include('foobar', 'ob');
// → true

Вот описание Underscore.string, оно просто добавляет 9kb, но дает вам все преимущества, которые хорошо протестированная и документированная библиотека имеет над фрагментами кода copy'n'paste:

Underscore.string - это библиотека JavaScript для удобной манипуляции с строками, расширение для Underscore.js, вдохновленное Prototype.js, Right.js, Подчеркивание и красивый язык Ruby.

Underscore.string предоставляет вам несколько полезных функций: capize, чистый, включает, count, escapeHTML, unescapeHTML, вставку, сращивание, startsWith, endsWith, заголовки, обрезка, обрезание и т.д.

Обратите внимание, что на Underscore.string влияет Underscore.js, но может использоваться без него.

Последнее не наименьшее: С версией JavaScript ES6 поставляется встроенный метод includes:

'foobar'.includes('ob');
// → true

Большинство современных браузеров уже поддерживают его, обратите внимание на таблицу совместимости ES6.

Ответ 13

Используйте регулярное выражение:

RegExp.test(string)

Ответ 14

Вы можете использовать match функцию, которая принимает RegExp (или строку, которая неявно преобразуется в RegExp), как это:

var stringData = "teststring";

var subStringToSearch = "test";

// This will give back the substring if it matches and return null otherwise
var doesContains = stringData.match(subStringToSearch);

if (doesContains != null) {
    alert("Contains Substring");
}

Как уже отмечалось, match() также может принимать RegExp в качестве аргумента:

x = "teststring";

if (x.match(/test/i)) {
     // Code
}

Ответ 15

Вы можете использовать селектор jQuery :contains.

$("div:contains('John')")

Отметьте здесь: contains-selector

Ответ 16

Вы искали .indexOf ^MDN.

indexOf будет возвращать индекс подстрочной подстроке. Индекс будет коррелировать с тем, где начинается подстрока. Если совпадения нет, возвращается -1. Вот простая демонстрация этой концепции:

var str = "Hello World"; // For example, lets search this string,
var term = "World"; // for the term "World",
var index = str.indexOf(term); // and get its index.
if (index != -1) { // If the index is not -1 then the term was matched in the string,
  alert(index); // and we can do some work based on that logic. (6 is alerted)
}

Ответ 17

Это просто сработало для меня. Он выбирает строки, которые не содержат термин "Удалено:"

if (eventString.indexOf("Deleted:") == -1)

Ответ 18

Вам нужно вызвать indexOf с капиталом "O", как указано. Следует также отметить, что в классе JavaScript зарезервированное слово, вы должны использовать className для получения этого атрибута данных. Причина, по которой он, вероятно, терпит неудачу, заключается в том, что он возвращает нулевое значение. Вы можете сделать следующее, чтобы получить значение вашего класса...

var test = elm.getAttribute("className");
//or
var test = elm.className

Ответ 19

Поскольку вопрос довольно популярен, я подумал, что могу добавить в код немного современный аромат.

// const           : creates an immutable constant
const allLinks   = document.getElementsByTagName("a");
// [].reduce.call  : gives access to the reduce method on a HTMLCollection
// () => {}        : ES6 arrow function
const foundLinks = [].reduce.call(allLinks, (sum, link) => {
     // bitwise OR : converts the boolean value to a number
     return sum + (link.classList.contains("title") | 0);
}, 0);

// template literal
console.log('Found ${foundLinks || "no"} title class');

BTW, правильным ответом является неправильный indexOf или нестандартные String.contains. Загрузка внешней библиотеки (особенно если код написан в чистом JavaScript) или возиться с String.prototype или с использованием регулярного выражения немного переборщил.

Ответ 20

`String.prototype.indexOf()` или `String.prototype.search()`?!

Как уже упоминалось, строки JavaScript имеют как indexOf, так и search.

Ключевое различие между ними состоит в том, что indexOf используется только для простых подстрок, тогда как search также поддерживает регулярные выражения. Конечно, преимущество использования indexOf заключается в том, что он быстрее.

См. также В JavaScript, в чем разница между indexOf() и search()?.

Внедрение собственного метода `String.prototype.contains()`

Если вы хотите добавить свой собственный метод contains к каждой строке, лучшим способом сделать это будет @zzzzBov:

if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

Вы бы использовали его следующим образом:

'Hello World'.contains('orl');

Реализация пользовательской утилиты

Обычно не рекомендуется добавлять собственные методы к стандартным объектам в JavaScript, например, потому что это может нарушить совместимость.

Если вам действительно нужен собственный метод contains и/или другие настраиваемые строковые методы, лучше создать свою собственную библиотеку утилиты и добавить в эту библиотеку свои собственные строковые методы:

var helper = {};

helper.string = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    },
    ...
};

Вы бы использовали его следующим образом:

helper.string.contains('Hello World', 'orl');

Использование сторонней библиотеки утилиты

Если вы не хотите создавать свою собственную вспомогательную библиотеку, есть, конечно, всегда возможность использовать стороннюю библиотеку утилиты. Как упоминалось @nachtigall, наиболее популярными являются Lodash и Underscore.js.

В Lodash вы можете использовать _.includes(), который вы используете следующим образом:

_.includes('Hello World', 'orl');

В Underscore.js вы можете использовать _.str.include(), который вы используете следующим образом:

_.str.include('Hello World', 'orl');

Ответ 21

Существует гладкий и лучший способ сделать это, и он использует оператор (BitWise NOT).

if(~"John".indexOf("J")) {
  alert("Found")
}
else {
  alert("Not Found");
}

Побитовое не преобразует "x" в - (x + 1), поэтому, если x получается -1 из метода indexOf, то он будет преобразован в - (-1 + 1) = -0, что является ложным значение.

Ответ 22

Пример

var a  = "Test String";

if(a.search("ring")!=-1){
     //exist 
} else {
     //not found 
}

Ответ 23

ES6 содержит String.prototype.includes.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes

Ответ 24

Простейшее обходное решение

if (!String.prototype.contains) {
  String.prototype.contains= function() {
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}

вы можете использовать следующим образом

"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains(" ")//true
"hello world".contains("  ")//false

Ссылка MDN

Ответ 25

JavaScript-код для использования метода contains в массиве:

<html>
    <head>
        <h2>Use of contains() method</h2>
        <script>
            Array.prototype.contains = function (element) {
                for (var i = 0; i < this.length; i++) {
                    if (this[i] == element) {
                        return true;
                    }
                }
                return false;
            }
            arr1 = ["Rose", "India", "Technologies"];
            document.write("The condition is "+arr1.contains("India")+"<br>");
        </script>
    </head>

    <b>[If the specified element is present in the array, it returns true otherwise
    returns false.]</b>

</html>

В данном коде метод contains определяет, присутствует ли указанный элемент в массиве или нет. Если указанный элемент присутствует в массиве, он возвращает true, иначе он возвращает false.

Ответ 26

Другой альтернативой является KMP.

Алгоритм KMP ищет подстроку length-m в строке length-n за время O (n + m) в наихудшем случае по сравнению с наихудшим случаем O (n⋅m) для простого алгоритма, поэтому использование KMP может разумно, если вам небезразлична сложность времени в худшем случае.

Вот реализация JavaScript от Project Nayuki, взятая из https://www.nayuki.io/res/knuth-morris-pratt-string-matching/kmp-string-matcher.js:

// Searches for the given pattern string in the given text string using the Knuth-Morris-Pratt string matching algorithm.
// If the pattern is found, this returns the index of the start of the earliest match in 'text'. Otherwise -1 is returned.

function kmpSearch(pattern, text) {
  if (pattern.length == 0)
    return 0; // Immediate match

  // Compute longest suffix-prefix table
  var lsp = [0]; // Base case
  for (var i = 1; i < pattern.length; i++) {
    var j = lsp[i - 1]; // Start by assuming we're extending the previous LSP
    while (j > 0 && pattern.charAt(i) != pattern.charAt(j))
      j = lsp[j - 1];
    if (pattern.charAt(i) == pattern.charAt(j))
      j++;
    lsp.push(j);
  }

  // Walk through text string
  var j = 0; // Number of chars matched in pattern
  for (var i = 0; i < text.length; i++) {
    while (j > 0 && text.charAt(i) != pattern.charAt(j))
      j = lsp[j - 1]; // Fall back in the pattern
    if (text.charAt(i) == pattern.charAt(j)) {
      j++; // Next char matched, increment position
      if (j == pattern.length)
        return i - (j - 1);
    }
  }
  return -1; // Not found
}

console.log(kmpSearch('ays', 'haystack') != -1) // true
console.log(kmpSearch('asdf', 'haystack') != -1) // false

Ответ 27

Чтобы собрать какие-то допустимые решения:

var stringVariable = "some text";
var findString = "text";

//using `indexOf()`
var containResult1 = stringVariable.indexOf(findString) != -1;
document.write(containResult1+', ');

//using `lastIndexOf()`
var containResult2 = stringVariable.lastIndexOf(findString) != -1;
document.write(containResult2+', ');

//using `search()`
var containResult3 = stringVariable.search(findString) != -1;
document.write(containResult3+', ');
     
//using `split()`
var containResult4 = stringVariable.split(findString)[0] != stringVariable;
document.write(containResult4+'');

Ответ 28

Так как есть жалоба на использование прототипа, и поскольку использование indexOf делает ваш код менее читаемым и поскольку regexp переполнен:

function stringContains(inputString, stringToFind) {
    return (inputString.indexOf(stringToFind) != -1);
}

Это компромисс, в который я попал.

Ответ 29

JavaScript

 var str = "My big string contain apples and oranges";
 var n = str.indexOf("apples"); 
 alert(n); //will alert 22, -1 if not found

JQuery

  <p>My big string contain apples and oranges</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found

Ответ 30

В ES6 у нас есть что-то, что включает в себя, что делает именно то, что вы хотите: так вы можете просто так:

'str1'.includes('str2');

Также в ES5, если вы его широко используете, вы можете просто добавить его так:

String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}

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

Ответы

Ответ 1

Ответ 2

Ответ 3

Ответ 4

Ответ 5

Ответ 6

Ответ 7

Синтаксис

Параметры

Пример

Ответ 8

Ответ 9

Ответ 10

Ответ 11

Ответ 12

Ответ 13

Ответ 14

Ответ 15

Ответ 16

Ответ 17

Ответ 18

Ответ 19

Ответ 20

String.prototype.indexOf() или String.prototype.search()?!

Внедрение собственного метода String.prototype.contains()

Реализация пользовательской утилиты

Использование сторонней библиотеки утилиты

Ответ 21

Ответ 22

Ответ 23

Ответ 24

Ответ 25

Ответ 26

Ответ 27

Ответ 28

Ответ 29

Ответ 30

`String.prototype.indexOf()` или `String.prototype.search()`?!

Внедрение собственного метода `String.prototype.contains()`