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

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

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

Вам также может понравиться

About the Author: qw

30 комментариев

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

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

  2. Вы можете легко добавить метод 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; }; }
    

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

    indexof()
    

    должен быть

    indexof()
    

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

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

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

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

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

    См. примеры: jsref_search

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

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

  6. Если вы искали альтернативу для написания чек-уродливого -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
    }
    

    Подробнее подробнее здесь

  7. Общий способ записи метода contains в JavaScript:

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

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

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

  8. В 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
  9. Вместо использования фрагментов кода, найденных здесь и там в Интернете, вы также можете использовать хорошо протестированную и задокументированную библиотеку. Два варианта, которые я бы рекомендовал:


    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.

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

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

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

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

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

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

    x = "teststring";
    
    if (x.match(/test/i)) {
         // Code
    }
    

  12. Вы искали .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)
    }
  13. Вам нужно вызвать indexOf с капиталом "O", как указано. Следует также отметить, что в классе JavaScript зарезервированное слово, вы должны использовать className для получения этого атрибута данных. Причина, по которой он, вероятно, терпит неудачу, заключается в том, что он возвращает нулевое значение. Вы можете сделать следующее, чтобы получить значение вашего класса…

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

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

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

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

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

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

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

  17. Простейшее обходное решение

    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

  18. 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.

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

    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+'');
  20. Так как есть жалоба на использование прототипа, и поскольку использование indexOf делает ваш код менее читаемым и поскольку regexp переполнен:

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

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

  21. 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
    

  22. Используйте встроенную и простейшую строку 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");
    }
    

  23. Самый простой способ — использовать 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.

Добавить комментарий для Christian Landgren Отменить ответ

Ваш e-mail не будет опубликован. Обязательные поля помечены *