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

7436

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

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

  • 31
    Это легко сделать с помощью метода indexOf, вы можете увидеть руководство по indexOf и подстроке здесь: dreamsyssoft.com/javascript-shell-scripting/…
  • 9
    возможный дубликат строки JQuery содержит проверку
Показать ещё 7 комментариев
Теги:
string
contains
substring
string-matching

49 ответов

12077
Лучший ответ

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

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

  • 927
    @Steve indexOf всегда возвращает число, поэтому нет необходимости использовать !== . Если вы хотите сохранить байты, вы можете использовать ~'foo'.indexOf('oo') который возвращает истинное значение, если подстрока найдена, и ложное значение ( 0 ), если это не так.
  • 701
    Для любопытных: в двух комплиментарных системах -1 представлен в двоичном виде как все 1 с (1111 1111 1111 1111 1111 1111 1111 1111 для 32-битных). Побитовое обратное (~) этого - все нули, или просто ноль, и, следовательно, ложь. Вот почему трюк с закорючкой работает, и это довольно неприятно, если я сам так скажу.
Показать ещё 41 комментарий
782

Вы можете легко добавить метод 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; }; }
  • 363
    Не изменяйте объекты, которые вам не принадлежат. nczonline.net/blog/2010/03/02/...
  • 5
    Я согласен с тем, что в целом это лучшая практика, но я чувствую, что в целом это нормально для кода конкретного приложения. Это было бы ужасно для библиотеки.
Показать ещё 18 комментариев
450

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

indexof()

должен быть

indexof()

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

if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}
  • 11
    @ JeremyW, я бы сказал, что на данный момент ценность этого ответа заключается в том, что люди, которые совершили ту же самую ошибку ( indexof вместо indexOf ), могут найти этот ответ и посмотреть, что происходит. Я бы не стал больше касаться этого вопроса.
379

Существует string.includes в ES6:

"potato".includes("to");
> true

Обратите внимание, что вам может потребоваться загрузить es6-shim или аналогичный, чтобы это работало в старых браузерах.

require('es6-shim')
  • 6
    поскольку я привык «содержать» в других языках и просто реализовал свою функцию, я просто столкнулся с ошибкой. Итак, краткий отзыв о поддержке. Firefox 19 - OSX => ОК, Firefox 19 - Windows => NOK, Chrome - OSX, Windows => NOK
  • 5
    Как это? String.prototype.contains = function (segment) { return this.indexOf(segment) !== -1; }; (Кстати: делать что-то на прототипе плохо)
Показать ещё 8 комментариев
358
var index = haystack.indexOf(needle);
248

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

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

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

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

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

  • 12
    Кажется, что это будет медленнее, чем функция indexOf, потому что ей придется анализировать RegEx. Тем не менее, если вы хотите, чтобы что-то не учитывало регистр символов, ваш путь - это путь (я думаю), хотя это было не то, о чем спрашивали. Даже если об этом не спросили, я голосую за это только из- за нечувствительного к регистру варианта.
  • 31
    Я не запускал тест, но будет ли str.toLowerCase().indexOf(searchstr.toLowerCase()) намного более эффективным для поиска str.toLowerCase().indexOf(searchstr.toLowerCase()) регистра?
Показать ещё 4 комментария
159

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

126

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

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

82

Эта часть кода должна хорошо работать:

var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
} 
  • 0
    он ищет переданный символ или слово, если оно найдено, тогда поиск возвращает целочисленное значение, которое является позицией слова во всей строке. Если слово или символ не найдены, функция поиска возвращает -1.
80

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

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

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

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

  • 14
    В чем преимущество !!~ над >-1 ?
  • 4
    @alex, нет особого преимущества, кроме как не полагаться на магические числа. Используйте то, что вам удобно.
Показать ещё 4 комментария
79

В 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
64

Вместо использования фрагментов кода, найденных здесь и там в Интернете, вы также можете использовать хорошо протестированную и задокументированную библиотеку. Два варианта, которые я бы рекомендовал:


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.

  • 4
    Я не вижу, как выяснение метода подчеркивания в любом случае превосходит простое использование хорошо документированной базовой функциональности, представленной в javascript, как показано здесь. Для типа кодера, который копирует и вставляет код, ваш пример кода будет не более или менее «фрагментом кода для копирования и вставки», чем любое другое решение, представленное здесь, за исключением того , что для него потребуется добавить библиотеку. Добавление библиотек просто для выполнения задач, которые также легко выполняются с использованием родного языка, независимо от размера библиотеки, - плохой совет. -1 от меня за колено рывок библиотеки по старому вопросу.
  • 8
    Если вы уже используете Underscore, вам, вероятно, следует использовать этот подход в любом случае, так как он делает ваш код более читабельным и более понятным для людей, не знакомых с JavaScript ... Помните, что ответы переполнения стека полезны для большего количества людей, чем просто ОП.
Показать ещё 2 комментария
64

Используйте регулярное выражение:

RegExp.test(string)

  • 72
    Использование регулярных выражений - это немного накладные расходы, чтобы проверить только наличие подстроки.
  • 5
    Тесты показывают иное; regex во многих случаях более эффективен и, что более важно, достаточно гибок, чтобы обрабатывать крайние случаи так, как это не делают другие решения.
Показать ещё 4 комментария
63

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

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

Отметьте здесь: contains-selector

  • 25
    Это ищет элементы DOM, хотя ...
  • 22
    дом разбора не имеет ничего общего с вопросом
