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


14 Answers

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

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

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




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






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




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.




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



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

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



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




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

A sintaxe é: 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 sintaxe 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) .




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

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



Exemplo

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



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.







Você estava procurando por .indexOf String.prototype.indexOf .

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:

if (eventString.indexOf("Deleted:") == -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 métodos ú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 .




Related