Ich versuche, die folgende Art von Zeichenfolge zu analysieren:

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

wo es beliebige Schlüssel gibt: "val" Paare im Inneren. Ich möchte den Schlüsselnamen und den Wert erfassen. Für diejenigen, die neugierig sind, versuche ich, das Datenbankformat von Task Warrior zu analysieren.

Hier ist meine Testzeichenfolge:

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

Dies soll hervorheben, dass sich alles in einem Schlüssel oder Wert befinden kann, außer Leerzeichen, keine Leerzeichen um die Doppelpunkte und Werte immer in doppelten Anführungszeichen.

Im Knoten ist dies meine Ausgabe:

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

Passt aber description:"aoeu"auch zu diesem Muster. Wie kann ich alle Spiele zurückbekommen?

Rufen Sie re.exec(s)in einer Schleife weiter auf, um alle Übereinstimmungen zu erhalten:

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

Probieren Sie es mit dieser JSFiddle aus: https://jsfiddle.net/7yS2V/

str.match(pattern)Wenn patterndas globale Flag vorhanden ist g, werden alle Übereinstimmungen als Array zurückgegeben.

Beispielsweise:

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

Um alle Übereinstimmungen zu durchlaufen, können Sie die folgende replaceFunktion verwenden:

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

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

Dies ist eine Lösung

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

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

Dies basiert auf der Antwort von Rasen, aber kürzer.

Beachten Sie, dass das Flag "g" gesetzt sein muss, um den internen Zeiger über Aufrufe nach vorne zu bewegen.

str.match(/regex/g)

Gibt alle Übereinstimmungen als Array zurück.

Wenn Sie aus einem mysteriösen Grund die zusätzlichen Informationen benötigen exec, die als Alternative zu früheren Antworten enthalten sind, können Sie dies mit einer rekursiven Funktion anstelle einer Schleife wie folgt tun (was auch cooler aussieht).

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)

Wie bereits in den Kommentaren erwähnt, ist es wichtig, gam Ende der Regex-Definition den Zeiger bei jeder Ausführung nach vorne zu bewegen.

Endlich sehen wir eine eingebaute matchAllFunktion. Hier finden Sie die Beschreibung und die Kompatibilitätstabelle . Es sieht so aus, als ob ab Mai 2020 Chrome, Edge, Firefox und Node.js (12+) unterstützt werden, jedoch nicht IE, Safari und Opera. Scheint, als ob es im Dezember 2018 entworfen wurde Geben Sie ihm also etwas Zeit, um alle Browser zu erreichen, aber ich vertraue darauf, dass es dort ankommt.

Die eingebaute matchAllFunktion ist nett, weil sie eine iterable zurückgibt . Es werden auch Erfassungsgruppen für jedes Spiel zurückgegeben! So können Sie Dinge wie tun

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

Es scheint auch, dass jedes Übereinstimmungsobjekt dasselbe Format wie verwendet match(). Also jedes Objekt ist ein Array der Partie und zwischengespeicherten Gruppen zusammen mit drei zusätzlichen Eigenschaften index, inputund groups. So sieht es aus:

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

Für weitere Informationen matchAllgibt es auch eine Google-Entwicklerseite . Es sind auch Polyfills / Shims erhältlich.

Basierend auf Agus 'Funktion, aber ich bevorzuge es, nur die Übereinstimmungswerte zurückzugeben:

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 sind schöner:

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

Verwendung in einer Schleife:

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

Oder wenn Sie ein Array möchten:

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

Wenn Sie ES9 haben

(Das heißt, wenn Ihr System: Chrome, Node.js, Firefox usw. Ecmascript 2019 oder höher unterstützt)

Verwenden Sie das neueyourString.matchAll( /your-regex/ ) .

Wenn Sie kein ES9 haben

Wenn Sie ein älteres System haben, finden Sie hier eine Funktion zum einfachen Kopieren und Einfügen

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
}

Anwendungsbeispiel:

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

Ausgänge:

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

Hier ist meine Funktion, um die Übereinstimmungen zu erhalten:

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

Seit ES9 gibt es jetzt eine einfachere und bessere Möglichkeit, alle Übereinstimmungen zusammen mit Informationen zu den Erfassungsgruppen und deren Index abzurufen:

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

// ["Mäuse", Index: 0, Eingabe: "Mäuse würfeln gern Reis", Gruppen: undefiniert]

// ["Würfel", Index: 13, Eingabe: "Mäuse würfeln gern Reis", Gruppen: undefiniert]

// ["Reis", Index: 18, Eingabe: "Mäuse würfeln gern Reis", Gruppen: undefiniert]

Es wird derzeit in Chrome, Firefox, Opera unterstützt. Je nachdem, wann Sie dies lesen, überprüfen Sie diesen Link , um die aktuelle Unterstützung anzuzeigen.

Benutze das...

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

Es wird ein Array aller Übereinstimmungen zurückgegeben ... Das würde gut funktionieren ... Aber denken Sie daran, dass keine Gruppen berücksichtigt werden. Es werden nur die vollständigen Übereinstimmungen zurückgegeben ...

Ich würde definitiv empfehlen, die Funktion String.match () zu verwenden und eine relevante RegEx dafür zu erstellen. Mein Beispiel ist eine Liste von Zeichenfolgen, die häufig beim Scannen von Benutzereingaben nach Schlüsselwörtern und Phrasen erforderlich ist.

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

Hoffe das hilft!

Dies wird bei Ihrem komplexeren Problem nicht wirklich helfen, aber ich poste dies trotzdem, da es eine einfache Lösung für Personen ist, die nicht wie Sie eine globale Suche durchführen.

Ich habe den regulären Ausdruck in der Antwort vereinfacht, um klarer zu sein (dies ist keine Lösung für Ihr genaues Problem).

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

Das sieht aufgrund der Kommentare ausführlicher aus als es ist. So sieht es ohne Kommentare aus

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

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

Beachten Sie, dass alle nicht übereinstimmenden Gruppen im Array als aufgeführt werden undefined Werte aufgeführt werden.

Diese Lösung verwendet den ES6-Spread-Operator, um das Array von Regex-spezifischen Werten zu bereinigen. Sie müssen Ihren Code über Babel ausführen, wenn Sie IE11-Unterstützung wünschen.

Hier ist eine einzeilige Lösung ohne while-Schleife .

Die Reihenfolge bleibt in der resultierenden Liste erhalten.

Die möglichen Nachteile sind

1. Es klont die Regex für jedes Match.
2. Das Ergebnis liegt in einer anderen Form als die erwarteten Lösungen vor. Sie müssen sie noch einmal verarbeiten.

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

Ich vermute, wenn es Randfälle wie zusätzliche oder fehlende Leerzeichen geben würde, könnte dieser Ausdruck mit weniger Grenzen auch eine Option sein:

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

Wenn Sie den Ausdruck untersuchen / vereinfachen / ändern möchten, wurde dies im oberen rechten Bereich von regex101.com erläutert . Wenn Sie möchten , können Sie in diesem Link auch sehen , wie es mit einigen Beispieleingaben übereinstimmt.

Prüfung

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

RegEx Circuit

jex.im visualisiert reguläre Ausdrücke:

Hier ist meine Antwort:

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