화성 문 - 정규 표현 식 (전재)

12437 단어
정규 표현 식 (regular expression) 은 문자열 이 일치 하 는 패턴 을 설명 합 니 다. 문자열 에 피 드 문자열 이 있 는 지, 일치 하 는 하위 문자열 을 교체 하거나 특정한 문자열 에서 특정한 조건 에 맞 는 하위 문자열 을 꺼 내 는 지 확인 할 수 있 습 니 다.정규 표현 식 생 성 방식
 var reg = /pattern/flags
//        
var reg = new RegExp(pattern,flags);
//      

pattern: 정규 표현 식 flags: 표지 (수정자) 표 지 는 주로 i 대소 문자 가 m 다 중 줄 과 일치 하 는 것 을 무시 합 니 다. 즉, 한 줄 의 텍스트 끝 에 도 달 했 을 때 다음 줄 에서 정규 와 일치 하 는 항목 g 의 전체 일치 모드 가 모든 문자열 에 적용 되 는 지 여 부 를 계속 유지 합 니 다. 첫 번 째 일치 하 는 항목 을 찾 을 때 중단 하 는 것 이 아 닙 니 다.
글자 수 생 성 방식 과 구조 함수 생 성 방식 의 차이
글자 수 생 성 방식 은 문자열 연결 을 할 수 없습니다. 인 스 턴 스 생 성 방식 은 가능 합 니 다.
var regParam = 'cm';
var reg1 = new RegExp(regParam+'1');
var reg2 = /regParam/;
console.log(reg1);  //   /cm1/
console.log(reg2);  //  /regParam/

글자 수 생 성 방식 의 특수 한 의미 의 문 자 는 전의 가 필요 하지 않 습 니 다. 인 스 턴 스 생 성 방식 은 전의 가 필요 합 니 다.
var reg1 = new RegExp('\d');  //    /d/ 
var reg2 = new RegExp('\\d')  //   /\d/
var reg3 = /\d/;              //  /\d/

문자
\d : 0-9           \d      
\w :   ,   ,    0-9 a-z A-Z _
\s :        
\D :   \d
\W :   \w
\S :   \s
 . :   
\ : | : () :
: \b : => ^ : => $ : => [a-z] : [] [^a-z] : [] ^ [abc] : abc [^abc]

횟수 를 나타 내 는 양사 원 문자
* : 0   
+ : 1   
? : 0  1      
{n} :   n ;
{n,} : n   
{n,m} : n  m 

양 어 는 원 문자 뒤에 나타 납 니 다. 예 를 들 어 \ d + 는 앞 에 나타 난 원 문자 의 횟수 를 제한 합 니 다.
var str = '1223334444';
var reg = /\d{2}/g;
var res = str.match(reg);
console.log(res)  //["12", "23", "33", "44", "44"]

var str ='         ';
var reg = /^\s+|\s+$/g; //        
var res = str.replace(reg,'');
console.log('('+res+')')  //(     )

일반 [] 의 문 자 는 + 와 같은 특별한 의미 가 없 지만 \ w 와 같은 것 은 특별한 의미 가 있 습 니 다.
var str1 = 'abc';
var str2 = 'dbc';
var str3 = '.bc';
var reg = /[ab.]bc/; //   .   .
reg.test(str1)  //true
reg.test(str2)  //false
reg.test(str3)  //true

[] 에서 두 자릿수 가 나타 나 지 않 습 니 다.
[12]  1  2   [0-9]     0 9 [a-z]  a z
  :   18 65       
var reg = /[18-65]/; //      
reg.test('50')
 //Uncaught SyntaxError: Invalid regular expression: /[18-65]/: Range out of order in character class
//        8-6    ,    [16-85]      16 85     ,             

         18-65              
    3      18-19  20-59 60-65 
reg = /(18|19)|([2-5]\d)|(6[0-5])/;

