contains contem palavra - Como verificar se uma string contém uma substring em JavaScript?





15 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; }; }
caractere char find

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



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




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




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.




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 .







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:

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




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)



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.




Exemplo

var a  = "Test String";

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






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




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:

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



Related