Le moyen le plus rapide de vérifier qu'une chaîne contient une autre sous-chaîne en JavaScript?

Je travaille sur un problème de performances sur JavaScript. Donc, je veux juste demander: quel est le moyen le plus rapide de vérifier si une chaîne contient une autre sous-chaîne (j'ai juste besoin de la valeur booléenne)? Pouvez-vous suggérer votre idée et un exemple de code d'extrait?

Vous avez deux possibilités:

1. Expression régulière :

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

2. indexOf:

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

Les expressions régulières semblent être plus rapides (du moins dans Chrome 10).

Test de performance - Botte de foin courte
Test de performance - Botte de foin longue

On ne peut pas dire avec certitude quelle méthode est la plus rapide. Les différences entre les navigateurs sont énormes. Alors que dans Chrome 10 indexOfsemble être plus rapide, dans Safari 5, indexOfc'est clairement plus lent que toute autre méthode.

Vous devez voir et essayer par vous-même. Cela dépend de vos besoins. Par exemple, une recherche insensible à la casse est beaucoup plus rapide avec les expressions régulières.

Mise à jour 2018:

Juste pour éviter aux gens d'exécuter eux-mêmes les tests, voici les résultats actuels pour la plupart des navigateurs courants, les pourcentages indiquent une augmentation des performances par rapport au résultat suivant le plus rapide (qui varie d'un navigateur à l'autre):

Chrome: indexOf (~ 98% plus rapide) <-- wow
Firefox: RegExp mis en cache (~ 18% plus rapide)
IE11: RegExp mis en cache (~ 10% plus rapide)
Edge: indexOf (~ 18% plus rapide)
Safari: RegExp mis en cache (~ 0.4% plus rapide)

Notez que RegExp mis en cache est: var r = new RegExp('simple'); var c = r.test(str);par opposition à:/simple/.test(str)

Est-ce que ça marche pour toi?

string1.indexOf(string2) >= 0

Edit: Cela peut ne pas être plus rapide qu'un RegExp si la chaîne2 contient des modèles répétés. Sur certains navigateurs, indexOf peut être beaucoup plus lent que RegExp. Voir les commentaires.

Edit 2: RegExp peut être plus rapide que indexOf lorsque les chaînes sont très longues et / ou contiennent des motifs répétés. Voir les commentaires et la réponse de @ Felix.

Le plus rapide

1. (ES6) comprend

    var string = "bonjour",
    substring = "lo";
    string.includes (sous-chaîne);

2. ES5 et plus ancien indexOf

    var string = "bonjour",
    substring = "lo";
    string.indexOf (sous-chaîne)! == -1;

http://jsben.ch/9cwLJ

Dans ES6, la includes()méthode est utilisée pour déterminer si une chaîne peut être trouvée dans une autre chaîne, retournée trueou falseselon le cas.

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

Voici jsperf entre

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

Et

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

Comme le résultat montré dans jsperf, il semble que les deux fonctionnent bien.

J'ai trouvé que l'utilisation d'une simple boucle for, l'itération sur tous les éléments de la chaîne et la comparaison en utilisant sont charAtplus rapides que indexOfou Regex. Le code et la preuve sont disponibles sur JSPerf .

ETA: indexOfet les charAtdeux fonctionnent de manière similaire sur Chrome Mobile selon les données de portée du navigateur répertoriées sur jsperf.com

Pour trouver une chaîne simple, utiliser la méthode indexOf () et utiliser regex est à peu près la même chose: http://jsperf.com/substring - choisissez donc celui qui semble le plus facile à écrire.

J'ai fait un jsben.ch pour vous http://jsben.ch/#/aWxtF ... il semble que indexOf est un peu plus rapide.

C'est un moyen facile d'utiliser la .match()méthode pour enchaîner.

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

Je vous souhaite une bonne journée, monsieur!