Показать ещё 1 комментарий
51

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

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

x = "teststring";

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

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

x = "teststring";

if (x.match(/test/i)) {
     // Code
}
  • 7
    если строка «test» включает в себя или другие литералы регулярных выражений вы получите ложные срабатывания.
  • 1
    Это всегда регулярное выражение «Если объект obj не-RegExp передается, он неявно преобразуется в RegExp с помощью new RegExp(obj) » , см. Developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
49

Вы искали .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)
}
48

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

var test = elm.getAttribute("className");
//or
var test = elm.className
  • 4
    Ваш первый подход неверен: elm.getAttribute ("class") == elm.className! = Elm.getAttribute ("className")
47

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

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

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

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

28

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

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

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

23

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

Пример

var a  = "Test String";

if(a.search("ring")!=-1){
     //exist 
} else {
     //not found 
}
22

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

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

21
  • 0
    @ MikeMüller Вопрос заключался в том, почему нет метода String.contains , а ответ таков: в ES6 он есть. Ссылка предоставляется только в качестве дополнительной документации.
  • 0
    В предварительном выпуске ES6 было содержимое, но оно было изменено на включения. Ссылка на ваш содержащий метод перенаправляет на метод include здесь: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… Вот доказательство того, что он был переименован: bugzilla.mozilla.org/show_bug.cgi?id=1102219
21

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.

  • 3
    -1; этот вопрос о строках, а не массивах.
  • 3
    строка это массив символов :)
Показать ещё 1 комментарий
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+'');
  • 0
    Я не вижу смысла в использовании lastIndexOf если вы хотите только проверить, содержит ли строка подстроку. Метод search только для регулярных выражений. метод split делает его только более сложным.
17

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
17

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

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

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

13

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

13

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

Если вам не нравятся трюки !!~ и т.д., вы можете просто добавить +1 к результату .indexOf(). Таким образом, если строка не найдена, -1 + 1 = 0 будет ложной, 0.. + 1 = 1.. будет правдой:

if ("StackOverflow".indexOf("Stack") + 1 )
    alert('contains');
else 
    alert('does not contain');
  • 1
    Да, мне тоже не нравятся эти тупые трюки, и я собирался написать следующее в качестве ответа, но ваш достаточно близок, поэтому я просто прокомментирую мой вариант: ++'foo'.indexOf('bar')
  • 0
    @GeorgeJempty: Ваш вариант - хорошая идея, но мой Firefox выдает ошибки, независимо от того, насколько сильно я его искажаю. :(
Показать ещё 1 комментарий
9

Простой ответ, работает 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
  • 0
    Свойство 'содержит' не существует для типа 'Строка'
8

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

'str1'.includes('str2');

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

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

Существует несколько способов сделать это. Наиболее часто используется метод indexOf(). indexOf() возвращает позицию строки, переданной ей как аргумент, и -1, если строка не содержит переданную строку.

let str = "A cat and a dog";
str.indexOf("cat"); // returns 2
str.indexOf("panda"); // returns -1
7

Еще одна функция search:

var str = "Stack Overflow";
var n = str.search("Overflow");
if (n != -1)
    alert('String exists')
  • 3
    search для регулярных выражений
7

Это функция, чтобы проверить, существует ли подстрока в строке или нет:

function isStringMatch(str, str_to_match) {
    return (str.indexOf(str_to_match) > -1);
}
  • 3
    Просто на голову ... это должно быть либо >=0 , >-1 , либо (мое предпочтение) !== -1 , так как это не удастся в его текущей форме, если строка начинается с подстроки.
7

Попробуйте следующее:

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

  • 0
    Мир странный: после того, как на ваш вопрос был дан самый простой Java-скрипт indexOf (), за вами последовали миллионы других неоправданно сложных ответов, которые получили множество откликов. Людям не нравится простой ответ, может быть? Я поражен и удивлен.
6

С ECMAScript 2015 мы можем использовать includes()

let s = "foo";
console.log(s.includes("oo"));
6

Я знаю, что лучший способ - 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);
5

Очень просто:

var a = "foo", b= "oo";
if (a.indexOf(substring) !== -1) {
    // has
}
5

Вы также можете сделать что-то вроде этого

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);
  • 0
    Является ли aContainsB стандартной функцией javascript? Я обнаружил, что это пользовательская функция здесь: adripofjavascript.com/blog/drips/… . Сама функция: function aContainsB (a, b) {return a.indexOf (b)> = 0; }.
5

Вы можете использовать indexOf, который возвращает позицию строки. Если не найден, он вернет -1. Поэтому, если метод возвращает -1, строка не существует

var string = "This is a test string",
substring = "test";
if(string.indexOf(substring) >= 0)
  //substring exist
else
  //substring does not exist
3

Я удивлен, что никто не упомянул KMP здесь. Что такое KMP? Алгоритм KMP обеспечивает наихудший поиск подстроки линейного времени, поэтому это разумный способ, если вы позаботитесь о наихудшей временной сложности. Ссылка на образец реализации KMP JavaScript

3

Еще один ответ...

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

2

var string = "foo",
    substring = "oo";
console.log(string.indexOf(substring) !== -1);
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

Результат в комментарии после строки

0

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

Синтаксис: string.indexOf(searchvalue, start)

где start - необязательный параметр.

0

Ни один из вышеперечисленных не работал у меня, поскольку были пробелы, но это то, что я сделал

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";
                }

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

Ещё вопросы

Сообщество Overcoder
Наверх
Меню