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



find char (25)

Use uma expressão regular:

RegExp.test(string)

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

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


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


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

Você pode usar o seletor de jQuery :contains .

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

Confira aqui: contains-selector


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


Exemplo

var a  = "Test String";

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

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

No ES5

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

No 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


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

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

No ES6 , temos algo chamado inclui que faz exatamente o que você quer: Então você pode simplesmente fazer assim:

'str1'.includes('str2');

Também no ES5 , se você usá-lo amplamente, você pode simplesmente adicioná-lo assim:

String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}

Outra opção de fazer isso é:

Você pode usar a função 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
}

Você precisa chamar indexOf 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. A razão pela qual provavelmente está falhando é porque está retornando um valor nulo. Você pode fazer o seguinte para obter seu valor de classe ...

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

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.


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.


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.


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

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


var index = haystack.indexOf(needle);

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

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)

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:

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


Outra opção é usar a função strstr() . Algo como:

if (strlen(strstr($haystack,$needle))>0) {
// Needle Found
}

Aponte para observar: A função strstr () faz distinção entre maiúsculas e minúsculas. Para uma pesquisa sem stristr() entre maiúsculas e minúsculas, use a função stristr() .





javascript string substring contains string-matching