javascript - correspondance d'une chaîne de caractères avec le tableau d'expressions régulières

Question

Existe-t-il un moyen en JavaScript d'obtenir une valeur booléenne pour une correspondance de la chaîne avec le tableau d'expressions régulières ?

L'exemple serait le suivant (où l'instruction "if" représente ce que j'essaie d'obtenir) :

var thisExpressions = [ '/something/', '/something_else/', '/and_something_else/'];
var thisString = 'else';

if (matchInArray(thisString, thisExpressions)) {

}

Answer 1

En utilisant une approche plus fonctionnelle, vous pouvez implémenter la correspondance avec un one-liner en utilisant un fichier de type fonction de mise en réseau :

ECMAScript 6 :

const regexList = [/apple/, /pear/];
const text = "banana pear";
const isMatch = regexList.some(rx => rx.test(text));

ECMAScript 5 :

var regexList = [/apple/, /pear/];
var text = "banana pear";
var isMatch = regexList.some(function(rx) { return rx.test(text); });

Answer 2

http://jsfiddle.net/9nyhh/1/

var thisExpressions = [/something/, /something_else/, /and_something_else/];
var thisExpressions2 = [/else/, /something_else/, /and_something_else/];
var thisString = 'else';

function matchInArray(string, expressions) {

    var len = expressions.length,
        i = 0;

    for (; i < len; i++) {
        if (string.match(expressions[i])) {
            return true;
        }
    }

    return false;

};

setTimeout(function() {
    console.log(matchInArray(thisString, thisExpressions));
    console.log(matchInArray(thisString, thisExpressions2));
}, 200)

Answer 3

Vous pourriez utiliser .test() qui renvoie une valeur booléenne lorsqu'elle trouve ce que vous cherchez dans une autre chaîne :

var thisExpressions = [ '/something/', '/something_else/', '/and_something_else/'];
var thisString = new RegExp('\\b' + 'else' + '\\b', 'i');
var FoundIt = thisString.test(thisExpressions);  
if (FoundIt) { /* DO STUFF */ }

Answer 4

Regardez par ici...

function matchInArray(stringSearch, arrayExpressions){
    var position = String(arrayExpressions).search(stringSearch);
    var result = (position > -1) ? true : false
    return result;
}

Answer 5

Vous pouvez joindre toutes les expressions régulières en une seule. De cette façon, la chaîne n'est est analysée une seule fois. Même avec une expression régulière un peu plus complexe.

var thisExpressions = [ /something/, /something_else/, /and_something_else/];
var thisString = 'else';

function matchInArray(str, expr) {
    var fullExpr = new RegExp(expr
        .map(x=>x.source) // Just if you need to provide RegExp instances instead of strings or ...
        // .map(x=>x.substring(1, x.length -2)  // ...if you need to provide strings enclosed by "/" like in original question.
        .join("|")
    )
    return str.match(fullExpr);

};

if (matchInArray(thisString, thisExpressions)) {
    console.log ("Match!!");
} 

En fait, même avec cette approche, si vous devez vérifier le même jeu d'expressions contre plusieurs chaînes de caractères, c'est un peu sous-optimal car vous construisez (et compilez) la même expression régulière à chaque appel de la fonction. (et compiler) la même expression régulière à chaque fois que la fonction est appelée.

Une meilleure approche serait d'utiliser un constructeur de fonctions comme celui-ci :

var thisExpressions = [ /something/, /something_else/, /and_something_else/];
var thisString = 'else';

function matchInArray_builder(expr) {
    var fullExpr = new RegExp(expr
        .map(x=>x.source) // Just if you need to provide RegExp instances instead of strings or ...
        // .map(x=>x.substring(1, x.length -2)  // ...if you need to provide strings enclosed by "/" like in original question.
        .join("|")
    )   

    return function (str) {
        return str.match(fullExpr);

    };
};  

var matchInArray = matchInArray_builder(thisExpressions);

if (matchInArray(thisString)) {
    console.log ("Match!!");
}