Como verificar se uma string contém uma substring em JavaScript?

Normalmente, eu esperaria um método String.contains() , mas não parece haver um.

O que é uma maneira razoável de verificar isso?

Aqui está uma lista de possibilidades atuais:

1. (ES6) includes – ir para responder

 var string = "foo", substring = "oo"; string.includes(substring); 

2. ES5 e mais antigo indexOf

 var string = "foo", substring = "oo"; string.indexOf(substring) !== -1; 

String.prototype.indexOf retorna a posição da string na outra string. Se não for encontrado, retornará -1 .

3. search – ir para responder

 var string = "foo", expr = /oo/; string.search(expr); 

4. lodash inclui – ir para responder

 var string = "foo", substring = "oo"; _.includes(string, substring); 

5. RegExp – ir para responder

 var string = "foo", expr = /oo/; // no quotes here expr.test(string); 

6. Match – ir para responder

 var string = "foo", expr = /oo/; string.match(expr); 

Testes de desempenho estão mostrando que indexOf pode ser a melhor escolha, se chegar a um ponto em que a velocidade é importante.

Você pode facilmente adicionar um método contains a String com esta declaração:

 String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; 

Nota: veja os comentários abaixo para um argumento válido para não usar isto. Meu conselho: use seu próprio julgamento.

Alternativamente:

 if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; } 

O problema com o seu código é que o JavaScript faz distinção entre maiúsculas e minúsculas. Sua chamada de método

 indexof() 

deve ser realmente

 indexOf() 

Tente corrigi-lo e veja se isso ajuda:

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

Existe uma string.includes no ES6 :

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

Note que você pode precisar carregar o es6-shim ou similar para fazer isso funcionar em navegadores mais antigos.

 require('es6-shim') 
 var index = haystack.indexOf(needle); 

Você poderia usar o método JavaScript search() .

A syntax é: string.search(regexp)

Ele retorna a posição da partida ou -1 se nenhuma correspondência for encontrada.

Veja exemplos lá: jsref_search

Você não precisa de uma syntax de expressão regular complicada. Se você não estiver familiarizado com eles, um simples st.search("title") servirá. Se você quer que seu teste seja insensível a maiúsculas e minúsculas, então você deve fazer st.search(/title/i) .

String.prototype.includes() foi introduzido no ES6.

Determina se uma string pode ser encontrada dentro de outra string, retornando true ou false conforme apropriado.

Sintaxe

 var contained = str.includes(searchString [, position]); 

parameters

 searchString 

Uma string a ser pesquisada nesta string.

 position 

A posição nessa string na qual começar a pesquisar por searchString é 0.

Exemplo

 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 

Se você estava procurando uma alternativa para escrever o feio -1, prefixar um til em vez disso.

 if (~haystack.indexOf('needle')) alert('found'); 

