web-dev-qa-db-fra.com

javascript - associe l'expression régulière au tableau d'éléments

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 (où la déclaration 'if' représente ce que j'essaie de réaliser):

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

if (matchInArray(thisString, thisExpressions)) {

}
javascriptarraysexpression
32
user398341

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)​
13
GillesC

En utilisant une approche plus fonctionnelle, vous pouvez implémenter la correspondance avec une ligne en utilisant une fonction array :

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); });
50
andersh

Vous pouvez utiliser .test () qui retourne une valeur booléenne quand est-ce que vous trouvez 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 */ }
5
Likwid_T

regarde par-là...

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

Vous pouvez joindre toutes les expressions régulières en une seule. De cette façon, la chaîne n'est scannée qu'une 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 contrôler le même ensemble d'expressions Avec plusieurs chaînes, il s'agit de quelques sous-optimaux, car vous générez (Et compilez) la même expression régulière chaque fois que la fonction est appelée.

Une meilleure approche consisterait à 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!!");
}
1
bitifet
let expressions = [ '/something/', '/something_else/', '/and_something_else/'];

let str = 'else';

voici le chèque pour les expressions suivantes:

if( expressions.find(expression => expression.includes(str) ) ) {

}

utilisation de la méthode Array .find () pour parcourir un tableau et .include pour vérifier la sous-chaîne 

0
Mubeen Khan