javascript contains - Come verificare se una stringa contiene una sottostringa in JavaScript?

Il problema con il tuo codice è che JavaScript fa distinzione tra maiuscole e minuscole. Il tuo metodo di chiamata

indexof()

dovrebbe essere effettivamente

indexOf()

Prova a risolverlo e vedi se questo aiuta:

if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}

var index = haystack.indexOf(needle);

String.prototype.includes() stato introdotto in ES6.

Determina se una stringa può essere trovata all'interno di un'altra stringa, restituendo true o false a seconda dei casi.

Sintassi

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

parametri

searchString

Una stringa da cercare all'interno di questa stringa.

position

La posizione in questa stringa in cui iniziare la ricerca di searchString su 0.

Esempio

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

Questo potrebbe richiedere uno shim ES6 nei browser più vecchi.

Questo pezzo di codice dovrebbe funzionare bene:

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

In ES5

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

In ES6 ci sono tre nuovi metodi: 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

Puoi usare jQuery :contains selettore.

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

Controllalo qui: contains-selector

Un'altra opzione per farlo è:

Puoi usare la funzione match, cioè qualcosa come:

x = "teststring";

if (x.match("test")) {
     // Code
}

match () può funzionare anche con espressioni regolari:

x = "teststring";

if (x.match(/test/i)) {
     // Code
}

Devi chiamare indexOf con una "O" maiuscola come accennato. Va anche notato che nella classe JavaScript è una parola riservata, è necessario utilizzare className per ottenere questo attributo di dati. Il motivo per cui probabilmente non funziona è perché restituisce un valore nullo. Puoi fare quanto segue per ottenere il valore della tua classe ...

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

Dato che la domanda è piuttosto popolare, ho pensato di aggiungere un tocco di modernità al codice.

// 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`);

A proposito, la risposta corretta è errata indexOf o String.contains non standard. Caricare una libreria esterna (specialmente se il codice è scritto in puro JavaScript) o fare scherzi con String.prototype o usare un'espressione regolare è un po 'eccessivo.

String.prototype.indexOf() o String.prototype.search() ?!

Come altri hanno già menzionato, le stringhe JavaScript hanno sia un metodo String.prototype.indexOf un metodo di search .

La differenza chiave tra entrambi è che indexOf è solo per le sottostringhe semplici, mentre la search supporta anche le espressioni regolari. Ovviamente, un indexOf positivo dell'utilizzo di indexOf è che è più veloce.

Vedi anche In JavaScript, qual è la differenza tra indexOf () e search ()? .

Implementazione del proprio metodo String.prototype.contains()

Se vuoi aggiungere il tuo metodo contains a ogni stringa, il modo migliore per farlo sarebbe l'approccio di :

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

Lo useresti in questo modo:

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

Implementazione di una libreria di utility personalizzata

È generalmente disapprovato aggiungere, ad esempio, i propri metodi personalizzati agli oggetti standard in JavaScript, perché potrebbe comportare una rottura della compatibilità.

Se vuoi davvero che il tuo metodo contains e / o altri metodi di stringa personalizzati, è meglio creare la tua libreria di utilità e aggiungere i tuoi metodi di stringa personalizzati a quella libreria:

var helper = {};

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

Lo useresti in questo modo:

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

Utilizzo di una libreria di utilità di terze parti

Se non vuoi creare la tua libreria di helper personalizzata, c'è sempre l'opzione di usare una libreria di utilità di terze parti. Come menzionato da , i più popolari sono Lodash e Underscore.js .

In Lodash, puoi usare _.includes() , che usi in questo modo:

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

In Underscore.js, puoi usare _.str.include() , che usi in questo modo:

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

Soluzione semplice

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

puoi usare nel modo seguente

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

Riferimento MDN

Codice JavaScript per utilizzare il metodo contains in un 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>

Nel codice dato il metodo contains determina se l'elemento specificato è presente nell'array o meno. Se l'elemento specificato è presente nell'array, restituisce true, altrimenti restituisce false.

Poiché esiste un reclamo sull'utilizzo del prototipo e dal momento che l'uso di indexOf rende il tuo codice meno leggibile e poiché regexp è eccessivo:

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

Questo è il compromesso per cui ho finito.

In ES6 , abbiamo qualcosa che include ciò che fa esattamente quello che vuoi: quindi puoi semplicemente fare così:

'str1'.includes('str2');

Anche in ES5 , se lo usi ampiamente, puoi semplicemente aggiungerlo in questo modo:

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