Est-il une version de JavaScript de la Chaîne.indexOf() qui permet d'expressions régulières?

Les Instances de la String constructeur ont une .recherche() méthode qui accepte une RegExp et renvoie l'index du premier match.

Pour lancer la recherche à partir d'une position particulière (pour simuler le deuxième paramètre de .indexOf()) vous pouvez slice de la première i caractères:

str.slice(i).search(/re/)

Mais cette obtiendrez de l'index dans la chaîne plus courte (après la première partie a été coupé en tranches), de sorte que vous aurez envie d'ajouter ensuite la longueur de la coupé la partie (i) pour le retour de l'indice si ce n'était pas -1. Cela vous donnera l'index dans la chaîne d'origine:

function regexIndexOf(text, re, i) {
    var indexInSuffix = text.slice(i).search(re);
    return indexInSuffix < 0 ? indexInSuffix : indexInSuffix + i;
}

Utilisation:

str.search(regex)

Consultez la documentation ici.

Basé sur BaileyP de réponse. La principale différence est que ces méthodes retournent -1 si le motif ne peut être égalé.

Edit: Merci à Jason Bunting la réponse que j'ai eu une idée. Pourquoi ne pas modifier le .lastIndex propriété de la regex? Bien que cela ne fonctionne que pour les modèles avec l'indicateur global (/g).

Edit: mis à Jour pour passer du cas de test.

String.prototype.regexIndexOf = function(re, startPos) {
    startPos = startPos || 0;

    if (!re.global) {
        var flags = "g" + (re.multiline?"m":"") + (re.ignoreCase?"i":"");
        re = new RegExp(re.source, flags);
    }

    re.lastIndex = startPos;
    var match = re.exec(this);

    if (match) return match.index;
    else return -1;
}

String.prototype.regexLastIndexOf = function(re, startPos) {
    startPos = startPos === undefined ? this.length : startPos;

    if (!re.global) {
        var flags = "g" + (re.multiline?"m":"") + (re.ignoreCase?"i":"");
        re = new RegExp(re.source, flags);
    }

    var lastSuccess = -1;
    for (var pos = 0; pos <= startPos; pos++) {
        re.lastIndex = pos;

        var match = re.exec(this);
        if (!match) break;

        pos = match.index;
        if (pos <= startPos) lastSuccess = pos;
    }

    return lastSuccess;
}

