substring contains Come verificare se una stringa contiene una sottostringa in JavaScript?



15 Answers

È possibile 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; }; }
javascript array contains

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

Qual è un modo ragionevole per verificare questo?




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



È possibile utilizzare il metodo JavaScript search() .

La sintassi è: 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 sintassi 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) .




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




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.




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 .







.indexOf cercando .indexOf String.prototype.indexOf .

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)



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.




Esempio

var a  = "Test String";

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






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




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



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



Related