() 의 우선 순위 향상 기능: 있 을 때 우 리 는 () 을 더 해서 우선 순 위 를 높 일 필요 가 있 는 지 주의해 야 한다.() 의 그룹 중복 하위 항목 (두 개 를 함께 놓 고 말 하기);그룹: 정규 에 작은 괄호 가 나타 나 면 그룹 이 됩 니 다. 그룹 만 있 으 면 exec (match) 와 replace 의 결과 가 달라 집 니 다. (뒤의 정규 방법 에서 다시 말 합 니 다)
그룹 참조 (중복 하위 항목): 정규 에 괄호 가 나타 나 면 그룹 을 만 들 수 있 습 니 다. 우 리 는 (n 은 숫자 로 몇 번 째 그룹 을 대표 합 니 다) 이 그룹 을 참조 할 수 있 습 니 다. 첫 번 째 작은 그룹 은 \ 1 로 표시 할 수 있 습 니 다. 예 를 들 어 이 문자열 'abAAbcCccdaACBDDabcccddaab' 에서 가장 많은 자모 가 나타 나 고 몇 번 이 나타 나 는 지 (대소 문자 무시) 를 구 할 수 있 습 니 다.。
var str = 'abbbbAAbcBCCccdaACBDDabcccddddaab';
str = str.toLowerCase().split('').sort(function(a,b){return a.localeCompare(b)}).join('');
var reg = /(\w)\1+/ig;
var maxStr = '';
var maxLen = 0;
str.replace(reg,function($0,$1){
    var regLen = $0.length;
    if(regLen>maxLen){
        maxLen = regLen;
        maxStr = $1;
    }else if(maxLen == regLen){
        maxStr += $1;
    }
})
console.log(`        ${maxStr},    ${maxLen} `);

우리 가 () 를 추가 하 는 것 은 우선 순 위 를 높이 기 위해 작은 그룹 을 잡 으 려 고 하지 않 을 때 () 에 추가 할 수 있 습 니까?:그룹 캡 처 취소 하기;
var str = 'aaabbb';
var reg = /(a+)(?:b+)/;
var res =reg.exec(str);
console.log(res)
//["aaabbb", "aaa", index: 0, input: "aaabbb"]
//            

정규 연산 자의 우선 순위 정규 표현 식 은 왼쪽 에서 오른쪽으로 계산 하고 우선 순위 순 서 를 따 르 는 것 이 산술 표현 식 과 매우 유사 합 니 다.같은 우선 순 위 는 왼쪽 에서 오른쪽으로 연산 되 며, 서로 다른 우선 순위 의 연산 은 먼저 높 고 나중에 낮 습 니 다.다음은 흔히 볼 수 있 는 연산 자의 우선 순위 배열 입 니 다. 각종 정규 표현 식 연산 자의 우선 순 위 를 최고 에서 최저 로 설명 합 니 다.
\ :    
(), (?:), (?=), []  =>        
*, +, ?, {n}, {n,}, {n,m}   =>      
^, $, \     、     
|       =>   ," "  
               ,    |    ,     |     ,    ()      
 :    food  foot    reg = /foo(t|d)/      

정규 적 인 특성 탐욕 성: 이른바 탐욕 성 은 바로 잡 을 때 매번 가능 한 한 조건 에 맞 는 내용 을 많이 잡 는 것 이다.조건 에 맞 는 문자열 을 최대한 적 게 잡 으 려 면 양사 원 문자 뒤에 '?' 를 추가 할 수 있 습 니 다.게 으 름 성: 게 으 름 성 은 한 번 성공 적 으로 캡 처 한 후에 뒤의 문자열 이 조건 에 맞 는 지 없 는 지 에 관 계 없 이 더 이상 캡 처 하지 않 는 다 는 것 이다.대상 의 모든 조건 에 맞 는 문자열 을 캡 처 하려 면 전체 캡 처 임 을 식별 자 g 로 표시 할 수 있 습 니 다.
var str = '123aaa456';
var reg = /\d+/;  //     ,         
var res = str.match(reg)
console.log(res)
// ["123", index: 0, input: "123aaa456"]
reg = /\d+?/g; //     、   
res = str.match(reg)
console.log(res)
// ["1", "2", "3", "4", "5", "6"]

정규 와 관련 된 몇 가지 방법
여기 서 우 리 는 test, exec, match 와 replace 라 는 네 가지 방법 만 소개 합 니 다.reg. test (str) 는 문자열 이 정규 에 맞 는 지 확인 하기 위해 true 로 돌아 가지 않 으 면 false 로 돌아 갑 니 다.
var str = 'abc';
var reg = /\w+/;
console.log(reg.test(str));  //true

reg. exec () 는 규칙 에 맞 는 문자열 을 캡 처 하 는 데 사 용 됩 니 다.
var str = 'abc123cba456aaa789';
var reg = /\d+/;
console.log(reg.exec(str))
//  ["123", index: 3, input: "abc123cba456aaa789"];
console.log(reg.lastIndex)
// lastIndex : 0 

reg.exec       
// [0:"123",index:3,input:"abc123cba456aaa789"]
0:"123"            
index:3            
input         

우리 가 exec 로 캡 처 할 때 정규 'g' 식별 자 를 추가 하지 않 으 면 exec 가 캡 처 한 것 은 매번 같 습 니 다. 정규 에 'g' 식별 자가 있 을 때 캡 처 한 결 과 는 다 릅 니 다. 우 리 는 방금 의 예 를 보 겠 습 니 다.
var str = 'abc123cba456aaa789';
var reg = /\d+/g;  //       g
console.log(reg.lastIndex)
// lastIndex : 0 

