uma - verificar se é string javascript




Como verificar se uma string contém uma substring em JavaScript? (20)

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

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


String.prototype.indexOf() ou String.prototype.search() ?

Como outros já mencionaram, as strings JavaScript têm um String.prototype.indexOf e search método de search .

A principal diferença entre ambos é que indexOf é apenas para substrings simples, enquanto search também suporta expressões regulares. Naturalmente, uma vantagem de usar indexOf é que é mais rápido.

Veja também Em JavaScript, qual é a diferença entre indexOf () e search ()? .

Implementando seu próprio método String.prototype.contains()

Se você quiser adicionar seu próprio método contains a cada string, a melhor maneira de fazer isso seria a abordagem do :

if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

Você usaria assim:

'Hello World'.contains('orl');

Implementando uma biblioteca de utilitários customizada

Geralmente é desaprovado adicionar seus próprios métodos personalizados a objetos padrão em JavaScript, por exemplo, porque isso pode quebrar a compatibilidade.

Se você realmente quer que seu próprio método contains e / ou outros métodos de string personalizados, é melhor criar sua própria biblioteca de utilitários e adicionar seus métodos de string personalizados a essa biblioteca:

var helper = {};

helper.string = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    },
    ...
};

Você usaria assim:

helper.string.contains('Hello World', 'orl');

Usando uma biblioteca de utilitários de terceiros

Se você não quiser criar sua própria biblioteca de ajuda personalizada, sempre haverá a opção de usar uma biblioteca de utilitários de terceiros. Como mencionado por , os mais populares são o Lodash e o Underscore.js .

Em Lodash, você poderia usar o _.includes() , que você usa assim:

_.includes('Hello World', 'orl');

Em Underscore.js, você poderia usar o _.str.include() , que você usa assim:

_.str.include('Hello World', 'orl');

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.


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.


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.


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 .


Este trecho de código deve funcionar bem:

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

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.


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)

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

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

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


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 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ê pode usar o seletor de jQuery :contains .

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

Confira aqui: contains-selector


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

String.prototype.includes() foi introduzido no ES6.

Determina se uma string pode ser encontrada dentro de outra string, retornando true ou false conforme apropriado.

Sintaxe

var contained = str.includes(searchString [, position]);  

Parâmetros

searchString

Uma string a ser pesquisada nesta string.

position

A posição nessa string na qual começar a pesquisar por searchString é 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

Isso pode exigir uma correção ES6 em navegadores mais antigos.


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

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.





string-matching