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

Вот список текущих возможностей:

1. (ES6) includes - перейдите к ответу

var string = "foo",
    substring = "oo";
string.includes(substring);

2. ES5 и старше indexOf

var string = "foo",
    substring = "oo";
string.indexOf(substring) !== -1;

String.prototype.indexOf возвращает позицию строки в другой строке. Если не найден, он вернет -1 .

3. search - перейдите к ответу

var string = "foo",
    expr = /oo/;
string.search(expr);

4. lodash включает - перейдите к ответу

var string = "foo",
    substring = "oo";
_.includes(string, substring);

5. RegExp - перейдите к ответу

var string = "foo",
    expr = /oo/;  // no quotes here
expr.test(string);

6. Матч - пойти, чтобы ответить

var string = "foo",
    expr = /oo/;
string.match(expr);

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

В ES5

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

В ES6 есть три новых метода: includes() , startsWith() , endsWith() .

var msg = "Hello world!";

console.log(msg.startsWith("Hello"));       // true
console.log(msg.endsWith("!"));             // true
console.log(msg.includes("o"));             // true

console.log(msg.startsWith("o", 4));        // true
console.log(msg.endsWith("o", 8));          // true
console.log(msg.includes("o", 8));          // false

Этот фрагмент кода должен работать хорошо:

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

Другой способ сделать это:

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

x = "teststring";

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

match () также может работать с регулярным выражением:

x = "teststring";

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

Существует string.includes в ES6 :

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

Обратите внимание, что вам может потребоваться загрузить es6-shim или аналогичный, чтобы это работало в старых браузерах.

require('es6-shim')

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

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

Проверьте его здесь: contains-selector

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

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

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

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

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

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

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

'str1'.includes('str2');

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

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

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

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

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

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

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

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

Используйте встроенный и самый простой, то есть match() в строке. Чтобы достичь того, что вы ожидаете, сделайте следующее:

var stringData ="anyString Data";

var subStringToSearch = "any";

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

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

Вы искали .indexOf ^{String.prototype.indexOf} .

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)
}

Вы можете легко добавить метод 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; }; }

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

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

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

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

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

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

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

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

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

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+'');

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

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

Джо Циммерман - вы увидите, что использование ~ on -1 преобразует его в 0. Число 0 является значением false, что означает, что он будет вычисляться как false при преобразовании в Boolean. Сначала это может показаться неважным, но помните, что такие функции, как indexOf, возвращают -1, когда запрос не найден. Это означает, что вместо того, чтобы писать что-то похожее на это:

if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}

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

if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}

Подробнее здесь

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

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

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

// 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 или с использованием регулярного выражения немного переборщил.

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

indexof()

на самом деле

indexOf()

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

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

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  

Заметка

Это может потребовать прокладки ES6 в старых браузерах.

Использование RegEx - это прямой способ сделать это:

Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);