tìm các cụm từ biểu thức chính quy trong một chuỗi mã javascript

Question

Tôi đang thực hiện phân tích cú pháp thô của mã javascript, với javascript. Tôi sẽ tiết lộ chi tiết của lý do tại sao Tôi cần làm điều này, nhưng đủ để nói rằng tôi không muốn tích hợp một đoạn mã thư viện khổng lồ, vì nó không cần thiết cho mục đích của tôi và điều quan trọng là tôi giữ điều này rất nhẹ và tương đối đơn giản. Vì vậy, xin vui lòng không đề nghị tôi sử dụng JsLint hoặc bất cứ điều gì như thế. Nếu câu trả lời là nhiều mã hơn bạn có thể dán vào câu trả lời của bạn, nó có thể nhiều hơn tôi muốn.

Mã của tôi hiện có thể thực hiện tốt công việc phát hiện các phần và nhận xét được trích dẫn, sau đó đối sánh dấu ngoặc nhọn và dấu ngoặc đơn (đảm bảo không bị nhầm lẫn bởi dấu ngoặc kép và nhận xét hoặc thoát trong dấu ngoặc kép). . Đây là tất cả những gì tôi cần để làm, và nó thực hiện tốt ... với một ngoại lệ:

Nó có thể bị nhầm lẫn bởi các biểu thức chính quy. Vì vậy, tôi hy vọng cho một số trợ giúp với phát hiện literals biểu thức chính quy trong một chuỗi javascript, vì vậy tôi có thể xử lý chúng một cách thích hợp.

Something như thế này:

function getRegExpLiterals (stringOfJavascriptCode) { 
    var output = []; 
    // todo! 
    return output; 
} 

var jsString = "var regexp1 = /abcd/g, regexp1 = /efg/;" 
console.log (getRegExpLiterals (jsString)); 

// should print: 
// [{startIndex: 13, length: 7}, {startIndex: 32, length: 5}] 

Answer 1

es5-lexer là một lexer JS sử dụng để phân tích rất chính xác để phân biệt biểu thức thông thường trong mã JS từ biểu thức chia, và cũng cung cấp một sự chuyển đổi mức thẻ mà bạn có thể sử dụng để làm chắc chắn rằng chương trình kết quả sẽ được diễn giải theo cùng một cách bởi một trình phân tích cú pháp JS đầy đủ như bởi trình lexer.

Bit quyết định xem một / bắt đầu một biểu thức chính quy được trong guess_is_regexp.js và các bài kiểm tra bắt đầu từ scanner_test.js line 401

var REGEXP_PRECEDER_TOKEN_RE = new RegExp(
    "^(?:" // Match the whole tokens below 
    + "break" 
    + "|case" 
    + "|continue" 
    + "|delete" 
    + "|do" 
    + "|else" 
    + "|finally" 
    + "|in" 
    + "|instanceof" 
    + "|return" 
    + "|throw" 
    + "|try" 
    + "|typeof" 
    + "|void" 
    // Binary operators which cannot be followed by a division operator. 
    + "|[+]" // Match + but not ++. += is handled below. 
    + "|-" // Match - but not --. -= is handled below. 
    + "|[.]" // Match . but not a number with a trailing decimal. 
    + "|[/]" // Match /, but not a regexp. /= is handled below. 
    + "|," // Second binary operand cannot start a division. 
    + "|[*]" // Ditto binary operand. 
    + ")$" 
    // Or match a token that ends with one of the characters below to match 
    // a variety of punctuation tokens. 
    // Some of the single char tokens could go above, but putting them below 
    // allows closure-compiler's regex optimizer to do a better job. 
    // The right column explains why the terminal character to the left can only 
    // precede a regexp. 
    + "|[" 
    + "!" // !   prefix operator operand cannot start with a division 
    + "%" // %   second binary operand cannot start with a division 
    + "&" // &, &&  ditto binary operand 
    + "(" // (   expression cannot start with a division 
    + ":" // :   property value, labelled statement, and operand of ?: 
      //    cannot start with a division 
    + ";" // ;   statement & for condition cannot start with division 
    + "<" // <, <<, << ditto binary operand 
    // !=, !==, %=, &&=, &=, *=, +=, -=, /=, <<=, <=, =, ==, ===, >=, >>=, >>>=, 
    // ^=, |=, ||= 
    // All are binary operands (assignment ops or comparisons) whose right 
    // operand cannot start with a division operator 
    + "=" 
    + ">" // >, >>, >>> ditto binary operand 
    + "?" // ?   expression in ?: cannot start with a division operator 
    + "[" // [   first array value & key expression cannot start with 
      //    a division 
    + "^" //^   ditto binary operand 
    + "{" // {   statement in block and object property key cannot start 
      //    with a division 
    + "|" // |, ||  ditto binary operand 
    + "}" // }   PROBLEMATIC: could be an object literal divided or 
      //    a block. More likely to be start of a statement after 
      //    a block which cannot start with a /. 
    + "~" // ~   ditto binary operand 
    + "]$" 
    // The exclusion of ++ and -- from the above is also problematic. 
    // Both are prefix and postfix operators. 
    // Given that there is rarely a good reason to increment a regular expression 
    // and good reason to have a post-increment operator as the left operand of 
    // a division (x++/y) this pattern treats ++ and -- as division preceders. 
);