Sto cercando di analizzare il seguente tipo di stringa:

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

dove ci sono chiavi arbitrarie: coppie "val" all'interno. Voglio prendere il nome della chiave e il valore. Per i curiosi sto cercando di analizzare il formato del database di task warrior.

Ecco la mia stringa di test:

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

che ha lo scopo di evidenziare che qualsiasi cosa può essere in una chiave o in un valore a parte lo spazio, nessuno spazio attorno ai due punti e che i valori sono sempre tra virgolette.

Nel nodo, questo è il mio output:

[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"]' ]

Ma description:"aoeu"corrisponde anche a questo modello. Come posso recuperare tutte le partite?

Continua a chiamare re.exec(s)in loop per ottenere tutte le partite:

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);

Provalo con questo JSFiddle: https://jsfiddle.net/7yS2V/

str.match(pattern), se patternha il flag globale g, restituirà tutte le partite come un array.

Per esempio:

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

Per scorrere tutte le partite, puoi usare la replacefunzione:

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

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

Questa è una soluzione

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

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

Questo si basa sulla risposta di lawnsea, ma più breve.

Si noti che il flag `g 'deve essere impostato per spostare il puntatore interno in avanti attraverso le invocazioni.

str.match(/regex/g)

restituisce tutte le partite come un array.

Se, per qualche motivo misterioso, hai bisogno delle informazioni aggiuntive fornite exec, in alternativa alle risposte precedenti, potresti farlo con una funzione ricorsiva invece di un ciclo come segue (che sembra anche più interessante).

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)

come affermato nei commenti prima, è importante avere galla fine della definizione regex per spostare il puntatore in avanti in ogni esecuzione.

Stiamo finalmente iniziando a vedere una matchAllfunzione integrata, vedi qui per la descrizione e la tabella di compatibilità . A partire da maggio 2020, Chrome, Edge, Firefox e Node.js (12+) sono supportati ma non IE, Safari e Opera. Sembra che sia stato redatto a dicembre 2018 quindi dagli un po 'di tempo per raggiungere tutti i browser, ma credo che ci arriverà.

La matchAllfunzione integrata è piacevole perché restituisce un iterabile . Restituisce anche gruppi di acquisizione per ogni partita! Quindi puoi fare cose del genere

// 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

Sembra anche che ogni oggetto match usi lo stesso formato di match(). Così ogni oggetto è un array di gruppi partita e cattura, insieme a tre proprietà aggiuntive index, input, e groups. Quindi sembra che:

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

Per ulteriori informazioni su matchAllc'è anche una pagina degli sviluppatori di Google . Ci sono anche polyfill / spessori disponibili.

Basato sulla funzione di Agus, ma preferisco restituire solo i valori di corrispondenza:

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: [>, <]

Iterables sono più belli:

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

Utilizzo in un ciclo:

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

O se vuoi un array:

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

Se hai ES9

(Significa che se il tuo sistema: Chrome, Node.js, Firefox, ecc. Supporta Ecmascript 2019 o successivo)

Usa il nuovo yourString.matchAll( /your-regex/ ).

Se non hai ES9

Se hai un sistema precedente, ecco una funzione per una facile copia e incolla

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
}

esempio di utilizzo:

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

uscite:

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

Ecco la mia funzione per ottenere le partite:

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]);
});

Da ES9, esiste ora un modo più semplice e migliore per ottenere tutte le partite, insieme alle informazioni sui gruppi di acquisizione e sul loro indice:

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

// ["topi", indice: 0, input: "ai topi piace tagliare il riso", gruppi: non definito]

// ["dice", indice: 13, input: "ai topi piace tagliare il riso", gruppi: non definito]

// ["riso", indice: 18, input: "ai topi piace tagliare il riso", gruppi: non definito]

Attualmente è supportato in Chrome, Firefox, Opera. A seconda di quando leggi questo, controlla questo link per vedere il suo attuale supporto.

Usa questo...

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

Restituirà una serie di tutte le partite ... Funzionerebbe perfettamente ... Ma ricorda che non terrà conto dei gruppi ... Restituirà solo le partite complete ...

Consiglio vivamente di utilizzare la funzione String.match () e di creare un RegEx pertinente per questo. Il mio esempio è con un elenco di stringhe, che è spesso necessario durante la scansione degli input dell'utente per parole chiave e frasi.

    // 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"]

Spero che questo ti aiuti!

Questo non aiuterà davvero con il tuo problema più complesso, ma lo sto pubblicando comunque perché è una soluzione semplice per le persone che non stanno effettuando una ricerca globale come te.

Ho semplificato la regex nella risposta per essere più chiari (questa non è una soluzione al tuo esatto problema).

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"]

Sembra più prolisso di quanto non sia a causa dei commenti, questo è quello che sembra senza commenti

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

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

Si noti che tutti i gruppi che non corrispondono verranno elencati nell'array come undefinedvalori.

Questa soluzione utilizza l'operatore spread ES6 per purificare l'array di valori specifici di regex. Sarà necessario eseguire il codice tramite Babel se si desidera il supporto IE11.

Ecco una soluzione a una riga senza un ciclo while .

L'ordine viene conservato nell'elenco risultante.

I potenziali aspetti negativi sono

1. Clona la regex per ogni partita.
2. Il risultato è in una forma diversa rispetto alle soluzioni previste. Dovrai elaborarli ancora una volta.

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 ] ]

La mia ipotesi è che se ci fossero casi limite come spazi extra o mancanti, questa espressione con meno confini potrebbe anche essere un'opzione:

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

Se desideri esplorare / semplificare / modificare l'espressione, è stata spiegata nel pannello in alto a destra di regex101.com . Se lo desideri, puoi anche guardare in questo link , come corrisponderebbe ad alcuni input di esempio.

Test

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}`);
    });
}

Circuito RegEx

jex.im visualizza le espressioni regolari:

Ecco la mia risposta:

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(','));