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




find char (25)

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

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

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


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

Como há uma reclamação sobre o uso do protótipo, e como usar o indexOf torna seu código menos legível, e como o regexp é um exagero:

function stringContains(inputString, stringToFind) {
    return (inputString.indexOf(stringToFind) != -1);
}

Esse é o compromisso que acabei indo para.


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.


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.


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.


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

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


var index = haystack.indexOf(needle);

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
}

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

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

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


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


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 .


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

Solução simples

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

você pode usar da seguinte maneira

"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains(" ")//true
"hello world".contains("  ")//false

Referência MDN


Este trecho de código deve funcionar bem:

var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
} 

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


Sempre que você vir a palavra-chave da função dentro de outra função, a função interna terá acesso a variáveis ​​na função externa.

function foo(x) {
  var tmp = 3;

  function bar(y) {
    console.log(x + y + (++tmp)); // will log 16
  }

  bar(10);
}

foo(2);

Isto irá sempre logar 16, porque bar pode acessar o x que foi definido como um argumento para foo , e ele também pode acessar tmp de foo .

Isso é um encerramento. Uma função não precisa retornar para ser chamada de encerramento. Simplesmente acessar variáveis ​​fora do seu escopo léxico imediato cria um fechamento .

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + (++tmp)); // will also log 16
  }
}

var bar = foo(2); // bar is now a closure.
bar(10);

A função acima também registrará 16, porque a bar ainda pode se referir a x e tmp , mesmo que não esteja mais diretamente dentro do escopo.

No entanto, como o tmp ainda está por dentro do fechamento da bar , ele também está sendo incrementado. Ele será incrementado toda vez que você ligar para a bar .

O exemplo mais simples de fechamento é este:

var a = 10;

function test() {
  console.log(a); // will output 10
  console.log(b); // will output 6
}
var b = 6;
test();

Quando uma função JavaScript é invocada, um novo contexto de execução é criado. Juntamente com os argumentos de função e o objeto pai, esse contexto de execução também recebe todas as variáveis ​​declaradas fora dele (no exemplo acima, tanto 'a' quanto 'b').

É possível criar mais de uma função de fechamento, retornando uma lista delas ou configurando-as para variáveis ​​globais. Todos estes se referem ao mesmo x ao mesmo tmp , eles não fazem suas próprias cópias.

Aqui o número x é um número literal. Como com outros literais em JavaScript, quando foo é chamado, o número x é copiado em foo como seu argumento x .

Por outro lado, JavaScript sempre usa referências ao lidar com objetos. Se disser, você chamou foo com um objeto, o fechamento retornará fará referência ao objeto original!

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + tmp);
    x.memb = x.memb ? x.memb + 1 : 1;
    console.log(x.memb);
  }
}

var age = new Number(2);
var bar = foo(age); // bar is now a closure referencing age.
bar(10);

Como esperado, cada chamada para bar(10) irá incrementar x.memb . O que pode não ser esperado, é que x está simplesmente se referindo ao mesmo objeto que a variável age ! Depois de um par de chamadas para bar , age.memb será 2! Essa referência é a base para vazamentos de memória com objetos HTML.





javascript string substring contains string-matching