Tôi đang cố phân tích kiểu chuỗi sau:

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

trong đó có các cặp khóa tùy ý: "val" bên trong. Tôi muốn lấy tên khóa và giá trị. Đối với những người tò mò tôi đang cố phân tích định dạng cơ sở dữ liệu của chiến binh nhiệm vụ.

Đây là chuỗi thử nghiệm của tôi:

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

có nghĩa là để làm nổi bật rằng bất cứ điều gì có thể nằm trong một khóa hoặc giá trị ngoài không gian, không có khoảng trắng xung quanh dấu hai chấm và các giá trị luôn nằm trong dấu ngoặc kép.

Trong nút, đây là đầu ra của tôi:

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

Nhưng description:"aoeu"cũng phù hợp với mô hình này. Làm thế nào tôi có thể lấy lại tất cả các trận đấu?

Tiếp tục gọi re.exec(s)trong một vòng lặp để có được tất cả các trận đấu:

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

Hãy thử nó với JSFiddle này: https://jsfiddle.net/7yS2V/

str.match(pattern), nếu patterncó cờ toàn cầu g, sẽ trả về tất cả các kết quả dưới dạng một mảng.

Ví dụ:

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

Để lặp qua tất cả các trận đấu, bạn có thể sử dụng replacechức năng:

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

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

Đây là một giải pháp

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

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

Điều này dựa trên câu trả lời của lawnsea, nhưng ngắn hơn.

Lưu ý rằng cờ `g 'phải được đặt để di chuyển con trỏ bên trong về phía trước qua các lệnh.

str.match(/regex/g)

trả về tất cả các kết quả khớp như một mảng.

Nếu, vì một lý do bí ẩn nào đó, bạn cần thông tin bổ sung đi kèm exec, như là một thay thế cho các câu trả lời trước đó, bạn có thể thực hiện với chức năng đệ quy thay vì một vòng lặp như sau (cũng có vẻ mát hơn).

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)

như đã nêu trong các ý kiến ​​trước đây, điều quan trọng là phải có gphần cuối của định nghĩa regex để di chuyển con trỏ về phía trước trong mỗi lần thực hiện.

Cuối cùng chúng ta cũng bắt đầu thấy một matchAllhàm tích hợp, xem ở đây để biết mô tả và bảng tương thích . Có vẻ như kể từ tháng 5 năm 2020, Chrome, Edge, Firefox và Node.js (12+) được hỗ trợ nhưng không hỗ trợ IE, Safari và Opera. Có vẻ như nó đã được soạn thảo vào tháng 12 năm 2018 vì vậy hãy cho nó một chút thời gian để tiếp cận tất cả các trình duyệt, nhưng tôi tin rằng nó sẽ đến đó.

Hàm tích hợp matchAlllà tốt vì nó trả về một lần lặp . Nó cũng trả về các nhóm bắt giữ cho mỗi trận đấu! Vì vậy, bạn có thể làm những việc như

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

Dường như mọi đối tượng khớp đều sử dụng định dạng giống như match(). Vì vậy, mỗi đối tượng là một mảng của các nhóm phù hợp và nắm bắt, cùng với ba thuộc tính bổ sung index, inputvà groups. Vì vậy, nó trông giống như:

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

Để biết thêm thông tin về matchAllđó cũng là một trang nhà phát triển Google . Ngoài ra còn có polyfill / shims có sẵn.

Dựa trên chức năng của Agus, nhưng tôi chỉ muốn trả về các giá trị khớp:

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 đẹp hơn:

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

Cách sử dụng trong một vòng lặp:

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

Hoặc nếu bạn muốn một mảng:

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

Nếu bạn có ES9

(Có nghĩa là nếu hệ thống của bạn: Chrome, Node.js, Firefox, v.v. hỗ trợ Ecmascript 2019 trở lên)

Sử dụng cái mới yourString.matchAll( /your-regex/ ).

Nếu bạn không có ES9

Nếu bạn có một hệ thống cũ hơn, đây là một chức năng để sao chép và dán dễ dàng

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
}

sử dụng ví dụ:

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

đầu ra:

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

Đây là chức năng của tôi để có được các trận đấu:

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

Kể từ ES9, giờ đây có một cách đơn giản hơn, tốt hơn để có được tất cả các trận đấu, cùng với thông tin về các nhóm bắt giữ và chỉ mục của chúng:

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

// ["chuột", chỉ mục: 0, đầu vào: "chuột thích xúc xắc gạo", nhóm: không xác định]

// ["xúc xắc", chỉ mục: 13, đầu vào: "chuột thích xúc xắc", nhóm: không xác định]

// ["rice", index: 18, input: "mouse like to dice rice", nhóm: không xác định]

Nó hiện được hỗ trợ trong Chrome, Firefox, Opera. Tùy thuộc vào thời điểm bạn đọc nó, hãy kiểm tra liên kết này để xem hỗ trợ hiện tại của nó.

Dùng cái này...

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

Nó sẽ trả về một loạt tất cả các trận đấu ... Điều đó sẽ hoạt động tốt .... Nhưng hãy nhớ rằng nó sẽ không đưa các nhóm vào tài khoản..Nó sẽ trả lại đầy đủ các trận đấu ...

Tôi chắc chắn sẽ khuyên bạn nên sử dụng hàm String.match () và tạo một RegEx có liên quan cho nó. Ví dụ của tôi là với một danh sách các chuỗi, thường cần thiết khi quét đầu vào của người dùng cho các từ khóa và cụm từ.

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

Hi vọng điêu nay co ich!

Điều này thực sự không giúp ích gì cho vấn đề phức tạp hơn của bạn nhưng dù sao tôi cũng đăng bài này vì đây là một giải pháp đơn giản cho những người không thực hiện tìm kiếm toàn cầu như bạn.

Tôi đã đơn giản hóa biểu thức chính trong câu trả lời để rõ ràng hơn (đây không phải là giải pháp cho vấn đề chính xác của bạn).

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

Điều đó có vẻ dài dòng hơn là vì các bình luận, đây là những gì nó trông giống như không có ý kiến

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

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

Lưu ý rằng bất kỳ nhóm nào không khớp sẽ được liệt kê trong mảng dưới dạng undefinedgiá trị.

Giải pháp này sử dụng toán tử trải ES6 để tinh lọc mảng các giá trị cụ thể regex. Bạn sẽ cần chạy mã của mình thông qua Babel nếu bạn muốn hỗ trợ IE11.

Đây là một giải pháp một dòng mà không có vòng lặp while .

Thứ tự được bảo quản trong danh sách kết quả.

Nhược điểm tiềm năng là

1. Nó nhân bản regex cho mỗi trận đấu.
2. Kết quả là ở một hình thức khác với các giải pháp dự kiến. Bạn sẽ cần xử lý chúng thêm một lần nữa.

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

Tôi đoán là nếu có các trường hợp cạnh như khoảng trắng thừa hoặc thiếu, biểu thức có ít ranh giới hơn cũng có thể là một tùy chọn:

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

Nếu bạn muốn khám phá / đơn giản hóa / sửa đổi biểu thức, nó sẽ được giải thích trên bảng trên cùng bên phải của regex101.com . Nếu bạn muốn, bạn cũng có thể xem trong liên kết này , cách nó phù hợp với một số đầu vào mẫu.

Kiểm tra

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

Mạch RegEx

jex.im hình dung các biểu thức thông thường:

Đây là câu trả lời của tôi:

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