RexExp instances ont un lastIndex bien déjà (si elles sont mondiales) et donc ce que je fais, c'est de la copie de l'expression régulière, en le modifiant légèrement pour les adapter à nos fins, exec-ing sur la chaîne et en regardant la lastIndex. Ce sera inévitablement plus rapide que la boucle sur la chaîne. (Vous avez suffisamment d'exemples de la manière de mettre cela sur la chaîne de prototype, à droite?),

function reIndexOf(reIn, str, startIndex) {
var re = new RegExp(reIn.source, 'g' + (reIn.ignoreCase ? 'i' : '') + (reIn.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
function reLastIndexOf(reIn, str, startIndex) {
var src = /\$$/.test(reIn.source) && !/\\\$$/.test(reIn.source) ? reIn.source : reIn.source + '(?![\\S\\s]*' + reIn.source + ')';
var re = new RegExp(src, 'g' + (reIn.ignoreCase ? 'i' : '') + (reIn.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
reIndexOf(/[abc]/, "tommy can eat");  //Returns 6
reIndexOf(/[abc]/, "tommy can eat", 8);  //Returns 11
reLastIndexOf(/[abc]/, "tommy can eat"); //Returns 11

Vous pouvez également prototype les fonctions sur l'objet RegExp:

RegExp.prototype.indexOf = function(str, startIndex) {
var re = new RegExp(this.source, 'g' + (this.ignoreCase ? 'i' : '') + (this.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
RegExp.prototype.lastIndexOf = function(str, startIndex) {
var src = /\$$/.test(this.source) && !/\\\$$/.test(this.source) ? this.source : this.source + '(?![\\S\\s]*' + this.source + ')';
var re = new RegExp(src, 'g' + (this.ignoreCase ? 'i' : '') + (this.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
/[abc]/.indexOf("tommy can eat");  //Returns 6
/[abc]/.indexOf("tommy can eat", 8);  //Returns 11
/[abc]/.lastIndexOf("tommy can eat"); //Returns 11

Une rapide explication de la façon dont je suis la modification de la RegExp: Pour indexOf je viens de veiller à ce que l'indicateur global est défini. Pour lastIndexOf de je suis à l'aide d'un négatif look-ahead pour trouver la dernière occurrence, à moins que le RegExp était déjà correspondant à la fin de la chaîne.

J'avais besoin d'un regexIndexOf fonctionner aussi pour un tableau, j'ai donc programmé un moi-même. Cependant, je doute, que c'est optimisé, mais je suppose que cela devrait fonctionner correctement.

Array.prototype.regexIndexOf = function (regex, startpos = 0) {
len = this.length;
for(x = startpos; x < len; x++){
if(typeof this[x] != 'undefined' && (''+this[x]).match(regex)){
return x;
}
}
return -1;
}
arr = [];
arr.push(null);
arr.push(NaN);
arr[3] = 7;
arr.push('asdf');
arr.push('qwer');
arr.push(9);
arr.push('...');
console.log(arr);
arr.regexIndexOf(/\d/, 4);

De données avec peu de matches, à l'aide de la chaîne.la recherche est la plus rapide dans les navigateurs. Il re-tranches d'une chaîne à chaque itération :

function lastIndexOfSearch(string, regex, index) {
if(index === 0 || index)
string = string.slice(0, Math.max(0,index));
var idx;
var offset = -1;
while ((idx = string.search(regex)) !== -1) {
offset += idx + 1;
string = string.slice(idx + 1);
}
return offset;
}

Denses de données j'ai fait cela. Il est complexe par rapport à la méthode execute, mais à la densité des données, c'est 2 à 10 fois plus rapide que toutes les autres méthodes que j'ai essayé, et environ 100 fois plus rapide que la solution retenue. Les points principaux sont:

1. Il appelle exec sur l'expression régulière passée en une fois pour vérifier qu'il y a un match ou de la quitter. Je ne ce à l'aide de (?= dans une méthode similaire, mais sur IE vérifier avec exec est considérablement plus rapide.
2. Il construit et met en cache une version modifiée de regex dans le format '(r).(?!.?r)"

3. La nouvelle regex est exécuté et les résultats de soit que exec, ou la première exec, sont renvoyés;

   function lastIndexOfGroupSimple(string, regex, index) {
   if (index === 0 || index) string = string.slice(0, Math.max(0, index + 1));
   regex.lastIndex = 0;
   var lastRegex, index
   flags = 'g' + (regex.multiline ? 'm' : '') + (regex.ignoreCase ? 'i' : ''),
   key = regex.source + '$' + flags,
   match = regex.exec(string);
   if (!match) return -1;
   if (lastIndexOfGroupSimple.cache === undefined) lastIndexOfGroupSimple.cache = {};
   lastRegex = lastIndexOfGroupSimple.cache[key];
   if (!lastRegex)
   lastIndexOfGroupSimple.cache[key] = lastRegex = new RegExp('.*(' + regex.source + ')(?!.*?' + regex.source + ')', flags);
   index = match.index;
   lastRegex.lastIndex = match.index;
   return (match = lastRegex.exec(string)) ? lastRegex.lastIndex - match[1].length : index;
   };

jsPerf de méthodes

Je ne comprends pas le but des tests de haut. Les Situations qui nécessitent une regex sont impossibles à comparer à un appel à indexOf, qui, je pense, est le point de la méthode dans la première place. Pour obtenir le test à passer, il est plus logique d'utiliser 'xxx+(?!x)', que de régler la façon dont les regex itère.

Si vous êtes à la recherche pour un de très simple lastIndex de recherche avec les RegExp et ne se soucient pas si il imite lastIndexOf dans les moindres détails, cela peut attirer votre attention.

J'ai tout simplement d'inverser la chaîne, et de soustraire la première occurence de l'indice de longueur - 1. Il arrive à passer mon test, mais je pense qu'il pourrait se poser un problème de performance avec de longues cordes.

interface String {
reverse(): string;
lastIndex(regex: RegExp): number;
}
String.prototype.reverse = function(this: string) {
return this.split("")
.reverse()
.join("");
};
String.prototype.lastIndex = function(this: string, regex: RegExp) {
const exec = regex.exec(this.reverse());
return exec === null ? -1 : this.length - 1 - exec.index;
};

Bien, que vous êtes simplement à la recherche pour correspondre à la position d'un caractère , regex est peut-être exagéré.

Je présume que tout ce que vous voulez, au lieu de "rechercher le premier de ces ce personnage" , il suffit de trouver la première de ces caractères.

Bien sûr, cela est la réponse la plus simple, mais en fait ce que votre question vise à faire, mais sans la regex partie ( parce que vous n'avez pas de préciser pourquoi précisément ce devait être un regex )

function mIndexOf( str , chars, offset )
{
var first  = -1; 
for( var i = 0; i < chars.length;  i++ )
{
var p = str.indexOf( chars[i] , offset ); 
if( p < first || first === -1 )
{
first = p;
}
}
return first; 
}
String.prototype.mIndexOf = function( chars, offset )
{
return mIndexOf( this, chars, offset ); # I'm really averse to monkey patching.  
};
mIndexOf( "hello world", ['a','o','w'], 0 );
>> 4 
mIndexOf( "hello world", ['a'], 0 );
>> -1 
mIndexOf( "hello world", ['a','o','w'], 4 );
>> 4
mIndexOf( "hello world", ['a','o','w'], 5 );
>> 6
mIndexOf( "hello world", ['a','o','w'], 7 );
>> -1 
mIndexOf( "hello world", ['a','o','w','d'], 7 );
>> 10
mIndexOf( "hello world", ['a','o','w','d'], 10 );
>> 10
mIndexOf( "hello world", ['a','o','w','d'], 11 );
>> -1