J'essaie d'analyser le type de chaîne suivant:

[key:"val" key2:"val2"]

où il y a des paires clé arbitraire: "val" à l'intérieur. Je veux saisir le nom de la clé et la valeur. Pour les curieux, j'essaye d'analyser le format de la base de données de task warrior.

Voici ma chaîne de test:

[description:"aoeu" uuid:"123sth"]

qui vise à souligner que tout peut être dans une clé ou une valeur en dehors de l'espace, aucun espace autour des deux-points et les valeurs sont toujours entre guillemets.

Dans node, voici ma sortie:

[deuteronomy][gatlin][~]$ node
> var re = /^\[(?:(.+?):"(.+?)"\s*)+\]$/g
> re.exec('[description:"aoeu" uuid:"123sth"]');
[ '[description:"aoeu" uuid:"123sth"]',
  'uuid',
  '123sth',
  index: 0,
  input: '[description:"aoeu" uuid:"123sth"]' ]

Mais description:"aoeu"correspond également à ce modèle. Comment puis-je récupérer tous les matchs?

Continuez à appeler re.exec(s)dans une boucle pour obtenir toutes les correspondances:

var re = /\s*([^[:]+):\"([^"]+)"/g;
var s = '[description:"aoeu" uuid:"123sth"]';
var m;

do {
    m = re.exec(s);
    if (m) {
        console.log(m[1], m[2]);
    }
} while (m);

Essayez-le avec ce JSFiddle: https://jsfiddle.net/7yS2V/

str.match(pattern), si patterna l'indicateur global g, retournera toutes les correspondances sous forme de tableau.

Par exemple:

const str = 'All of us except @Emran, @Raju and @Noman was there';
console.log(
  str.match(/@\w*/g)
);
// Will log ["@Emran", "@Raju", "@Noman"]

Pour parcourir toutes les correspondances, vous pouvez utiliser la replacefonction:

var re = /\s*([^[:]+):\"([^"]+)"/g;
var s = '[description:"aoeu" uuid:"123sth"]';

s.replace(re, function(match, g1, g2) { console.log(g1, g2); });

C'est une solution

var s = '[description:"aoeu" uuid:"123sth"]';

var re = /\s*([^[:]+):\"([^"]+)"/g;
var m;
while (m = re.exec(s)) {
  console.log(m[1], m[2]);
}

Ceci est basé sur la réponse de Lawnsea, mais plus courte.

Notez que l'indicateur «g» doit être défini pour déplacer le pointeur interne vers l'avant à travers les appels.

str.match(/regex/g)

renvoie toutes les correspondances sous forme de tableau.

Si, pour une raison mystérieuse, vous avez besoin des informations supplémentaires fournies exec, comme alternative aux réponses précédentes, vous pouvez le faire avec une fonction récursive au lieu d'une boucle comme suit (qui semble également plus cool).

function findMatches(regex, str, matches = []) {
   const res = regex.exec(str)
   res && matches.push(res) && findMatches(regex, str, matches)
   return matches
}

// Usage
const matches = findMatches(/regex/g, str)

comme indiqué dans les commentaires précédents, il est important d'avoir gà la fin de la définition de regex pour faire avancer le pointeur à chaque exécution.

Nous commençons enfin à voir une matchAllfonction intégrée, voir ici pour la description et le tableau de compatibilité . Il semble que depuis mai 2020, Chrome, Edge, Firefox et Node.js (12+) soient pris en charge, mais pas IE, Safari et Opera. On dirait qu'il a été rédigé en décembre 2018, alors laissez-lui un peu de temps pour atteindre tous les navigateurs, mais j'espère qu'il y parviendra.

La matchAllfonction intégrée est agréable car elle renvoie un itérable . Il renvoie également des groupes de capture pour chaque match! Ainsi, vous pouvez faire des choses comme

// get the letters before and after "o"
let matches = "stackoverflow".matchAll(/(\w)o(\w)/g);

for (match of matches) {
    console.log("letter before:" + match[1]);
    console.log("letter after:" + match[2]);
}

arrayOfAllMatches = [...matches]; // you can also turn the iterable into an array

