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




15 Answers

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

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 может быть лучшим выбором, если дело доходит до того, что скорость имеет значение.

символ выражения

Обычно я ожидал бы String.contains() , но, похоже, его нет.

Каков разумный способ проверить это?




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

indexof()

на самом деле

indexOf()

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

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



var index = haystack.indexOf(needle);



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




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

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



В 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




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

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

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




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

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

x = "teststring";

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

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

x = "teststring";

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



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

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



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

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




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

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

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

См. Также В JavaScript, в чем разница между indexOf () и search ()? ,

Внедрение собственного String.prototype.contains()

Если вы хотите добавить свой собственный метод contains к каждой строке, лучшим способом сделать это будет :

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

Использование сторонней библиотеки утилиты

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

В Lodash вы можете использовать _.includes() , который вы используете следующим образом:

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

В Underscore.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

Ссылка MDN




Код 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.




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

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

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




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

'str1'.includes('str2');

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

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



Related

javascript string substring contains string-matching