contains contem palavra - Como verificar se uma string contém uma substring em JavaScript?
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; }; }
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
}
ES6 contém String.prototype.includes
.
https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/includes
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");
}