javascript uma Como posso verificar se a string contém substring?




react indexof (11)

Esta questão já tem uma resposta aqui:

Eu tenho um carrinho de compras que exibe opções de produtos em um menu suspenso e, se eles selecionarem "sim", eu quero tornar visíveis alguns outros campos na página.

O problema é que o carrinho de compras também inclui o modificador de preço no texto, que pode ser diferente para cada produto. O código a seguir funciona:

$(document).ready(function() {
    $('select[id="Engraving"]').change(function() {
        var str = $('select[id="Engraving"] option:selected').text();
        if (str == "Yes (+ $6.95)") {
            $('.engraving').show();
        } else {
            $('.engraving').hide();
        }
    });
});

No entanto, eu prefiro usar algo assim, o que não funciona:

$(document).ready(function() {
    $('select[id="Engraving"]').change(function() {
        var str = $('select[id="Engraving"] option:selected').text();
        if (str *= "Yes") {
            $('.engraving').show();
        } else {
            $('.engraving').hide();
        }
    });
});

Eu só quero executar a ação se a opção selecionada contiver a palavra "Sim" e ignorar o modificador de preço.


Retorna o número de vezes que a palavra-chave é incluída na string.

var count = "I have one keyword".match(/keyword/g);
var clean_count = !count ? false : count.length;

Você pode usar este Polyfill no ie e chrome

if (!('contains' in String.prototype)) {
    String.prototype.contains = function (str, startIndex) {
        "use strict";
        return -1 !== String.prototype.indexOf.call(this, str, startIndex);
    };
}

Eu sei que a melhor maneira é str.indexOf(s) !== -1; http://hayageek.com/javascript-string-contains/

Sugiro outra maneira ( str.replace(s1, "") !== str ):

var str = "Hello World!", s1 = "ello", s2 = "elloo";
alert(str.replace(s1, "") !== str);
alert(str.replace(s2, "") !== str);


Nenhum dos acima funcionou para mim como havia espaços em branco, mas isso é o que eu fiz

tr = table.getElementsByTagName("tr");

    for (i = 0; i < tr.length; i++) {
        td = tr[i].getElementsByTagName("td")[0];
        bottab.style.display="none";
        bottab2.style.display="none";
        if (td) {
        var getvar=td.outerText.replace(/\s+/, "") ;

            if (getvar==filter){
                tr[i].style.display = "";
            }else{
                tr[i].style.display = "none";
            }

        }
    }

você pode definir um método de extensão e usá-lo depois.

String.prototype.contains = function(it) 
{ 
   return this.indexOf(it) != -1; 
};

para que você possa usar em sua página em qualquer lugar como:

var str="hello how are you";
str.contains("are");

que retorna verdadeiro .

Consulte a postagem abaixo para obter mais métodos auxiliares de extensão. Métodos auxiliares de Javascript


Outra maneira:

var testStr = "This is a test";

if(testStr.contains("test")){
    alert("String Found");
}

** Testado no Firefox, Safari 6 e Chrome 36 **


O ECMAScript 6 introduz o documentation , anteriormente denominado contains .

Pode ser usado assim:

'foobar'.includes('foo'); // true
'foobar'.includes('baz'); // false

Também aceita um segundo argumento opcional que especifica a posição na qual começar a pesquisar:

'foobar'.includes('foo', 1); // false
'foobar'.includes('bar', 1); // true

Pode ser polyfilled para funcionar em navegadores antigos.


Como isso:

if (str.indexOf("Yes") >= 0)

... ou você pode usar o operador til:

if (~str.indexOf("Yes"))

Isso funciona porque indexOf() retorna -1 se a string não foi encontrada.

Observe que isso faz distinção entre maiúsculas e minúsculas.
Se você quiser uma pesquisa que não diferencia maiúsculas de minúsculas, pode escrever

if (str.toLowerCase().indexOf("yes") >= 0)

Ou,

if (/yes/i.test(str))

Você também pode verificar se a palavra exata está contida em uma string. Por exemplo:

function containsWord(haystack, needle) {
    return (" " + haystack + " ").indexOf(" " + needle + " ") !== -1;
}

Uso:

containsWord("red green blue", "red"); // true
containsWord("red green blue", "green"); // true
containsWord("red green blue", "blue"); // true
containsWord("red green blue", "yellow"); // false

É assim que o jQuery faz seu método hasClass.


É bem tarde para escrever essa resposta, mas pensei em incluí-la de qualquer maneira. String.prototype agora possui um método que pode verificar a substring. Este método faz distinção entre maiúsculas e minúsculas.

var str = 'It was a good date';
console.log(str.includes('good')); // shows true
console.log(str.includes('Good')); // shows false

Para verificar uma substring, a seguinte abordagem pode ser executada:

if (mainString.toLowerCase().includes(substringToCheck.toLowerCase())) {
    // mainString contains substringToCheck
}

Confira a documentation para saber mais.


Se você é capaz de usar bibliotecas, você pode achar que a biblioteca Lo-Dash JS é bastante útil. Nesse caso, vá em frente e verifique _.contains() (substituído por _.includes() partir da v4).

(Nota A convenção Lo-Dash está nomeando o objeto da biblioteca _. Não esqueça de verificar a instalação na mesma página para configurá-lo para o seu projeto.)

_.contains("foo", "oo");     // → true
_.contains("foo", "bar");    // → false
// Equivalent with:
_("foo").contains("oo");     // → true
_("foo").contains("bar");    // → false

No seu caso, vá em frente e use:

_.contains(str, "Yes");
// or:
_(str).contains("Yes");

..que de quem você gosta melhor.





contains