Il semble également que chaque objet de correspondance utilise le même format que match(). Ainsi , chaque objet est un tableau de groupes de correspondance et la capture, avec trois autres propriétés index, input, et groups. Donc ça ressemble à:

[<match>, <group1>, <group2>, ..., index: <match offset>, input: <original string>, groups: <named capture groups>]

Pour plus d'informations, matchAllil existe également une page des développeurs Google . Il existe également des polyfills / cales disponibles.

Basé sur la fonction d'Agus, mais je préfère ne renvoyer que les valeurs de correspondance:

var bob = "> bob <";
function matchAll(str, regex) {
    var res = [];
    var m;
    if (regex.global) {
        while (m = regex.exec(str)) {
            res.push(m[1]);
        }
    } else {
        if (m = regex.exec(str)) {
            res.push(m[1]);
        }
    }
    return res;
}
var Amatch = matchAll(bob, /(&.*?;)/g);
console.log(Amatch);  // yeilds: [>, <]

Les itérables sont plus agréables:

const matches = (text, pattern) => ({
  [Symbol.iterator]: function * () {
    const clone = new RegExp(pattern.source, pattern.flags);
    let match = null;
    do {
      match = clone.exec(text);
      if (match) {
        yield match;
      }
    } while (match);
  }
});

Utilisation en boucle:

for (const match of matches('abcdefabcdef', /ab/g)) {
  console.log(match);
}

Ou si vous voulez un tableau:

[ ...matches('abcdefabcdef', /ab/g) ]

Si vous avez ES9

(Cela signifie que si votre système: Chrome, Node.js, Firefox, etc. prend en charge Ecmascript 2019 ou version ultérieure)

Utilisez le nouveau yourString.matchAll( /your-regex/ ).

Si vous n'avez pas ES9

Si vous avez un système plus ancien, voici une fonction pour copier et coller facilement

function findAll(regexPattern, sourceString) {
    let output = []
    let match
    // make sure the pattern has the global flag
    let regexPatternWithGlobal = RegExp(regexPattern,"g")
    while (match = regexPatternWithGlobal.exec(sourceString)) {
        // get rid of the string copy
        delete match.input
        // store the match data
        output.push(match)
    } 
    return output
}

exemple d'utilisation:

console.log(   findAll(/blah/g,'blah1 blah2')   ) 

les sorties:

[ [ 'blah', index: 0 ], [ 'blah', index: 6 ] ]

Voici ma fonction pour obtenir les correspondances:

function getAllMatches(regex, text) {
    if (regex.constructor !== RegExp) {
        throw new Error('not RegExp');
    }

    var res = [];
    var match = null;

    if (regex.global) {
        while (match = regex.exec(text)) {
            res.push(match);
        }
    }
    else {
        if (match = regex.exec(text)) {
            res.push(match);
        }
    }

    return res;
}

// Example:

var regex = /abc|def|ghi/g;
var res = getAllMatches(regex, 'abcdefghi');

res.forEach(function (item) {
    console.log(item[0]);
});

Depuis ES9, il existe désormais un moyen plus simple et meilleur d'obtenir toutes les correspondances, ainsi que des informations sur les groupes de capture et leur index:

const string = 'Mice like to dice rice';
const regex = /.ice/gu;
for(const match of string.matchAll(regex)) {
    console.log(match);
}

// ["souris", index: 0, entrée: "souris aiment couper le riz en dés", groupes: indéfini]

// ["dés", index: 13, entrée: "les souris aiment couper le riz en dés", groupes: indéfini]

// ["riz", index: 18, entrée: "les souris aiment couper le riz en dés", groupes: indéfini]

Il est actuellement pris en charge dans Chrome, Firefox, Opera. En fonction du moment où vous lisez ceci, consultez ce lien pour voir son support actuel.

Utilisez ceci...

var all_matches = your_string.match(re);
console.log(all_matches)

Il renverra un tableau de toutes les correspondances ... Cela fonctionnerait très bien ... Mais rappelez-vous que cela ne prendra pas en compte les groupes ... Il ne fera que renvoyer les correspondances complètes ...

