Dize aşağıdaki tür ayrıştırmak çalışıyorum:

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

burada keyfi anahtar vardır: içeride "val" çiftleri. Anahtar adını ve değerini almak istiyorum. Merak edenler için görev savaşçısının veritabanı formatını ayrıştırmaya çalışıyorum.

İşte benim test dizesi:

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

bu, herhangi bir şeyin boşluktan başka bir anahtar veya değerde olabileceğini, iki nokta üst üste çevresinde boşluk olmadığını ve değerlerin her zaman çift tırnak içinde olduğunu vurgulamak içindir.

Düğümde, bu benim çıktı:

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

Ancak description:"aoeu"bu modelle de eşleşir. Tüm maçları nasıl geri alabilirim?

re.exec(s)Tüm eşleşmeleri elde etmek için bir döngüde aramaya devam et :

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

Bu JSFiddle ile deneyin: https://jsfiddle.net/7yS2V/

str.match(pattern), patterngenel bayrak varsa gtüm eşleşmeleri dizi olarak döndürür.

Örneğin:

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

Tüm eşleşmeler arasında geçiş yapmak için şu replaceişlevi kullanabilirsiniz :

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

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

Bu bir çözüm

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

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

Bu, lawnsea'nın cevabına dayanır, ancak daha kısadır.

Dahili işaretçiyi çağrılar arasında ileriye taşımak için `g 'bayrağının ayarlanması gerektiğine dikkat edin.

str.match(/regex/g)

tüm eşleşmeleri dizi olarak döndürür.

Gizemli bir nedenden ötürü, ek bilgilere ihtiyacınız varsa, execönceki yanıtlara alternatif olarak, aşağıdaki gibi bir döngü yerine özyinelemeli bir işlevle yapabilirsiniz (bu da daha havalı görünür).

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)

önceki yorumlarda belirtildiği gibi g, her yürütmede işaretçiyi ileriye taşımak için normal ifade tanımının sonunda olması önemlidir .

Sonunda yerleşik bir matchAllişlev görmeye başlıyoruz , açıklama ve uyumluluk tablosu için buraya bakın . Mayıs 2020 itibariyle Chrome, Edge, Firefox ve Node.js (12+) destekleniyor, ancak IE, Safari ve Opera desteklenmiyor. Aralık 2018'de hazırlanmış gibi görünüyor, bu yüzden tüm tarayıcılara ulaşmak için biraz zaman verin, ancak oraya ulaşacağına inanıyorum.

Yerleşik matchAllbir döndürdüğü için işlev güzel iterable . Ayrıca her maç için yakalama grupları döndürür! Yani böyle şeyler yapabilirsiniz

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

Ayrıca, her eşleşme nesnesiyle aynı biçimi kullanıyor gibi görünüyor match(). Bu nedenle, her bir amacı, üç ek özellikleri ile birlikte eşleme ve yakalama grupları bir dizi olduğu index, inputve groups. Yani şöyle görünüyor:

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

Daha fazla bilgi için ilgili matchAllde bir var Google geliştiricileri sayfa . Ayrıca çoklu dolgular / şimler de mevcuttur.

Agus işlevine dayanarak, sadece eşleşme değerlerini döndürmeyi tercih ederim:

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

Yinelenebilir güzel:

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

Bir döngüde kullanım:

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

Veya bir dizi istiyorsanız:

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

ES9'unuz varsa

(Sisteminiz: Chrome, Node.js, Firefox, vb. Ecmascript 2019 veya daha yenisini destekliyorsa)

Yeni olanı kullanın yourString.matchAll( /your-regex/ ).

ES9'unuz yoksa

Daha eski bir sisteminiz varsa, kolay kopyalama ve yapıştırma işlevi

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
}

örnek kullanım:

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

çıktılar:

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

İşte maçları almak için benim fonksiyonu:

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

ES9'dan bu yana, artık tüm maçları elde etmenin, yakalama grupları ve dizinleri hakkındaki bilgilerle birlikte daha basit ve daha iyi bir yolu var:

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

// ["fareler", dizin: 0, giriş: "fareler pirinci zarlamak ister", gruplar: tanımsız]

// ["zar", dizin: 13, giriş: "pirinç zar atmak gibi fareler", gruplar: tanımsız]

// ["pirinç", dizin: 18, giriş: "pirinç zar atmak gibi fareler", gruplar: tanımsız]

Şu anda Chrome, Firefox, Opera'da desteklenmektedir. Bunu ne zaman okuduğunuza bağlı olarak , mevcut desteğini görmek için bu bağlantıyı kontrol edin .

Bunu kullan...

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

Tüm maçlar bir dizi dönecektir ... Bu gayet iyi çalışır .... Ama unutmayın gruplar hesaba katmayacak ... Sadece tam maçlar dönecektir ...

Kesinlikle String.match () işlevini kullanarak ve bunun için ilgili bir RegEx oluşturma tavsiye ederim. Örneğim, anahtar kelimeler ve kelime öbekleri için kullanıcı girişlerini tararken gerekli olan dizelerin bir listesidir.

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

Bu yardımcı olur umarım!

Bu gerçekten daha karmaşık sorununuza yardımcı olmayacak, ancak bunu zaten gönderiyorum çünkü sizin gibi küresel bir arama yapmayan insanlar için basit bir çözüm.

Daha net olmak için cevaptaki regex'i basitleştirdim (bu, tam sorununuza bir çözüm değildir).

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

Bu yorumlar nedeniyle olduğundan daha ayrıntılı görünüyor, yorum yapmadan böyle görünüyor

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

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

Eşleşmeyen tüm grupların dizide undefineddeğerler olarak listeleneceğini unutmayın .

Bu çözüm, regex'e özgü değerler dizisini saflaştırmak için ES6 forma operatörünü kullanır. IE11 desteği istiyorsanız kodunuzu Babel üzerinden çalıştırmanız gerekecektir .

Burada while döngüsü olmayan tek satırlık bir çözüm var .

Sipariş, sonuç listesinde korunur.

Potansiyel dezavantajları

1. Her maç için normal ifadeyi klonlar.
2. Sonuç, beklenen çözümlerden farklı bir formda. Onları bir kez daha işlemeniz gerekecek.

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

Benim tahminim, ekstra veya eksik boşluklar gibi kenar durumlar olacaksa, daha az sınırları olan bu ifade de bir seçenek olabilir:

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

İfadeyi keşfetmek / basitleştirmek / değiştirmek isterseniz, ifade regex101.com'un sağ üst panelinde açıklanmıştır . İsterseniz, bu bağlantıda bazı örnek girdilerle nasıl eşleşeceğini de izleyebilirsiniz .

Ölçek

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 Devresi

jex.im düzenli ifadeleri görselleştirir:

İşte cevabım:

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