자바스크립트에서 정규식 리터럴을 연결하려면 어떻게 해야 합니까?

자바스크립트에서 정규식 리터럴을 연결하려면 어떻게 해야 합니까?

이런 일을 할 수 있을까요?

var pattern = /some regex segment/ + /* comment here */
    /another segment/;

아니면 새 제품을 사용해야 합니까?RegExp()구문 및 연결 문자열?코드가 더 명확하고 간결하기 때문에 리터럴을 사용하고 싶습니다.

정규식 리터럴 구문을 사용하지 않고 정규식을 만드는 방법은 다음과 같습니다.이렇게 하면 정규식 개체가 되기 전에 임의 문자열을 조작할 수 있습니다.

var segment_part = "some bit of the regexp";
var pattern = new RegExp("some regex segment" + /*comment here */
              segment_part + /* that was defined just now */
              "another segment");

두 개의 정규식 리터럴이 있는 경우 실제로 다음 기술을 사용하여 연결할 수 있습니다.

var regex1 = /foo/g;
var regex2 = /bar/y;
var flags = (regex1.flags + regex2.flags).split("").sort().join("").replace(/(.)(?=.*\1)/g, "");
var regex3 = new RegExp(expression_one.source + expression_two.source, flags);
// regex3 is now /foobar/gy

그것은 단지 하나와 둘이 문자 그대로의 정규 표현 대신 문자 그대로의 문자열인 것보다 더 말이 많은 것입니다.

정규식 개체를 임의로 연결하는 것만으로도 부작용이 발생할 수 있습니다.RegExp를 사용합니다.대신 소스:

var r1 = /abc/g;
var r2 = /def/;
var r3 = new RegExp(r1.source + r2.source, 
                   (r1.global ? 'g' : '') 
                   + (r1.ignoreCase ? 'i' : '') + 
                   (r1.multiline ? 'm' : ''));
console.log(r3);
var m = 'test that abcdef and abcdef has a match?'.match(r3);
console.log(m);
// m should contain 2 matches

또한 표준 RegExp 플래그를 사용하여 이전 RegExp의 정규식 플래그를 유지할 수 있습니다.

jsFiddle

저는 "평가" 옵션에 전적으로 동의하지 않습니다.

var xxx = /abcd/;
var yyy = /efgh/;
var zzz = new RegExp(eval(xxx)+eval(yyy));

의도한 결과가 아닌 "//abcd//efgh//"를 제공합니다.

source like 사용하기

var zzz = new RegExp(xxx.source+yyy.source);

"/sysdefgh/"를 제공하며, 이는 정확합니다.

논리적으로 평가할 필요가 없습니다. 당신은 당신의 표현을 알고 있습니다. 당신은 단지 그것의 출처나 그것이 어떻게 쓰여지는지가 꼭 그것의 가치는 아닙니다.플래그의 경우 RegExp의 선택적 인수를 사용하면 됩니다.

제 상황에서, 저는 ^과 $가 제가 함께 연결하려고 하는 여러 표현에 사용되는 문제에 달려 있습니다!이러한 표현식은 프로그램 전체에서 사용되는 문법 필터입니다.이제 저는 프리포지션의 경우를 처리하기 위해 그 중 일부를 함께 사용하고 싶지 않습니다. 시작과 끝을 제거하기 위해 소스를 "분할"해야 할 수도 있습니다. ^(및/또는 )$ :) 건배, 알렉스.

문제 regexp에 \1과 같은 백매치 그룹이 포함된 경우.

var r = /(a|b)\1/  // Matches aa, bb but nothing else.
var p = /(c|d)\1/   // Matches cc, dd but nothing else.

그러면 소스를 연결하는 것만으로는 작동하지 않습니다.실제로, 이 둘의 조합은 다음과 같습니다.

var rp = /(a|b)\1(c|d)\1/
rp.test("aadd") // Returns false

해결책:먼저 첫 번째 정규식에서 일치하는 그룹의 수를 계산한 다음 두 번째의 각 역일치 토큰에 대해 일치하는 그룹의 수만큼 증분합니다.