console.log(reg.exec(str))
//  ["123", index: 3, input: "abc123cba456aaa789"]
console.log(reg.lastIndex)
// lastIndex : 6

console.log(reg.exec(str))
// ["456", index: 9, input: "abc123cba456aaa789"]
console.log(reg.lastIndex)
// lastIndex : 12

console.log(reg.exec(str))
// ["789", index: 15, input: "abc123cba456aaa789"]
console.log(reg.lastIndex)
// lastIndex : 18

console.log(reg.exec(str))
// null
console.log(reg.lastIndex)
// lastIndex : 0

exec 방법 을 호출 할 때마다 캡 처 된 문자열 은 같 지 않 습 니 다. lastIndex: 이 속성 은 다음 캡 처 를 어떤 색인 에서 시작 하 는 지 기록 합 니 다.캡 처 를 시작 하지 않 았 을 때 이 값 은 0 입 니 다.지난번 포획 결과 가 null 이면그러면 lastIndex 의 값 은 0 으로 변 경 됩 니 다. 다음 에 처음부터 캡 처 합 니 다.그리고 이 lastIndex 속성 은 인위적인 할당 도 지원 합 니 다.
exec 캡 처 는 그룹 () 의 영향 을 받 습 니 다.
var str = '2017-01-05';
var reg = /-(\d+)/g
// ["-01", "01", index: 4, input: "2017-01-05"]
"-01" :         
"01"  :                 

str. match (reg) 가 일치 하 는 데 성공 하면 일치 하 는 그룹 으로 돌아 가 고 일치 하지 않 으 면 null 로 돌아 갑 니 다.
//match exec      
var str = 'abc123cba456aaa789';
var reg = /\d+/;
console.log(reg.exec(str));
//["123", index: 3, input: "abc123cba456aaa789"]
console.log(str.match(reg));
//["123", index: 3, input: "abc123cba456aaa789"]

위의 두 가지 방법 console 의 결 과 는 어떤 차이 가 있 습 니까?두 문자열 은 똑 같 습 니 다.우리 가 전체 국면 을 일치 시 킬 때, 양자 의 차이 가 나타 날 것 이다.
var str = 'abc123cba456aaa789';
var reg = /\d+/g;
console.log(reg.exec(str));
// ["123", index: 3, input: "abc123cba456aaa789"]
console.log(str.match(reg));
// ["123", "456", "789"]

전역 이 일치 할 때 match 방법 은 일치 하 는 조건 에 맞 는 문자열 을 한꺼번에 배열 에 캡 처 합 니 다. exec 로 같은 효 과 를 얻 으 려 면 여러 번 exec 방법 을 실행 해 야 합 니 다.
우 리 는 exec 로 match 방법의 실현 을 간단하게 모 의 해 볼 수 있다.
String.prototype.myMatch = function (reg) {
    var arr = [];
    var res = reg.exec(this);
    if (reg.global) {
        while (res) {
            arr.push(res[0]);
            res = reg.exec(this)
        }
    }else{
        arr.push(res[0]);
    }
    return arr;
}

var str = 'abc123cba456aaa789';
var reg = /\d+/;
console.log(str.myMatch(reg))
// ["123"]

var str = 'abc123cba456aaa789';
var reg = /\d+/g;
console.log(str.myMatch(reg))
// ["123", "456", "789"]

또한, match 와 exec 는 그룹 () 의 영향 을 받 을 수 있 습 니 다. 그러나 match 는 식별 자 g 가 없 는 상태 에서 만 작은 그룹의 내용 을 표시 합 니 다. 전체 g 가 있 으 면 match 는 한 번 에 모두 배열 에 캡 처 합 니 다.
var str = 'abc';
var reg = /(a)(b)(c)/;

console.log( str.match(reg) );
// ["abc", "a", "b", "c", index: 0, input: "abc"]
console.log( reg.exec(str) );
// ["abc", "a", "b", "c", index: 0, input: "abc"]

    g    
var str = 'abc';
var reg = /(a)(b)(c)/g;
console.log( str.match(reg) );
// ["abc"]
console.log( reg.exec(str) );
// ["abc", "a", "b", "c", index: 0, input: "abc"]

str. replace () 라 는 방법 은 모두 가 낯 설 지 않 을 것 이다. 지금 우리 가 말 하고 자 하 는 것 은 바로 이 방법 과 정규 와 관련 된 것 이다.
        ,                
  :str.replace(reg,newStr);

