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

Ответ 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;
}