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)) {
}
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)
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); });
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 */ }
regarde par-là...
function matchInArray(stringSearch, arrayExpressions){
var position = String(arrayExpressions).search(stringSearch);
var result = (position > -1) ? true : false
return result;
}
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!!");
}
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