Как проверить, содержит ли строка подстроку в 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 shim в старых браузерах.

Если вы искали альтернативу для написания уродливой проверки -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);

на ЕС6 есть три новых метода: 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:

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

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

обратите внимание, подчеркнуть.на строку влияет подчеркивания.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

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

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.

в Lodash, вы можете использовать _.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 reference

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 делает ваш код менее читаемым, и поскольку regexp является излишним:

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

используйте встроенный и самый простой i.e 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 как хорошо.