Nommé capturer les groupes regex en JavaScript?

Autant que je sache, il n'y a pas une telle chose comme l'appelle de capturer les groupes en JavaScript. Quelle est l'alternative pour obtenir des fonctionnalités similaires?

  • Groupes de Capture sont en javascript par numéro ..$1 est le premier groupe capturé, $2, $3 ... jusqu'à 99$, mais il semble que vous voulez quelque chose d'autre, qui n'existe pas
  • vous parlez numérotées de capturer les groupes, l'OP parle nommée capturer les groupes. Ils existent, mais nous voulons savoir si il y a de l'aide pour eux en JS.
  • Il y a un proposition de porter nommé regex en JavaScript, mais c'est peut-être des années avant de voir que, si jamais nous ne.
InformationsquelleAutor mmierins | 2011-03-20
  1. 92

    ECMAScript 2018 introduit nommé capturer les groupes en JavaScript regexes.

    Si vous avez besoin de soutenir les anciens navigateurs, vous pouvez tout faire avec la normale (numérotés) de capturer les groupes que vous pouvez faire avec nommée capturer les groupes, vous avez juste besoin de garder une trace des numéros qui peuvent être lourdes si l'ordre de la capture d'un groupe dans votre regex changements.

    Il y a seulement deux "structurelle" avantages de l'nommé capturer les groupes que je pense:

    1. Dans certains regex saveurs.NET et JGSoft, autant que je sache), vous pouvez utiliser le même nom pour les différents groupes de votre regex (voir ici pour un exemple où cette matière). Mais la plupart des regex saveurs ne prennent pas en charge cette fonctionnalité de toute façon.

    2. Si vous avez besoin de se référer à numérotées de capturer les groupes dans une situation où ils sont entourés par des chiffres, vous pouvez obtenir un problème. Disons que vous voulez ajouter un zéro à un chiffre et donc vouloir remplacer (\d) avec $10. En JavaScript, cela fonctionne (tant que vous avez moins de 10 capture d'un groupe dans votre regex), mais Perl vont penser que vous êtes à la recherche pour la référence arrière nombre 10 la place de numéro 1, suivie par une 0. En Perl, vous pouvez utiliser ${1}0 dans ce cas.

    Autres que les que les, nommée capturer les groupes sont juste "sucre syntaxique". Il permet d'utiliser la capture de groupes uniquement lorsque vous en avez vraiment besoin et l'utilisation de non-capture de groupes (?:...) dans tous les autres cas.

    Le plus gros problème (à mon avis) avec JavaScript, c'est qu'il ne prend pas en charge verbose regexes qui ferait de la création d'lisible, complexe expressions régulières beaucoup plus facile.

    Steve Levithan de XRegExp bibliothèque résout ces problèmes.

    • Beaucoup de saveurs permettre à l'aide de la même capture d'un groupe de nom plusieurs fois dans une expression régulière. Mais seulement .NET et Perl 5.10+ faire ce particulièrement utile en gardant la valeur capturée par le dernier groupe d'un nom qui a participé au match.
    • L'énorme avantage est que vous pouvez simplement changer votre RegExp, pas de nombre variable de la cartographie. Non-capture de groupes de résoudre ce problème, sauf sur un cas: ce que si l'ordre des groupes de modifications? en outre, il est annonying de mettre ce surplus de caractères sur les autres groupes...
    • Le soi-disant sucre syntaxique t aider à adoucir la lisibilité du code!
    • Il comblera les inégalée avec indéfini. Certaines langues habitude, en vous forçant à utiliser nommé.
    • Je pense qu'il y a une autre raison pour nommé capturer les groupes qui m'est très précieuse. Par exemple, si vous souhaitez utiliser une regex pour analyser une date à partir d'une chaîne, vous pouvez écrire une fonction flexible qui prend de la valeur et de la regex. Tant que la regex a nommé capture pour l'année, le mois et la date, vous pouvez courir à travers un tableau d'expressions régulières, avec un minimum de code.
    • les chances sont, le test d'un tableau de regexes sur les dates ne va pas être une bonne pratique, car 01/02/03, ou même 01/02/2003 est ambigu, mais même alors, ne pas avoir à savoir la commande enregistre le code. Certains d'entre nous sont même la création de notre regexes partir de chaînes de caractères.

    InformationsquelleAutor Tim Pietzcker
  2. 60

    Vous pouvez utiliser XRegExp, augmentée, extensible, multi-navigateur et la mise en œuvre d'expressions régulières, y compris le soutien pour la syntaxe supplémentaire, les indicateurs et méthodes:

    • Ajoute de nouvelles regex et le texte de remplacement de la syntaxe, y compris la prise en charge globale de nommé capture.
    • Ajoute deux nouveaux regex drapeaux: s, de faire dot correspondre à tous les personnages (aka dotall ou singleline mode), et x, gratuit pour les-de l'espacement et de commentaires (aka le mode étendu).
    • Fournit une suite de fonctions et de méthodes qui rendent complexes les regex traitement d'une brise.
    • Automatiquement les correctifs les plus couramment rencontrées croix-navigateur incohérences dans les regex comportement et la syntaxe.
    • Vous permet de facilement créer et utiliser des plugins qui ajoutent une nouvelle syntaxe et des drapeaux XRegExp du langage d'expressions régulières.
    InformationsquelleAutor Yunga Palatino
  3. 55

    Une autre solution possible: créer un objet contenant les noms de groupe et les index.

    var regex = new RegExp("(.*) (.*)");
var regexGroups = { FirstName: 1, LastName: 2 };

    Ensuite, utilisez les clés de l'objet de référence les groupes:

    var m = regex.exec("John Smith");
var f = m[regexGroups.FirstName];

    Cela améliore la lisibilité/de la qualité du code en utilisant les résultats de la regex, mais pas à la lisibilité de la regex lui-même.

    InformationsquelleAutor Mr. TA
  4. 50

    Dans l'ES6, vous pouvez utiliser la matrice de déstructuration de l'attraper vos groupes:

    let text = '27 months';
let regex = /(\d+)\s*(days?|months?|years?)/;
let [, count, unit] = text.match(regex) || [];

//count === '27'
//unit === 'months'

    Avis:

    • la première virgule dans la dernière let saute la première valeur du tableau qui en résulte, qui est l'ensemble de la chaîne correspond
    • la || [] après .match() permettra d'éviter une déstructuration de l'erreur quand il n'y a pas de matchs (car .match() sera de retour null)
    • La première virgule est parce que le premier élément du tableau retourné par correspondance est l'expression d'entrée, à droite?
    • String.prototype.match retourne un tableau avec: l'ensemble de la chaîne correspond à la position 0, puis tous les groupes après que. La première virgule dit "ignorer l'élément à la position 0"
    • Mon préféré de réponse ici pour ceux avec transpiling ou ES6+ cibles. Ce n'est pas nécessairement empêcher l'incohérence des erreurs ainsi que nommé indices pourraient si par exemple un réutilisés regex changements, mais je pense que la concision ici facilement fait pour que. J'ai opté pour RegExp.prototype.exec sur String.prototype.match dans des endroits où la chaîne peut être null ou undefined.
    • Ce qu'un ingénieux réponse. Propre, concis & sans bug. Upvoted...
    InformationsquelleAutor bfred.it
  5. 13

    Mise à jour: Il finalement fait en JavaScript (ECMAScript 2018)!

    Nommé capturer les groupes pourraient le faire en JavaScript très bientôt.

    La proposition est à l'étape 3 déjà.

    Un groupe de capture peut être donné un nom à l'intérieur de crochets angulaires à l'aide de la (?<name>...) syntaxe, pour
    tout nom de l'identificateur. L'expression régulière pour un jour peut être
    écrit comme /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u. Chaque nom
    doit être unique et suivez la grammaire pour ECMAScript identifiant-nom.

    Groupes cités peuvent être accessibles à partir des propriétés de l'un des groupes de propriété de
    le résultat de l'expression régulière. Des références numérotées pour les groupes
    également créé, tout comme pour les non-nommé groupes. Par exemple:

    let re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;
let result = re.exec('2015-01-02');
//result.groups.year === '2015';
//result.groups.month === '01';
//result.groups.day === '02';

//result[0] === '2015-01-02';
//result[1] === '2015';
//result[2] === '01';
//result[3] === '02';
    • C'est une étape 4 proposition à ce moment.
    InformationsquelleAutor Forivin
  6. 6

    De nommage capturé groupes fournissent une chose: moins de confusion complexe, avec des expressions régulières.

    Cela dépend vraiment de votre cas d'utilisation, mais peut-être l'impression de votre regex pourrait aider.

    Ou vous pourrait essayer de définir des constantes de vous référer à votre capturé groupes.

    Commentaires pourraient alors également aider à montrer à d'autres personnes qui lisent votre code, ce que vous avez fait.

    Pour le reste je suis d'accord avec Tims réponse.

    InformationsquelleAutor Yashima
  7. 5

    Il y a un node.js bibliothèque appelée nommé regexp que vous pouvez utiliser dans votre node.js projets (dans le navigateur par l'emballage de la bibliothèque avec browserify, ou tout autre emballage de scripts). Cependant, la bibliothèque ne peut pas être utilisé avec des expressions régulières qui contiennent des non-nommé de capturer les groupes.

    Si vous comptez l'ouverture de la capture des accolades dans votre expression régulière, vous pouvez créer un mappage entre nommé capturer les groupes et le numéro de capturer les groupes dans votre regex et peuvent mélanger et assortir librement. Vous avez juste à supprimer les noms de groupe avant d'utiliser les regex. J'ai écrit trois fonctions qui montrent que. Voir ce gist: https://gist.github.com/gbirke/2cc2370135b665eee3ef

    • Voilà qui est étonnant, léger, je vais essayer
    • Est-ce de travailler avec imbriqués les groupes nommés à l'intérieur régulier de groupes complexes, des expressions régulières?
    • Il n'est pas parfait. Bug lors de l': getMap("((a|b(:<foo>c)))"); foo devrait être le troisième groupe, pas la deuxième. /((a|b c)))/g.exec("bc"); ["bc", "bc", "bc", "c"]
    InformationsquelleAutor chiborg
  8. 2

    Si vous ne pouvez pas faire cela avec de la vanille JavaScript, peut-être que vous pouvez utiliser certains Array.prototype fonction comme Array.prototype.reduce à son tour indexé correspond à celles qui sont spécifiées à l'aide de certains magie.

    Évidemment, la solution suivante aura besoin que les matchs se produisent dans l'ordre:

    JS:

    //@text Contains the text to match
//@regex A regular expression object (f.e. /.+/)
//@matchNames An array of literal strings where each item
//            is the name of each group
function namedRegexMatch(text, regex, matchNames) {
  var matches = regex.exec(text);

  return matches.reduce(function(result, match, index) {
    if (index > 0)
      //This substraction is required because we count 
      //match indexes from 1, because 0 is the entire matched string
      result[matchNames[index - 1]] = match;

    return result;
  }, {});
}

var myString = "Hello Alex, I am John";

var namedMatches = namedRegexMatch(
  myString,
  /Hello ([a-z]+), I am ([a-z]+)/i, 
  ["firstPersonName", "secondPersonName"]
);

alert(JSON.stringify(namedMatches));

    • C'est assez cool. Je pense simplement que.. ne serait-il pas possible de créer une regex fonction qui accepte un personnalisé regex? De sorte que vous pourrait aller comme var assocArray = Regex("hello alex, I am dennis", "hello ({hisName}.+), I am ({yourName}.+)");
    • Clairement, vous pouvez aller plus loin et de développer cette fonctionnalité. Il ne serait pas difficile de le faire fonctionner 😀
    • Vous pouvez étendre la RegExp objet par l'ajout d'une fonction à son prototype.
    • Autant que je sache, il n'est pas recommandé d'étendre les objets intégrés
    InformationsquelleAutor Matías Fidemraizer