Existe-t-il une version de String.indexOf() de JavaScript qui permet d'utiliser des expressions régulières ?

Question

En javascript, existe-t-il un équivalent de String.indexOf() qui prend une expression régulière au lieu d'une chaîne pour le premier paramètre tout en autorisant un second paramètre ?

J'ai besoin de faire quelque chose comme

str.indexOf(/[abc]/ , i);

et

str.lastIndexOf(/[abc]/ , i);

Alors que String.search() prend un regexp comme paramètre, il ne me permet pas de spécifier un second argument !

Editar:
Cela s'est avéré plus difficile que je ne le pensais au départ, j'ai donc écrit une petite fonction de test pour tester toutes les solutions proposées... elle suppose que regexIndexOf et regexLastIndexOf ont été ajoutés à l'objet String.

function test (str) {
    var i = str.length +2;
    while (i--) {
        if (str.indexOf('a',i) != str.regexIndexOf(/a/,i)) 
            alert (['failed regexIndexOf ' , str,i , str.indexOf('a',i) , str.regexIndexOf(/a/,i)]) ;
        if (str.lastIndexOf('a',i) != str.regexLastIndexOf(/a/,i) ) 
            alert (['failed regexLastIndexOf ' , str,i,str.lastIndexOf('a',i) , str.regexLastIndexOf(/a/,i)]) ;
    }
}

et je teste comme suit pour m'assurer qu'au moins pour une regexp d'un caractère, le résultat est le même que si nous utilisions indexOf

//Chercher le a parmi les xes
test('xxx') ;
test('axx') ;
test('xax') ;
test('xxa') ;
test('axa') ;
test('xaa') ;
test('aax') ;
test('aaa') ;

Answer 1

Instances de la String ont un .search() méthode qui accepte un RegExp et renvoie l'index de la première correspondance.

Pour lancer la recherche à partir d'une position particulière (en simulant le deuxième paramètre de l'option .indexOf() ) vous pouvez slice du premier i des personnages :

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

Mais cela donnera l'index de la chaîne la plus courte (après que la première partie ait été coupée). Vous devrez donc ajouter la longueur de la partie coupée ( i ) à l'index retourné s'il ne l'était pas. -1 . Vous obtiendrez ainsi l'indice dans la chaîne de caractères d'origine :

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

Answer 2

En combinant quelques-unes des approches déjà mentionnées (l'indexOf est évidemment assez simple), je pense que ce sont les fonctions qui feront l'affaire :

function regexIndexOf(string, regex, startpos) {
    var indexOf = string.substring(startpos || 0).search(regex);
    return (indexOf >= 0) ? (indexOf + (startpos || 0)) : indexOf;
}

function regexLastIndexOf(string, regex, startpos) {
    regex = (regex.global) ? regex : new RegExp(regex.source, "g" + (regex.ignoreCase ? "i" : "") + (regex.multiLine ? "m" : ""));
    if(typeof (startpos) == "undefined") {
        startpos = string.length;
    } else if(startpos < 0) {
        startpos = 0;
    }
    var stringToWorkWith = string.substring(0, startpos + 1);
    var lastIndexOf = -1;
    var nextStop = 0;
    while((result = regex.exec(stringToWorkWith)) != null) {
        lastIndexOf = result.index;
        regex.lastIndex = ++nextStop;
    }
    return lastIndexOf;
}

---

UPDATE : Edited regexLastIndexOf() de sorte qu'il semble imiter lastIndexOf() maintenant. Veuillez me faire savoir si cela échoue encore et dans quelles circonstances.

---

UPDATE : Passe tous les tests trouvés dans les commentaires de cette page, et les miens. Bien sûr, cela ne veut pas dire qu'il est à l'épreuve des balles. Tout commentaire est apprécié.

Answer 3

J'ai une version courte pour vous. Elle fonctionne bien pour moi !

var match      = str.match(/[abc]/gi);
var firstIndex = str.indexOf(match[0]);
var lastIndex  = str.lastIndexOf(match[match.length-1]);

Et si vous voulez une version prototype :

String.prototype.indexOfRegex = function(regex){
  var match = this.match(regex);
  return match ? this.indexOf(match[0]) : -1;
}

String.prototype.lastIndexOfRegex = function(regex){
  var match = this.match(regex);
  return match ? this.lastIndexOf(match[match.length-1]) : -1;
}

EDITAR : si vous voulez ajouter le support pour fromIndex

String.prototype.indexOfRegex = function(regex, fromIndex){
  var str = fromIndex ? this.substring(fromIndex) : this;
  var match = str.match(regex);
  return match ? str.indexOf(match[0]) + fromIndex : -1;
}

String.prototype.lastIndexOfRegex = function(regex, fromIndex){
  var str = fromIndex ? this.substring(0, fromIndex) : this;
  var match = str.match(regex);
  return match ? str.lastIndexOf(match[match.length-1]) : -1;
}

Pour l'utiliser, c'est aussi simple que cela :

var firstIndex = str.indexOfRegex(/[abc]/gi);
var lastIndex  = str.lastIndexOfRegex(/[abc]/gi);

Answer 4

D'après la réponse de BaileyP. La principale différence est que ces méthodes renvoient -1 si le motif ne peut pas être trouvé.

Editar: Grâce à la réponse de Jason Bunting, j'ai eu une idée. Pourquoi ne pas modifier le .lastIndex de la regex ? Bien que cela ne fonctionne que pour les modèles avec le drapeau global ( /g ).

Editar: Mis à jour pour passer les test-cases.

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

Answer 5

Ce n'est pas le cas à l'origine, mais vous pouvez certainement ajouter cette fonctionnalité.

<script type="text/javascript">

String.prototype.regexIndexOf = function( pattern, startIndex )
{
    startIndex = startIndex || 0;
    var searchResult = this.substr( startIndex ).search( pattern );
    return ( -1 === searchResult ) ? -1 : searchResult + startIndex;
}

String.prototype.regexLastIndexOf = function( pattern, startIndex )
{
    startIndex = startIndex === undefined ? this.length : startIndex;
    var searchResult = this.substr( 0, startIndex ).reverse().regexIndexOf( pattern, 0 );
    return ( -1 === searchResult ) ? -1 : this.length - ++searchResult;
}

String.prototype.reverse = function()
{
    return this.split('').reverse().join('');
}

// Indexes 0123456789
var str = 'caabbccdda';

alert( [
        str.regexIndexOf( /[cd]/, 4 )
    ,   str.regexLastIndexOf( /[cd]/, 4 )
    ,   str.regexIndexOf( /[yz]/, 4 )
    ,   str.regexLastIndexOf( /[yz]/, 4 )
    ,   str.lastIndexOf( 'd', 4 )
    ,   str.regexLastIndexOf( /d/, 4 )
    ,   str.lastIndexOf( 'd' )
    ,   str.regexLastIndexOf( /d/ )
    ]
);

</script>

Je n'ai pas entièrement testé ces méthodes, mais elles semblent fonctionner jusqu'à présent.