Come verificare se una stringa contiene una sottostringa in JavaScript?



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

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

Qual è un modo ragionevole per verificare questo?




Il modo più semplice è infatti l'utilizzo di indexOf . Per controllare semplicemente una stringa di string per un substr sottostringa è possibile 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 .




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






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.




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




Puoi usare jQuery :contains selettore.

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

Controllalo qui: contains-selector




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




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




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




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.




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.




var index = haystack.indexOf(needle);



È 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) .




Related