Il modo più veloce per controllare una stringa contiene un'altra sottostringa in JavaScript?

Sto lavorando con un problema di prestazioni su JavaScript. Quindi voglio solo chiedere: qual è il modo più veloce per verificare se una stringa contiene un'altra sottostringa (ho solo bisogno del valore booleano)? Potresti suggerire la tua idea e un esempio di codice dello snippet?

Hai due possibilità:

1. Espressione regolare :

   (new RegExp('word')).test(str)
   // or
   /word/.test(str)

2. indexOf:

   str.indexOf('word') !== -1

Le espressioni regolari sembrano essere più veloci (almeno in Chrome 10).

Test delle prestazioni - pagliaio corto
Test delle prestazioni - pagliaio lungo

Non si può dire con certezza quale metodo sia più veloce. Le differenze tra i browser sono enormi. Mentre in Chrome 10 indexOfsembra essere più veloce, in Safari 5 indexOfè chiaramente più lento di qualsiasi altro metodo.

Devi vedere e provare per te stesso. Dipende dai tuoi bisogni. Ad esempio, una ricerca senza distinzione tra maiuscole e minuscole è molto più veloce con le espressioni regolari.

Aggiornamento 2018:

Solo per salvare le persone dall'esecuzione dei test stessi, ecco i risultati attuali per i browser più comuni, le percentuali indicano un aumento delle prestazioni rispetto al successivo risultato più veloce (che varia tra i browser):

Chrome: indexOf (~ 98% più veloce) <-- wow
Firefox: cache RegExp (~ 18% più veloce)
IE11: cache RegExp (~ 10% più veloce)
Bordo: indexOf (~ 18% più veloce)
Safari: cache RegExp (~ 0,4% più veloce)

Si noti che RegExp memorizzato nella cache è: var r = new RegExp('simple'); var c = r.test(str);al contrario di:/simple/.test(str)

Per te funziona?

string1.indexOf(string2) >= 0

Modifica: potrebbe non essere più veloce di un RegExp se string2 contiene pattern ripetuti. Su alcuni browser, indexOf potrebbe essere molto più lento di RegExp. Vedi commenti

Modifica 2: RegExp potrebbe essere più veloce di indexOf quando le stringhe sono molto lunghe e / o contengono schemi ripetuti. Vedi i commenti e la risposta di @Felix.

Il più veloce

1. (ES6) include

    var string = "ciao",
    sottostringa = "lo";
    string.includes (substring);

2. ES5 e indice precedente

    var string = "ciao",
    sottostringa = "lo";
    string.indexOf (sottostringa)! == -1;

http://jsben.ch/9cwLJ

In ES6, il includes()metodo viene utilizzato per determinare se una stringa può essere trovata all'interno di un'altra stringa, restituendo trueo falsecome appropriato.

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('nonexistent')); // false

Ecco jsperf in mezzo

var ret = str.includes('one');

E

var ret = (str.indexOf('one') !== -1);

Come il risultato mostrato in jsperf, sembra che entrambi funzionino bene.

Ho scoperto che l'utilizzo di un semplice ciclo for, l'iterazione su tutti gli elementi nella stringa e il confronto con l'operare si charAtesegue più velocemente di indexOfo Regex. Il codice e la prova sono disponibili su JSPerf .

ETA: indexOfed charAtentrambi funzionano allo stesso modo in modo terribile su Chrome Mobile secondo i dati di Browser Scope elencati su jsperf.com

Per trovare una stringa semplice, usare il metodo indexOf () e usare regex è praticamente lo stesso: http://jsperf.com/substring - quindi scegli quello che sembra più facile da scrivere.

Ho creato un jsben.ch per te http://jsben.ch/#/aWxtF ... sembra che indexOf sia un po 'più veloce.

È un modo semplice per utilizzare il .match()metodo per la stringa.

var re = /(AND|OR|MAYBE)/;
var str = "IT'S MAYBE BETTER WAY TO USE .MATCH() METHOD TO STRING";
console.log('Do we found something?', Boolean(str.match(re)));

Ti auguro una buona giornata, signore!