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

вы можете легко добавить contains метод для строки с этим утверждением:

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

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

indexof()

на самом деле должно быть

indexOf()

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

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

есть string.includes в ES6:

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

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

require('es6-shim')

var index = haystack.indexOf(needle);

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

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

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

смотрите примеры там:jsref_search

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

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 в старых браузерах.

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

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

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

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

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

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

больше подробности здесь

этот кусок кода должен работать так:

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

распространенный способ написать contains метод в JavaScript - это:

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

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

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

на 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

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

---

1 вариант: использовать Лодашь: это includes способ:

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

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

---

2-й вариант: или использовать подчеркивания.строка: это include способ:

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

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

подчеркивания.строка-это библиотека JavaScript для удобного манипулирования со строками, расширение для подчеркивания.Яш вдохновил по прототипу.js, Право.js, подчеркивание и красивый рубиновый язык.

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

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

---

последнее не менее важное: С JavaScript версия ES6 поставляется со встроенным includes способ:

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

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

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

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

проверьте это здесь:содержит-селектор

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

RegExp.test(string)

другой вариант сделать это:

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

x = "teststring";

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

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

x = "teststring";

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

искали .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)
}

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

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

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

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

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

// 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`);

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

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

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

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

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

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

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

см. также в JavaScript, в чем разница между indexOf() а поиск ()?.

реализуя свой 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, самые популярные из них Лодашь и подчеркивания.js.

в Лодашь, вы могли бы использовать _.includes(), который вы используете такой:

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

В Подчеркивания.JS, вы могли бы использовать _.str.include(), который вы используете такой :

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

пример

var a  = "Test String";

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

простое решение

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

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

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

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.

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

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

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

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

это компромисс, на который я в конечном итоге пошел.

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

используйте встроенный и самый простой, т. е. 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 подстроки substr вы можете использовать этот метод:

string = "asdf";
substr = "as";
alert(string.indexOf(substr) == -1 ? false : true);

---

как вы хотели, чтобы функция string.contains(), вы можете реализовать его сами, как это:

String.prototype.contains = function(test) {
    return this.indexOf(test) == -1 ? false : true;
};

теперь вы можете использовать этот метод ecen shorter, чтобы проверить, содержит ли строка специальную подстроку:

string = "asdf";
alert(string.contains("as"));

здесь JSFiddle как хорошо.