var str = 'a111bc222de';
var res = str.replace(/\d/g,'Q')
console.log(res)
// "aQQQbcQQQde"

replace              
str.replace(reg,fn);

var str = '2017-01-06';
str = str.replace(/-\d+/g,function(){
    console.log(arguments)
})

       :
["-01", 4, "2017-01-06"]
["-06", 7, "2017-01-06"]
"2017undefinedundefined"
                   exec      ,   exec     ,                   

var str = '2017-01-06';
str = str.replace(/-(\d+)/g,function(){
    console.log(arguments)
})
["-01", "01", 4, "2017-01-06"]
["-06", "06", 7, "2017-01-06"]
"2017undefinedundefined"

결과적으로 우리 의 추측 은 문제 가 없다.또한, 우리 가 주의해 야 할 것 은 replace 에서 정규 로 찾 은 문자열 을 바 꾸 려 면 함수 에서 정규 로 잡 은 내용 을 바 꾸 기 위해 반환 값 이 필요 합 니 다.
replace 방법 으로 url 의 인 자 를 얻 는 방법
(function(pro){
    function queryString(){
        var obj = {},
            reg = /([^?+]+)=([^?+]+)/g;
        this.replace(reg,function($0,$1,$2){
            obj[$1] = $2;
        })
        return obj;
    }
    pro.queryString = queryString;
}(String.prototype));

//    url  https://www.baidu.com?a=1&b=2
// window.location.href.queryString();
// {a:1,b:2}

너그러이 단언 하 다
어떤 내용 (그러나 이러한 내용 은 포함 되 지 않 음) 이전 이나 그 후의 것 을 찾 는 데 사 용 됩 니 다. 예 를 들 어 \ b, ^, $처럼 위 치 를 지정 하 는 데 사 용 됩 니 다. 이 위 치 는 일정한 조건 (즉 단언) 을 만족 시 켜 야 하기 때문에 0 폭 단언 이 라 고도 부 릅 니 다.
정규 표현 식 을 사용 할 때 포 획 된 내용 의 앞 뒤 는 반드시 특정한 내용 이 어야 하 며, 우리 가 이러한 특정한 내용 을 포착 하고 싶 지 않 을 때 는 0 폭 의 단언 이 도움 이 될 수 있다.
0 너비 예측 선행 단언 (? = exp) 0 너비 마이너스 예측 선행 단언 (?! exp) 0 너비 가 돌 이 켜 보고 단언 (? < = exp) 0 너비 마이너스 돌 이 켜 보고 단언 (? 이 네 쌍 둥 이 는 이름 이 길 어 보 이 며 복잡 하고 어 려 운 느낌 을 주 고 있다. 이들 이 무엇 을 하 는 지 하나씩 살 펴 보 자.
(? = exp) 이 간단 한 이 해 는 문자 가 나타 나 는 위치의 오른쪽 이 exp 표현 식 과 일치 해 야 한 다 는 것 이다.
var str = "i'm singing and dancing";
var reg = /\b(\w+(?=ing\b))/g
var res = str.match(reg);
console.log(res)
// ["sing", "danc"]


    ,        ,    。
var str = 'abc';
var reg = /a(?=b)c/;
console.log(res.test(str));  // false

이것 은 보기에 정확 한 것 같 습 니 다. 실제 결 과 는 false reg 에서 a (? = b) 와 일치 하 는 문자열 'abc' 문자열 a 의 오른쪽 은 b 입 니 다. 이 일치 하 는 것 은 문제 가 없습니다. 다음 reg 에서 a (? = b) 뒤의 c 와 일치 하 는 문자열 은 문자열 'abc' 에서 a 의 뒤쪽 b 의 앞 자리 부터 일치 합 니 다. 이것 은 / ac / 'abc' 와 일치 하 는 것 입 니 다. 결 과 는 false 입 니 다.
(?! exp) 이것 은 문자 가 나타 난 위치의 오른쪽 이 exp 라 는 표현 식 이 될 수 없다 는 것 을 말 합 니 다.
var str = 'nodejs';
var reg = /node(?!js)/;
console.log(reg.test(str)) // false

(? < = exp) 이것 은 문자 가 나타 나 는 위치의 앞쪽 이 exp 라 는 표현 식 입 니 다.
var str = '¥998$888';
var reg = /(?<=\$)\d+/;
console.log(reg.exec(str)) //888

(?
var str = '¥998$888';
var reg = /(?

감사합니다. 본인 은 많은 이익 을 얻 었 습 니 다!
다음으로 전송:http://www.cnblogs.com/chenmeng0818/p/6370819.html

좋은 웹페이지 즐겨찾기