Como verificar se uma string contém um sub-texto em JavaScript?
30 answers
Aqui está uma lista das possibilidades actuais:
1. (ES6) includes
-ir para responder
var string = "foo",
substring = "oo";
string.includes(substring);
2. ES5 ou mais indexOf
var string = "foo",
substring = "oo";
string.indexOf(substring) !== -1;
String.prototype.indexOf
devolve a posição do texto no outro texto. Se não for encontrado, ele 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. Expressão regular-ir para resposta
var string = "foo",
expr = /oo/; // no quotes here
expr.test(string);
6. Corresponder-ir para responder
var string = "foo",
expr = /oo/;
string.match(expr);
Os ensaios de desempenho mostram que indexOf
pode ser a melhor escolha, se chegar a um ponto em que a velocidade é importante.
Pode adicionar facilmente um método contains
ao texto 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.
Em alternativa:
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 é sensível à capitalização. O seu método chama
indexof()
Deve ser realmente
indexOf()
Tenta corrigi - lo e vê se isso ajuda:
if (test.indexOf("title") !=-1) {
alert(elm);
foundLinks++;
}
"potato".includes("to");
> true
Note que poderá ter de carregar es6-shim
ou algo semelhante para que isto funcione em navegadores mais antigos.
require('es6-shim')
var index = haystack.indexOf(needle);
Podes usar o método JavaScript search()
.
A sintaxe é: string.search(regexp)
Devolve a posição da correspondência, ou-1 Se não for encontrada nenhuma correspondência.
Ver exemplos: jsref_search
Você não precisa de uma sintaxe de expressão regular complicada. Se você não estiver familiarizado com eles um simples {[2] } serve. Se quiser que o seu teste seja insensível a maiúsculas, então deve fazer st.search(/title/i)
.
String.prototype.includes()
foi introduzido no ES6.
Determina se um texto pode ser encontrado dentro de outro texto, devolver verdadeiro ou falso, conforme apropriado.
Sintaxe
var contained = str.includes(searchString [, position]);
Parâmetros
searchString
Um texto a procurar dentro deste texto.
position
A posição nesta sequência na qual começar a procurar por searchString
é igual a 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
Nota
Isto pode requerer ES6 shim em navegadores mais antigos.Se você estava procurando uma alternativa para passar o cheque feio-1, você prepara um ~ tilde em vez disso.
if (~haystack.indexOf('needle')) alert('found');
Mais detalhes aquiJoe Zimmerman - você verá que usando ~ on-1 converte para 0. O número 0 é a valor de falsey, o que significa que irá avaliar para falso quando convertido para logico. Isso pode não parecer uma grande ideia no início, mas ... recordar as funções como o indexOf irá retornar-1 quando a consulta não estiver encontrado. Isto significa que em vez de escrever algo semelhante a este:
Agora pode ter menos caracteres no seu código para o poder escrever. assim:if (someStr.indexOf("a") >= 0) { // Found it } else { // Not Found }
if (~someStr.indexOf("a")) { // Found it } else { // Not Found }
var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
//logic
}
Uma forma 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 bitwise (~
) é usado para transformar -1
em 0
(falsey), e todos os outros valores serão não-zero (truthy).
Os operadores de negação booleana dupla são usados para lançar o número em um booleano.
Em ES5
var s = "foo";
alert(s.indexOf("oo") > -1);
Em ES6 existem três novos métodos: 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
Em vez de usar excertos 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 includes
método:
_.includes('foobar', 'ob');
// → true
O Lodash é a mais popular dependência de biblioteca javascript para o MPN e tem montes de métodos úteis de utilitário javascript. Então para muitos projetos você iria querer isso de qualquer maneira; -)
2ª opção: ou usar sublinhado.string: tem um include
método:
_.str.include('foobar', 'ob');
// → true
Aqui está a descrição do sublinhado.string, ele apenas adiciona 9kb, mas lhe dá todas as vantagens que uma biblioteca bem testada e documentada tem sobre excertos de código copy'n'paste:
Nota bem, sublinhado.o texto é influenciado por sublinhado.js mas pode ser usado sem ele.Sublinhado.string é uma biblioteca de JavaScript para manipulação confortável com cordas, extensão para sublinhado.js inspirado no protótipo.js, Direito.js, Underscore e bela linguagem Ruby.
Sublinhado.o texto oferece-lhe várias funções úteis: capitalizar, clean, includes, count, escapeHTML, unescapeHTML, insert, splice, começar com, terminar com, titleize, trim, truncate e assim por diante.
Last not Least: With JavaScript version ES6 comes an built-in includes
método:
'foobar'.includes('ob');
// → true
Os navegadores mais modernos já o suportam., estar de olho no quadro de compatibilidade ES6 .
Utilizar uma expressão regular:
Outra opção para fazer isto é:
Podes usar a função de correspondência, isto é, algo do género:
x = "teststring";
if (x.match("test")) {
// Code
}
O Match () também pode funcionar com expressão regular:
x = "teststring";
if (x.match(/test/i)) {
// Code
}
Estavas à procura .indexOf
MDN.
indexOf
vai devolver um índice à sub-estrutura correspondente. O índice irá correlacionar-se com o início da sub-estrutura. Se não houver correspondência, o a-1 é devolvido. Aqui está um demonstração simples deste 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)
}
Tens de ligar para o index of com um "O" maiúsculo, como mencionado. Também deve ser notado, que na classe JavaScript é uma palavra reservada, você precisa usar className para obter este atributo de dados. Provavelmente está a falhar porque está a devolver um valor nulo. Você pode fazer o seguinte para obter o seu valor de classe...
var test = elm.getAttribute("className");
//or
var test = elm.className
if (eventString.indexOf("Deleted:") == -1)
// 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 correcta é escrever incorrectamente indexOf
ou o não-padrão String.contains
.
Carregar uma biblioteca externa (especialmente se o código for escrito em JavaScript puro) ou mexer com String.prototype
ou usar uma expressão regular é um pouco exagerado.
Há uma maneira mais elegante e melhor de fazer isso e está usando o operador (BitWise não).
if(~"John".indexOf("J")) {
alert("Found")
}
else {
alert("Not Found");
}
A Bitwise não converte" x " em - (x + 1) assim, se o x se tornar-1 a partir do método indexOf.então ele será convertido em -( -1 + 1) = -0 que é um valor falso .
String.prototype.indexOf()
ou String.prototype.search()
?!
Como outros já mencionaram, as cadeias de JavaScript têm ambos um indexOf
e search
método.
A diferença chave entre ambos, é que indexOf
é apenas para substratos simples, enquanto {[9] } também suporta expressões regulares. Claro, uma vantagem de usar indexOf
é que é mais rápido.
Ver também em JavaScript, Qual é a diferença entre indexOf() e search()?.
Aplicação o seu próprio método String.prototype.contains()
Se quiser adicionar o seu próprio método contains
a cada cadeia de caracteres, a melhor maneira de o fazer seria @zzzbov ' s approach:
if (!String.prototype.contains) {
String.prototype.contains = function (arg) {
return !!~this.indexOf(arg);
};
}
Usarias assim:
'Hello World'.contains('orl');
Implementação de uma biblioteca de utilitários personalizados
Geralmente é desaprovado para adicionar seus próprios métodos personalizados para objetos padrão em JavaScript, por exemplo, porque ele pode quebrar a compatibilidade.
Se realmente quer o seu próprio método contains
e / ou outros métodos de texto personalizados, é melhor criar a sua própria biblioteca de utilitários e adicionar os seus métodos de texto personalizados a essa biblioteca:
var helper = {};
helper.string = {
contains : function (haystack, needle) {
return !!~haystack.indexOf(needle);
},
...
};
Usarias assim:
helper.string.contains('Hello World', 'orl');
Usando uma biblioteca de utilidade pública de terceiros
Se não quiser criar a sua própria biblioteca auxiliar personalizada, existe-é claro-sempre a opção de usar uma biblioteca utilitária de terceiros. Como mencionado por @nachtigall, os mais populares são Lodash e sublinhado.js .
Em Lodash, você poderia usar _.includes()
, que você usa assim:
_.includes('Hello World', 'orl');
Em Underscore.js, você poderia usar _.str.include()
, que você usa assim:
_.str.include('Hello World', 'orl');
Exemplo
var a = "Test String";
if(a.search("ring")!=-1){
//exist
} else {
//not found
}
Solução simples
if (!String.prototype.contains) {
String.prototype.contains= function() {
return String.prototype.indexOf.apply(this, arguments) !== -1;
};
}
Pode ser utilizado da seguinte forma
"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains(" ")//true
"hello world".contains(" ")//false
O ES6 contém String.prototype.includes
.
Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
Código JavaScript para usar o método contains
num array:
<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>
No código indicado, o método contains
determina se o elemento especificado está presente na matriz ou não. Se o elemento especificado está presente no array, ele retorna verdadeiro, caso contrário ele retorna falso.
Para recolher algum tipo de soluções válidas:
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+'');
Uma vez que há uma queixa sobre a utilização do protótipo, e uma vez que o uso de indexOf
torna o seu código menos legível, e uma vez que a regexp é um exagero:
function stringContains(inputString, stringToFind) {
return (inputString.indexOf(stringToFind) != -1);
}
Foi esse o compromisso que acabei por alcançar.
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 componente e o mais simples i. e match()
na corda. Para alcançar o que você está olhando para a frente, faça isso:
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 forma mais fácil é, de facto, utilizar o índice de . Para verificar apenas um texto string
para uma sub-sequência substr
pode usar este método:
string = "asdf";
substr = "as";
alert(string.indexOf(substr) == -1 ? false : true);
Como você queria a função string.contains()
, você pode implementá-la você mesmo assim:
String.prototype.contains = function(test) {
return this.indexOf(test) == -1 ? false : true;
};
Agora pode usar este método ecen shorter para verificar se uma cadeia contém uma substring especial:
string = "asdf";
alert(string.contains("as"));
Aqui está um JSFiddle também.