function concatenate(r1, r2) {
  var count = function(r, str) {
    return str.match(r).length;
  }
  var numberGroups = /([^\\]|^)(?=\((?!\?:))/g; // Home-made regexp to count groups.
  var offset = count(numberGroups, r1.source);    
  var escapedMatch = /[\\](?:(\d+)|.)/g;        // Home-made regexp for escaped literals, greedy on numbers.
  var r2newSource = r2.source.replace(escapedMatch, function(match, number) { return number?"\\"+(number-0+offset):match; });
  return new RegExp(r1.source+r2newSource,
      (r1.global ? 'g' : '') 
      + (r1.ignoreCase ? 'i' : '')
      + (r1.multiline ? 'm' : ''));
}

테스트:

var rp = concatenate(r, p) // returns  /(a|b)\1(c|d)\2/
rp.test("aadd") // Returns true

다음의 경우:

• 당신은 당신이 정규 표현식에서 무엇을 하는지 알고 있습니다.
• 당신은 패턴을 형성할 많은 정규화 조각들이 있고, 그들은 같은 깃발을 사용할 것입니다.
• 작은 패턴 청크를 배열로 분리하는 것이 더 읽기 쉽다는 것을 알게 됩니다.
• 또한 다음 개발을 위해 각 부분에 대해 나중에 의견을 제시할 수 있습니다.
• 당신은 당신의 정규식을 시각적으로 단순화하는 것을 선호합니다./this/g보다는new RegExp('this', 'g');
• 정규식을 처음부터 하나로 묶는 것보다 추가 단계로 조립하는 것이 좋습니다.

그런 다음 다음과 같이 쓸 수 있습니다.

var regexParts =
    [
        /\b(\d+|null)\b/,// Some comments.
        /\b(true|false)\b/,
        /\b(new|getElementsBy(?:Tag|Class|)Name|arguments|getElementById|if|else|do|null|return|case|default|function|typeof|undefined|instanceof|this|document|window|while|for|switch|in|break|continue|length|var|(?:clear|set)(?:Timeout|Interval))(?=\W)/,
        /(\$|jQuery)/,
        /many more patterns/
    ],
    regexString  = regexParts.map(function(x){return x.source}).join('|'),
    regexPattern = new RegExp(regexString, 'g');

그런 다음 다음과 같은 작업을 수행할 수 있습니다.

string.replace(regexPattern, function()
{
    var m = arguments,
        Class = '';

    switch(true)
    {
        // Numbers and 'null'.
        case (Boolean)(m[1]):
            m = m[1];
            Class = 'number';
            break;

        // True or False.
        case (Boolean)(m[2]):
            m = m[2];
            Class = 'bool';
            break;

        // True or False.
        case (Boolean)(m[3]):
            m = m[3];
            Class = 'keyword';
            break;

        // $ or 'jQuery'.
        case (Boolean)(m[4]):
            m = m[4];
            Class = 'dollar';
            break;

        // More cases...
    }

    return '<span class="' + Class + '">' + m + '</span>';
})

저의 경우(코드 미러와 같은 편집기), 식을 포장하기 위해 html 태그로 교체할 때마다 다음과 같이 많은 교체를 하는 것보다 하나의 큰 정규식을 수행하는 것이 훨씬 쉽습니다.다음 패턴은 html 태그 자체에 영향을 주지 않고는 타겟팅하기가 더 어려울 것입니다(그리고 안타깝게도 자바스크립트에서 지원되지 않는 좋은 배경이 없다면).

.replace(/(\b\d+|null\b)/g, '<span class="number">$1</span>')
.replace(/(\btrue|false\b)/g, '<span class="bool">$1</span>')
.replace(/\b(new|getElementsBy(?:Tag|Class|)Name|arguments|getElementById|if|else|do|null|return|case|default|function|typeof|undefined|instanceof|this|document|window|while|for|switch|in|break|continue|var|(?:clear|set)(?:Timeout|Interval))(?=\W)/g, '<span class="keyword">$1</span>')
.replace(/\$/g, '<span class="dollar">$</span>')
.replace(/([\[\](){}.:;,+\-?=])/g, '<span class="ponctuation">$1</span>')

가능한 한 자주 문자 구문을 사용하는 것이 좋습니다.더 짧고 읽기 쉬우며 이스케이프 인용문이나 이중 이스케이프 백래시가 필요하지 않습니다."Javascript Patterns"에서 스토얀 스테파노프 2010.

그러나 새로 만들기를 사용하는 것이 연결할 수 있는 유일한 방법일 수 있습니다.

평가는 피하겠습니다.안전하지 않습니다.

다음과 같은 작업을 수행할 수 있습니다.

function concatRegex(...segments) {
  return new RegExp(segments.join(''));
}

세그먼트는 별도의 인수로 전달되는 문자열(정규 리터럴이 아닌)입니다.

리터럴 클래스와 RegExp 클래스 모두에서 gex 소스를 중첩할 수 있습니다.

var xxx = new RegExp(/abcd/);
var zzz = new RegExp(xxx.source + /efgh/.source);

생성자를 두 개의 매개 변수와 함께 사용하고 '/' 후행 문제를 방지합니다.

var re_final = new RegExp("\\" + ".", "g");    // constructor can have 2 params!
console.log("...finally".replace(re_final, "!") + "\n" + re_final + 
    " works as expected...");                  // !!!finally works as expected

                         // meanwhile

re_final = new RegExp("\\" + "." + "g");              // appends final '/'
console.log("... finally".replace(re_final, "!"));    // ...finally
console.log(re_final, "does not work!");              // does not work

아니요, 문자 그대로의 방식은 지원되지 않습니다.RegExp를 사용해야 합니다.

나에게 더 쉬운 방법은 소스를 연결하는 것입니다. 예:

a = /\d+/
b = /\w+/
c = new RegExp(a.source + b.source)

c 값의 결과:

/\d+\w+/

정규식에 연결이 필요한 경우 와일드 코드를 작성하지 말고 RegEXP, 백슬래시 및 연결을 사용하십시오.

무엇이 필요합니까?

const cookieName = 'my-cookie';
const regex = /(?:(?:^|.*;\s*)cookieName\s*\=\s*([^;]*).*$)|^.*$/;

구현 방법:

const cookieName = 'my-cookie';
const regex = new RegExp('(?:(?:^|.*;\\s*)' + cookieName + '\\s*\\=\\s*([^;]*).*$)|^.*$');
console.log(regex);

행운을 빕니다.

사용하는 것을 선호합니다.eval('your expression')그것은 그것을 추가하지 않기 때문에./양쪽 끝에/그거='new RegExp'한다.

언급URL : https://stackoverflow.com/questions/185510/how-can-i-concatenate-regex-literals-in-javascript