Как проверить, содержит ли строка подстроку в JavaScript?
30 ответов
вот список текущих возможностей:
1. (ЕС6) 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. лодаш включает- перейти к ответу
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
может быть лучшим выбором, если дело доходит до точки, где имеет значение скорость.
вы можете легко добавить 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++;
}
"potato".includes("to");
> true
Примечание вам может потребоваться загрузить es6-shim
или аналогично, чтобы это работало на старых браузерах.
require('es6-shim')
вы можете использовать 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')")
проверьте это здесь:содержит-селектор
другой вариант сделать это:
вы можете использовать функцию 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');
простое решение
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
код 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 как хорошо.