Je recommanderais définitivement d'utiliser la fonction String.match () et de créer un RegEx pertinent pour cela. Mon exemple est avec une liste de chaînes, ce qui est souvent nécessaire lors de l'analyse des entrées utilisateur à la recherche de mots-clés et de phrases.

    // 1) Define keywords
    var keywords = ['apple', 'orange', 'banana'];

    // 2) Create regex, pass "i" for case-insensitive and "g" for global search
    regex = new RegExp("(" + keywords.join('|') + ")", "ig");
    => /(apple|orange|banana)/gi

    // 3) Match it against any string to get all matches 
    "Test string for ORANGE's or apples were mentioned".match(regex);
    => ["ORANGE", "apple"]

J'espère que cela t'aides!

Cela n'aidera pas vraiment à résoudre votre problème plus complexe, mais je le publie quand même car c'est une solution simple pour les personnes qui ne font pas de recherche globale comme vous.

J'ai simplifié l'expression régulière dans la réponse pour être plus claire (ce n'est pas une solution à votre problème exact).

var re = /^(.+?):"(.+)"$/
var regExResult = re.exec('description:"aoeu"');
var purifiedResult = purify_regex(regExResult);

// We only want the group matches in the array
function purify_regex(reResult){

  // Removes the Regex specific values and clones the array to prevent mutation
  let purifiedArray = [...reResult];

  // Removes the full match value at position 0
  purifiedArray.shift();

  // Returns a pure array without mutating the original regex result
  return purifiedArray;
}

// purifiedResult= ["description", "aoeu"]

Cela semble plus verbeux qu'à cause des commentaires, voici à quoi cela ressemble sans commentaires

var re = /^(.+?):"(.+)"$/
var regExResult = re.exec('description:"aoeu"');
var purifiedResult = purify_regex(regExResult);

function purify_regex(reResult){
  let purifiedArray = [...reResult];
  purifiedArray.shift();
  return purifiedArray;
}

Notez que tous les groupes qui ne correspondent pas seront répertoriés dans le tableau en tant que undefinedvaleurs.

Cette solution utilise l'opérateur de propagation ES6 pour purifier le tableau de valeurs spécifiques à l'expression régulière. Vous devrez exécuter votre code via Babel si vous souhaitez prendre en charge IE11.

Voici une solution en une ligne sans boucle while .

L'ordre est conservé dans la liste résultante.

Les inconvénients potentiels sont

1. Il clone le regex pour chaque match.
2. Le résultat est sous une forme différente des solutions attendues. Vous devrez les traiter une fois de plus.

let re = /\s*([^[:]+):\"([^"]+)"/g
let str = '[description:"aoeu" uuid:"123sth"]'

(str.match(re) || []).map(e => RegExp(re.source, re.flags).exec(e))

[ [ 'description:"aoeu"',
    'description',
    'aoeu',
    index: 0,
    input: 'description:"aoeu"',
    groups: undefined ],
  [ ' uuid:"123sth"',
    'uuid',
    '123sth',
    index: 0,
    input: ' uuid:"123sth"',
    groups: undefined ] ]

Je suppose que s'il y avait des cas extrêmes tels que des espaces supplémentaires ou manquants, cette expression avec moins de limites pourrait également être une option:

^\s*\[\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*\]\s*$

Si vous souhaitez explorer / simplifier / modifier l'expression, cela a été expliqué dans le panneau supérieur droit de regex101.com . Si vous le souhaitez, vous pouvez également regarder dans ce lien , comment il correspondrait à certains exemples d'entrées.

Tester

const regex = /^\s*\[\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*([^\s\r\n:]+)\s*:\s*"([^"]*)"\s*\]\s*$/gm;
const str = `[description:"aoeu" uuid:"123sth"]
[description : "aoeu" uuid: "123sth"]
[ description : "aoeu" uuid: "123sth" ]
 [ description : "aoeu"   uuid : "123sth" ]
 [ description : "aoeu"uuid  : "123sth" ] `;
let m;

while ((m = regex.exec(str)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (m.index === regex.lastIndex) {
        regex.lastIndex++;
    }
    
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Circuit RegEx

jex.im visualise les expressions régulières:

Voici ma réponse:

var str = '[me nombre es] : My name is. [Yo puedo] is the right word'; 

var reg = /\[(.*?)\]/g;

var a = str.match(reg);

a = a.toString().replace(/[\[\]]/g, "").split(','));