Come verificare se una stringa contiene una sottostringa in JavaScript?

Di solito mi aspetterei un metodo String.contains() , ma non sembra esserlo.

Qual è un modo ragionevole per verificare questo?

Ecco un elenco di possibilità attuali:

1. (ES6) includes – vai a rispondere

 var string = "foo", substring = "oo"; string.includes(substring); 

2. ES5 e indexOf precedente

 var string = "foo", substring = "oo"; string.indexOf(substring) !== -1; 

String.prototype.indexOf restituisce la posizione della stringa nell’altra stringa. Se non trovato, restituirà -1 .

3. search – vai a rispondere

 var string = "foo", expr = /oo/; string.search(expr); 

4. include il lodash – vai a rispondere

 var string = "foo", substring = "oo"; _.includes(string, substring); 

5. RegExp – vai a rispondere

 var string = "foo", expr = /oo/; // no quotes here expr.test(string); 

6. Match – vai a rispondere

 var string = "foo", expr = /oo/; string.match(expr); 

I test delle prestazioni stanno dimostrando che indexOf potrebbe essere la scelta migliore, se si tratta di un punto in cui la velocità è importante.

È ansible aggiungere facilmente un metodo contains a String con questa istruzione:

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

Nota: vedere i commenti seguenti per un argomento valido per non utilizzare questo. Il mio consiglio: usa il tuo giudizio.

In alternativa:

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

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

C’è una string.includes in ES6 :

 "potato".includes("to"); > true 

Nota che potrebbe essere necessario caricare es6-shim o simile per farlo funzionare su browser più vecchi.

 require('es6-shim') 
 var index = haystack.indexOf(needle); 

È ansible utilizzare il metodo JavaScript search() .

La syntax è: string.search(regexp)

Restituisce la posizione della partita, o -1 se non viene trovata alcuna corrispondenza.

Guarda gli esempi qui: jsref_search

Non hai bisogno di una syntax di espressioni regolari complicate. Se non si ha familiarità con loro, st.search("title") un semplice st.search("title") . Se vuoi che il tuo test sia insensibile alle maiuscole e minuscole, allora dovresti fare st.search(/title/i) .

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 

Se stavi cercando un’alternativa per scrivere il brutto controllo -1, preferisci invece una ~ tilde.

 if (~haystack.indexOf('needle')) alert('found'); 

Joe Zimmerman – vedrai che usando ~ on -1 lo converte a 0. Il numero 0 è un valore falso, il che significa che verrà valutato come falso quando convertito in booleano. Potrebbe non sembrare una grande intuizione all’inizio, ma ricorda che funzioni come indexOf restituiscono -1 quando la query non viene trovata. Ciò significa che invece di scrivere qualcosa di simile a questo:

 if (someStr.indexOf("a") >= 0) { // Found it } else { // Not Found } 

Ora puoi avere un minor numero di caratteri nel codice in modo da poterlo scrivere in questo modo:

 if (~someStr.indexOf("a")) { // Found it } else { // Not Found } 

Maggiori dettagli qui

Questo pezzo di codice dovrebbe funzionare bene:

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

Un metodo comune per scrivere un metodo contains in JavaScript è:

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

L’operatore di negazione bit a bit ( ~ ) viene utilizzato per trasformare -1 in 0 (falso) e tutti gli altri valori saranno diversi da zero (vero).

Gli operatori di doppia negazione booleana sono usati per convertire il numero in un booleano.

In ES5

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

Invece di usare snippet di codice trovati qui e là sul web, puoi anche usare una libreria ben testata e documentata. Due opzioni che consiglierei:


1a opzione: usa Lodash : ha un metodo includes :

 _.includes('foobar', 'ob'); // → true 

Lodash è la dipendenza della libreria javascript più popolare per npm e ha un sacco di utili metodi di utilità javascript. Quindi per molti progetti lo vorresti comunque 😉


Seconda opzione: Oppure usa Underscore.string : ha un metodo include :

 _.str.include('foobar', 'ob'); // → true 

Ecco la descrizione di Underscore.string, aggiunge solo 9kb ma offre tutti i vantaggi di una libreria ben collaudata e documentata su frammenti di codice copy’n’paste:

Underscore.string è una libreria JavaScript per una comoda manipolazione con le stringhe, estensione per Underscore.js ispirata a Prototype.js, Right.js, Underscore e bellissimo linguaggio Ruby.

Underscore.string offre diverse funzioni utili: capitalizza, pulisci, include, conta, escapeHTML, unescapeHTML, insert, splice, startsWith, endsWith, titleize, trim, truncate e così via.

Nota bene, Underscore.string è influenzato da Underscore.js ma può essere utilizzato senza di esso.


Ultimo non meno: con la versione JavaScript ES6 arriva un metodo incorporato includes :

 'foobar'.includes('ob'); // → true 

La maggior parte dei browser moderni lo supportano già, hanno un occhio sulla tabella di compatibilità ES6 .

Puoi usare jQuery :contains selettore.

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

Controllalo qui: contiene-selector

Usa un’espressione regolare:

RegExp.test(string)

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 } 

.indexOf cercando .indexOf MDN .

indexOf restituirà un indice alla sottostringa corrispondente. L’indice sarà correlato a dove inizia la sottostringa. Se non c’è corrispondenza, viene restituito -1. Ecco una semplice demo di questo concetto:

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

Questo ha funzionato per me. Seleziona per le stringhe che non contengono il termine “Eliminato:”

 if (eventString.indexOf("Deleted:") == -1) 

Devi chiamare indexOf con una “O” maiuscola come accennato. Va anche notato che nella class 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 class …

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

Dato che la domanda è piuttosto popolare, ho pensato di aggiungere un touch 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.

C’è un modo elegante e migliore per farlo e sta usando l’operatore (BitWise NOT).

 if(~"John".indexOf("J")) { alert("Found") } else { alert("Not Found"); } 

Bitwise Not converte “x” in – (x + 1) così, se la x risulta -1 dal metodo indexOf, allora sarà convertita in – (-1 + 1) = -0 che è un valore falsy.

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

Come altri hanno già menzionato, le stringhe JavaScript hanno sia un metodo 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 @zzzzBov :

 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 @nachtigall , 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

Esempio

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

Codice JavaScript per utilizzare il metodo contains in un array:

   

Use of contains() method

[If the specified element is present in the array, it returns true otherwise returns false.]

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.

Per raccogliere qualche tipo di soluzioni valide:

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

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.

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

  

My big string contain apples and oranges

alert($("p:contains(apples)")[0] != undefined); //will alert true if found

Usa il built in e il più semplice ie match() sulla stringa. Per ottenere ciò che stai guardando avanti fai questo:

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

Il modo più semplice è infatti l’utilizzo di indexOf . Per controllare semplicemente una stringa di string per un substr sottostringa è ansible utilizzare questo metodo:

 string = "asdf"; substr = "as"; alert(string.indexOf(substr) == -1 ? false : true); 

Come volevi la funzione string.contains() , puoi implementarla tu stesso in questo modo:

 String.prototype.contains = function(test) { return this.indexOf(test) == -1 ? false : true; }; 

Ora puoi usare questo metodo ecen short per verificare se una stringa contiene una sottostringa speciale:

 string = "asdf"; alert(string.contains("as")); 

Ecco anche un JSFiddle .