Joe Zimmerman – você verá que usar ~ on -1 o converte em 0. O número 0 é um valor de falsey, o que significa que ele será avaliado como falso quando convertido em booleano. Isso pode não parecer um grande insight no início, mas lembre-se que funções como indexOf retornarão -1 quando a consulta não for encontrada. Isso significa que, em vez de escrever algo semelhante a isso:

 if (someStr.indexOf("a") >= 0) { // Found it } else { // Not Found } 

Agora você pode ter menos caracteres em seu código para poder escrevê-lo assim:

 if (~someStr.indexOf("a")) { // Found it } else { // Not Found } 

Mais detalhes aqui

Este trecho de código deve funcionar bem:

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

Uma maneira comum de escrever um método contains em JavaScript é:

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

O operador de negação bit a bit ( ~ ) é usado para transformar -1 em 0 (falsey) e todos os outros valores serão diferentes de zero (truthy).

Os operadores de negação booleana dupla são usados ​​para converter o número em um booleano.

No ES5

 var s = "foo"; alert(s.indexOf("oo") > -1); 

Em vez de usar snippets de código encontrados aqui e ali na Web, você também pode usar uma biblioteca bem testada e documentada. Duas opções que eu recomendaria:


1ª opção: Use Lodash : Tem um método includes :

 _.includes('foobar', 'ob'); // → true 

Lodash é a dependência de biblioteca javascript mais popular para npm e tem um monte de methods úteis de utilitário javascript. Então, para muitos projetos, você gostaria disso de qualquer maneira 😉


2ª opção: Ou use Underscore.string : Tem um método include :

 _.str.include('foobar', 'ob'); // → true 

Aqui está a descrição de Underscore.string, ele apenas adiciona 9kb, mas oferece todas as vantagens que uma biblioteca bem testada e documentada tem sobre os snippets de código do copy’n’paste:

Underscore.string é uma biblioteca JavaScript para manipulação confortável com strings, extensão para Underscore.js inspirada em Prototype.js, Right.js, Underscore e linda linguagem Ruby.

O Underscore.string fornece várias funções úteis: capitalize, limpa, inclui, conta, escapeHTML, unescapeHTML, insert, splice, startsWith, endsWith, titleize, trim, truncate e assim por diante.

Note bem, Underscore.string é influenciado por Underscore.js mas pode ser usado sem ele.


Por último, não menos importante: com o JavaScript, a versão ES6 vem com um método de inclusão embutido:

 'foobar'.includes('ob'); // → true 

A maioria dos navegadores modernos já suporta isso, fique de olho na tabela de compatibilidade do ES6 .

Você pode usar o seletor de jQuery :contains .

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

Confira aqui: contém-seletor

Use uma expressão regular:

RegExp.test(string)

Outra opção de fazer isso é:

Você pode usar a function de correspondência, isto é, algo como:

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

match () também pode trabalhar com expressão regular:

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

Isso só funcionou para mim. Ele seleciona seqüências de caracteres que não contêm o termo “Excluído:”

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

Você estava procurando por .indexOf MDN .

indexOf retornará um índice para a substring correspondente. O índice irá correlacionar para onde a substring é iniciada. Se não houver correspondência, será retornado um -1. Aqui está uma demonstração simples desse conceito:

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

Você precisa chamar indexOf com um “O” maiúsculo como mencionado. Também deve ser notado, que na class JavaScript é uma palavra reservada, você precisa usar className para obter este atributo de dados. A razão pela qual provavelmente está falhando é porque está retornando um valor nulo. Você pode fazer o seguinte para obter seu valor de class …

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

Como a pergunta é bastante popular, achei que poderia adicionar um pouco de sabor moderno ao código.

 // 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, a resposta correta é incorretamente indexOf ou o String.contains não-padrão. Carregar uma biblioteca externa (especialmente se o código estiver escrito em JavaScript puro) ou mexer com String.prototype ou usar uma expressão regular é um pouco exagerado.

Há uma maneira elegante e melhor de fazer isso e está usando o operador (BitWise NOT).

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

O Bitwise Not converte “x” em – (x + 1) assim, se x resulta em -1 do método indexOf, ele será convertido em – (-1 + 1) = -0, que é um valor falso.

String.prototype.indexOf() ou String.prototype.search() ?

Como outros já mencionaram, as strings JavaScript têm um indexOf e search método de search .

A principal diferença entre ambos é que indexOf é apenas para substrings simples, enquanto search também suporta expressões regulares. Naturalmente, uma vantagem de usar indexOf é que é mais rápido.

Veja também Em JavaScript, qual é a diferença entre indexOf () e search ()? .

Implementando seu próprio método String.prototype.contains()

Se você quiser adicionar seu próprio método contains a cada string, a melhor maneira de fazer isso seria a abordagem do @zzzzBov :

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

Você usaria assim:

 'Hello World'.contains('orl'); 

Implementando uma biblioteca de utilitários customizada

Geralmente é desaprovado adicionar seus próprios methods personalizados a objects padrão em JavaScript, por exemplo, porque isso pode quebrar a compatibilidade.

Se você realmente quer que seu próprio método contains e / ou outros methods de string personalizados, é melhor criar sua própria biblioteca de utilitários e adicionar seus methods de string personalizados a essa biblioteca:

 var helper = {}; helper.string = { contains : function (haystack, needle) { return !!~haystack.indexOf(needle); }, ... }; 

Você usaria assim:

 helper.string.contains('Hello World', 'orl'); 

Usando uma biblioteca de utilitários de terceiros

Se você não quiser criar sua própria biblioteca de ajuda personalizada, sempre haverá a opção de usar uma biblioteca de utilitários de terceiros. Como mencionado por @nachtigall , os mais populares são o Lodash e o Underscore.js .

Em Lodash, você poderia usar o _.includes() , que você usa assim:

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

Em Underscore.js, você poderia usar o _.str.include() , que você usa assim:

 _.str.include('Hello World', 'orl'); 

Solução simples

 if (!String.prototype.contains) { String.prototype.contains= function() { return String.prototype.indexOf.apply(this, arguments) !== -1; }; } 

você pode usar da seguinte maneira

 "hello".contains("he") // true "hello world".contains("lo w")//true "hello world".contains("lo wa")//false "hello world".contains(" ")//true "hello world".contains(" ")//false 

Referência MDN

Exemplo

 var a = "Test String"; if(a.search("ring")!=-1){ //exist } else { //not found } 

Código JavaScript para usar o método contains em uma matriz:

   

Use of contains() method

[If the specified element is present in the array, it returns true otherwise returns false.]

No código fornecido, o método contains determina se o elemento especificado está presente na matriz ou não. Se o elemento especificado estiver presente na matriz, ele retornará verdadeiro, caso contrário, retornará falso.

Para coletar algum tipo de solução válida:

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

Como há uma reclamação sobre o uso do protótipo, e como usar o indexOf torna seu código menos legível, e como o regexp é um exagero:

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

Esse é o compromisso que acabei indo para.

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

  

My big string contain apples and oranges

alert($("p:contains(apples)")[0] != undefined); //will alert true if found

Use o inbuilt e o mais simples ie match() na string. Para conseguir o que você está ansioso, faça o seguinte:

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

A maneira mais fácil é usar o indexOf . Para apenas verificar uma string de string para um substring substring, você pode usar este método:

 string = "asdf"; substr = "as"; alert(string.indexOf(substr) == -1 ? false : true); 

Como você queria a function string.contains() , você mesmo pode implementá-la assim:

 String.prototype.contains = function(test) { return this.indexOf(test) == -1 ? false : true; }; 

Agora você pode usar este método mais curto para verificar se uma string contém uma substring especial:

 string = "asdf"; alert(string.contains("as")); 

Aqui está um JSFiddle também.