Обычно я ожидал бы String.contains()
, но, похоже, его нет.
Каков разумный способ проверить это?
Вот список текущих возможностей:
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
может быть лучшим выбором, если дело доходит до того, что скорость имеет значение.
indexOf
всегда возвращает число, поэтому нет необходимости использовать !==
. Если вы хотите сохранить байты, вы можете использовать ~'foo'.indexOf('oo')
который возвращает истинное значение, если подстрока найдена, и ложное значение ( 0
), если это не так.
Вы можете легко добавить метод 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; }; }
Проблема с вашим кодом заключается в том, что JavaScript чувствителен к регистру. Вызов метода
indexof()
должен быть
indexof()
Попробуйте его исправить и посмотрите, помогает ли это:
if (test.indexOf("title") !=-1) {
alert(elm);
foundLinks++;
}
indexof
вместо indexOf
), могут найти этот ответ и посмотреть, что происходит. Я бы не стал больше касаться этого вопроса.
Существует string.includes
в ES6:
"potato".includes("to");
> true
Обратите внимание, что вам может потребоваться загрузить es6-shim
или аналогичный, чтобы это работало в старых браузерах.
require('es6-shim')
String.prototype.contains = function (segment) { return this.indexOf(segment) !== -1; };
(Кстати: делать что-то на прототипе плохо)
var index = haystack.indexOf(needle);
Вы можете использовать метод JavaScript search()
.
Синтаксис: string.search(regexp)
Возвращает позицию совпадения или -1, если совпадение не найдено.
См. примеры: jsref_search
Вам не нужен сложный синтаксис регулярных выражений. Если вы не знакомы с ними, это сделает простой st.search("title")
. Если вы хотите, чтобы ваш тест был нечувствительным к регистру, вы должны сделать st.search(/title/i)
.
str.toLowerCase().indexOf(searchstr.toLowerCase())
намного более эффективным для поиска str.toLowerCase().indexOf(searchstr.toLowerCase())
регистра?
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, вместо этого вы добавляете ~ тильду.
if (~haystack.indexOf('needle')) alert('found');
Джо Циммерман - вы увидите, что использование ~ on -1 преобразует его в 0. Число 0 является значение false, что означает, что он будет вычисляться как false при преобразовании в булево. Сначала это может показаться не очень сильным, но помните, что функции, такие как indexOf, возвращают -1, когда запрос не найденный. Это означает, что вместо того, чтобы писать что-то похожее на это:
if (someStr.indexOf("a") >= 0) { // Found it } else { // Not Found }
Теперь у вас может быть меньше символов в коде, чтобы вы могли писать например:
if (~someStr.indexOf("a")) { // Found it } else { // Not Found }
Подробнее подробнее здесь
includes()
, выполнив следующее: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Эта часть кода должна хорошо работать:
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), а все остальные значения будут отличными от нуля (правда).
Операторы с двойным булевым отрицанием используются для перевода числа в логическое.
!!~
над >-1
?
В 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-й вариант: Используйте 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.
Используйте регулярное выражение:
Вы можете использовать селектор jQuery :contains
.
$("div:contains('John')")
Отметьте здесь: contains-selector
Другой способ сделать это:
Вы можете использовать функцию соответствия, то есть что-то вроде:
x = "teststring";
if (x.match("test")) {
// Code
}
match() также может работать с регулярным выражением:
x = "teststring";
if (x.match(/test/i)) {
// Code
}
obj
не-RegExp передается, он неявно преобразуется в RegExp
с помощью new RegExp(obj)
» , см. Developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Вы искали .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 зарезервированное слово, вы должны использовать className для получения этого атрибута данных. Причина, по которой он, вероятно, терпит неудачу, заключается в том, что он возвращает нулевое значение. Вы можете сделать следующее, чтобы получить значение вашего класса...
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');
BTW, правильным ответом является неправильный indexOf
или нестандартные String.contains
. Загрузка внешней библиотеки (особенно если код написан в чистом JavaScript) или возиться с String.prototype
или с использованием регулярного выражения немного переборщил.
Существует гладкий и лучший способ сделать это, и он использует оператор (BitWise NOT).
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() и 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');
Пример
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
ES6 содержит String.prototype.includes
.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
String.contains
, а ответ таков: в ES6 он есть. Ссылка предоставляется только в качестве дополнительной документации.
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+'');
lastIndexOf
если вы хотите только проверить, содержит ли строка подстроку. Метод search
только для регулярных выражений. метод split
делает его только более сложным.
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
Так как есть жалоба на использование прототипа, и поскольку использование indexOf
делает ваш код менее читаемым и поскольку regexp переполнен:
function stringContains(inputString, stringToFind) {
return (inputString.indexOf(stringToFind) != -1);
}
Это компромисс, в который я попал.
Самый простой способ - использовать 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.
Используйте встроенную и простейшую строку 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");
}
Если вам не нравятся трюки !!~
и т.д., вы можете просто добавить +1
к результату .indexOf()
. Таким образом, если строка не найдена, -1 + 1 = 0
будет ложной, 0.. + 1 = 1..
будет правдой:
if ("StackOverflow".indexOf("Stack") + 1 )
alert('contains');
else
alert('does not contain');
++'foo'.indexOf('bar')
Простой ответ, работает 100%
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
В ES6 у нас есть что-то, что включает в себя, что делает именно то, что вы хотите: так вы можете просто так:
'str1'.includes('str2');
Также в ES5, если вы его широко используете, вы можете просто добавить его так:
String.prototype.includes = String.prototype.includes || function(str) {
return this.indexOf(str) > -1;
}
Существует несколько способов сделать это. Наиболее часто используется метод indexOf()
. indexOf()
возвращает позицию строки, переданной ей как аргумент, и -1, если строка не содержит переданную строку.
let str = "A cat and a dog";
str.indexOf("cat"); // returns 2
str.indexOf("panda"); // returns -1
Еще одна функция search
:
var str = "Stack Overflow";
var n = str.search("Overflow");
if (n != -1)
alert('String exists')
search
для регулярных выражений
Это функция, чтобы проверить, существует ли подстрока в строке или нет:
function isStringMatch(str, str_to_match) {
return (str.indexOf(str_to_match) > -1);
}
>=0
, >-1
, либо (мое предпочтение) !== -1
, так как это не удастся в его текущей форме, если строка начинается с подстроки.
Попробуйте следующее:
if ('Hello, World!'.indexOf('orl') !== -1)
alert("The string 'Hello World' contains the substring 'orl'!");
else
alert("The string 'Hello World' does not contain the substring 'orl'!");
Вот пример: jsfiddle
С ECMAScript 2015 мы можем использовать includes()
let s = "foo";
console.log(s.includes("oo"));
Я знаю, что лучший способ - str.indexOf(s) !== -1;
http://hayageek.com/javascript-string-contains/
Я предлагаю другой способ (str.replace(s1, "") !== str
):
var str = "Hello World!", s1 = "ello", s2 = "elloo";
alert(str.replace(s1, "") !== str);
alert(str.replace(s2, "") !== str);
Очень просто:
var a = "foo", b= "oo";
if (a.indexOf(substring) !== -1) {
// has
}
Вы также можете сделать что-то вроде этого
var snipers = " Vasily Zaytsev, Simo Hayha, Chris Kyle";
var me = "Josip";
function printSniperStatus (person) {
if (aContainsB(snipers, person)) {
console.log(person + " is a sniper.");
} else {
console.log(person + " is NOT a sniper.");
}
}
// Outputs: "Josip is NOT a sniper."
printSniperStatus(me);
Вы можете использовать indexOf
, который возвращает позицию строки. Если не найден, он вернет -1. Поэтому, если метод возвращает -1
, строка не существует
var string = "This is a test string",
substring = "test";
if(string.indexOf(substring) >= 0)
//substring exist
else
//substring does not exist
Я удивлен, что никто не упомянул KMP здесь. Что такое KMP? Алгоритм KMP обеспечивает наихудший поиск подстроки линейного времени, поэтому это разумный способ, если вы позаботитесь о наихудшей временной сложности. Ссылка на образец реализации KMP JavaScript
Обычно я ожидал бы метод String.contains(),...
В зависимости от того, что обычно означает, есть хотя бы один способ, не представленный во всех предыдущих ответах.
Это может быть полезно в очень конкретных случаях, но:
var mystring="Foo bar baz"
var searchstr="bar"
var arraysplt=mystring.split(searchstr)
var containbool=typeof(arraysplt[1])=="string";
Если searchstr
присутствует хотя бы один раз, даже в конце mystring
, то typeof(split(...)[1])
string
(пустая строка). Если нет, то typeof(split(...)[1])
станет undefined
.
или
typeof( mystring.split( searchstr )[1] ) == "string";
Но использование этого метода может быть полезно только тогда, когда элементы arraysplt
будут полезны для использования в script.
... так что этот короткий метод кажется совершенно бесполезным (я думаю)...
Но если ваша цель состоит в том, чтобы разбить строку, используя indexOf
, чтобы обеспечить отсутствие разделителя.
var string = "foo",
substring = "oo";
console.log(string.indexOf(substring) !== -1);
Используя Indexof, который можно легко идентифицировать, Пример:
var array = [2, 9, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0
Результат в комментарии после строки
Метод indexOf является лучшим решением, так как он поддерживается всеми браузерами
Синтаксис: string.indexOf(searchvalue, start)
где start
- необязательный параметр.
Ни один из вышеперечисленных не работал у меня, поскольку были пробелы, но это то, что я сделал
tr = table.getElementsByTagName("tr");
for (i = 0; i < tr.length; i++) {
td = tr[i].getElementsByTagName("td")[0];
bottab.style.display="none";
bottab2.style.display="none";
if (td) {
var getvar=td.outerText.replace(/\s+/, "") ;
if (getvar==filter){
tr[i].style.display = "";
}else{
tr[i].style.display = "none";
}
}
}
result = 'GBP|1800';
//if pipe delimeter is there it returns true else false.
if(result.indexOf("|"))
{
console.log('go default:' +result);
var cur = result.substring(0, 3);//returns GBP
console.log('go default cur:' +cur);
var minmum_fee = result.substring(4);//gets the substring amount
console.log('go default minmum_fee:' +minmum_fee);
}
else
{
console.log('not found:' +result);
}