완전 js 정규 표현 식 정리 노트

10253 단어

var reCat = new RegExp("cat", "gi"); //RegExp              ,                   ,                
var reCat = /cat/gi; //  Perl      
 
 i:             
 g:      (                   ) 
 m:       



문자 
메타 문 자 는 표현 식 문법 의 일부분 입 니 다. 정규 표현 식 에 사용 되 는 모든 메타 문 자 는 {[(\ ^ $|)]}? * + -  물음표 와 일치 하 는 경우: var reQMark = / \? /;또는 var reQMark = new RegExp ("\ \?"); /여기 가 두 개의 역 슬 래 쉬, 이중 전의 라 는 것 을 주의해 라.  

\xxx         xxx      , :/\142/   b 
\xdd          dd      , :/\x62/   b 
\uxxxx          xxxx     Unicode   , :/\u0062/   b 
\r       

\f \t \v \a alert \e escape \cX X \0 NULL . , , [^
\r] \w , [a-zA-Z_0-9] \W , [^a-zA-Z_0-9] \d , [0-9] \D , [^0-9] \s , [ \t
\x0B\f\r],\x0B tab \t \S , [^ \t
\x0B\f\r]

네모 난 괄호 

[abc]              
[^abc]                
[0-9]       0   9     
[a-z]         a     z     
[A-Z]         A     Z     
[A-z]         A     z     
[adgk]              
[^adgk]              

양사  ? 0 개 또는 하 나 를 포함 하 는 문자열 과 일치 합 니 다. 예 를 들 어 ba? d 는 bd, bad 와 일치 합 니 다.  + 최소한 하나의 문자열 을 포함 하 는 문자열 과 일치 합 니 다. 예 를 들 어 ba + d 는 bad, baad 와 일치 합 니 다.  * 0 개 이상 의 문자열 을 포함 하 는 모든 문자열 과 일치 합 니 다. 예 를 들 어 ba * d 는 bd, bad, baad 와 일치 합 니 다.  {n} 은 n 번 의 시퀀스 를 포함 하 는 문자열 과 일치 합 니 다. 예 를 들 어 ba {1} d 는 bad 와 일치 합 니 다.  {n, m} 은 최소 n 번 이지 만 m 번 을 초과 하지 않 는 문자열 과 일치 합 니 다. 예 를 들 어 ba {0, 1} d 는 bd, bad 와 일치 합 니 다.  {n,} 은 최소한 n 번 이상 나타 나 는 시퀀스 를 포함 하 는 문자열 과 일치 합 니 다. 예 를 들 어 ba {0,} 은 bd, bad, baad, baaad 와 일치 합 니 다.    탐욕 양사: 전체 문자열 이 일치 하 는 지 확인 하 십시오. 일치 하지 않 는 것 을 발견 하면 작년 에 이 문자열 의 마지막 문 자 를 다시 시도 합 니 다. 예 를 들 어:?, +, *,{n}, {n, m}, {n,}, 기본적으로 탐욕 양사 입 니 다.  타성 양사: 문자열 의 첫 번 째 자모 가 일치 하 는 지 먼저 보 세 요. 만약 에 단독 이라는 문자 가 부족 하면 다음 문 자 를 읽 고 두 문 자 를 구성 하 는 문자열 은 탐욕 양사 의 작업 방식 과 정반 대 입 니 다. 예 를 들 어:?, +?, *?{n}?、{n, m}?、{n, }?  지배 양사: 전체 문자열 과 만 일치 하려 고 시도 합 니 다. 전체 문자열 이 일치 하지 않 으 면 더 이상 시도 하지 않 습 니 다. 예 를 들 어:? +, +, * +,{n}+、{n, m}+、{n, }+  

var sToMatch = "abbbaabbbaaabbb1234"; 
var re1 = /.*bbb/g; //     "abbbaabbbaaabbb" 
var re2 = /.*?bbb/g; //            ,     "abbb","aabbb","aaabbb" 
var re3 = /.*+bbb/g; //    ,     

복잡 한 패턴 의 그룹: 일련의 괄호 로 일련의 문자, 문자 류 와 양 어 를 둘러싸 고 사용 합 니 다.  /(dog){2}/  일치 하 는 "dogdog"  /([bd]ad?)*/  일치 하 는 공백, "ba", "da", "bad", "dad"  /(mom( and dad)?)/  매 칭 "mom", "mom and dad"  /^\s*(.*?)\s+$/  처음 과 끝 이 일치 하 는 공백 문자 도 / ^ \ s + | \ s + $/ g 를 사용 할 수 있 습 니 다.  복잡 한 패턴 의 역방향 참조: 캡 처 그룹 이 라 고도 합 니 다. 왼쪽 에서 오른쪽으로 만 나 는 왼쪽 괄호 문자 의 순서에 따라 생 성 되 고 번 호 를 매 깁 니 다. 예 를 들 어 표현 식 (A? (B? (C?))), (B? (C?), (C?) 번 호 를 생 성 합 니 다.  역방향 인용 에는 몇 가지 다른 사용 방법 이 있다.  우선, 정규 표현 식 대상 의 test (), match () 또는 search () 방법 을 사용 한 후, 반대로 인 용 된 값 은 RegExp 구조 함수 에서 얻 을 수 있 습 니 다. 예 를 들 어: 

var sToMatch = "#123456789"; 
var reNumbers = /#(\d+)/; 
reNumbers.test(sToMatch); 
alert(RegExp.$1); //"123456789",$1          ,     $2,$3... 

그 다음 에 그룹 을 정의 하 는 표현 식 에 역방향 인용 을 직접 포함 할 수 있 습 니 다. 예 를 들 어 \ 1, \ 2 등 특수 전의 서열 을 사용 하여 이 루어 집 니 다. 

var sToMatch = "dogdog"; 
var reDogdog = /(dog)\1/; //   /dogdog/ 
alert(reDogdog.test(sToMatch)); //true 

셋째, 역방향 인용 은 String 대상 의 replace () 방법 에 사용 할 수 있 으 며, $1, $2 등 특수 문자 배열 을 사용 하여 이 루어 집 니 다. 

var sToChange = "1234 5678"; 
var reMatch = /(\d{4}) (\d{4})/; 
alert(sToChange.replace(reMatch, "$2 $1")); //"5678 1234" 

복잡 모드 후보: 파이프 문자 (|) 를 사용 하여 두 개의 단독 모드 사이 에 놓 습 니 다. 

var reBadWords = /badword | anotherbadword/gi; 
var sUserInput = "This is a String using badword1 and badword2."; 
var sFinalText = sUserInput.replace(reBadWords, function(sMatch){ 
 return sMatch.replace(/./g, "*"); //                
}); 

복잡 한 모드 의 비 포획 적 그룹: 포획 적 그룹 에 비해 역방향 인용 을 만 들 지 않 습 니 다. 비교적 긴 정규 표현 식 에서 역방향 인용 을 저장 하면 일치 속 도 를 낮 출 수 있 습 니 다. 비 포획 적 그룹 을 사용 하면 일치 하 는 문자열 시퀀스 와 같은 능력 을 가 질 수 있 습 니 다. 결 과 를 저장 하지 않 아 도 됩 니 다. 

var sToMatch = "#123456789"; 
var reNumbers = /#(?:\d+)/; //                                     
reNumbers.test(sToMatch); 
alert(RegExp.$1); //"",                   
alert(sToMatch.replace(reNumbers, "abcd$1")); //     "abcd$1"   "abcd123456789",           

또: 

String.prototype.stripHTML = function(){ 
 var reTag = //g; //     HTML  ,      HTML   
 return this.replace(reTag, ""); 
} 

복잡 한 패턴 의 전망: 정규 표현 식 연산 기 에 게 위 치 를 이동 하지 않 고 앞 을 보 여 줍 니 다. 정방 향 전망 (다음 에 나타 나 는 것 이 특정한 문자 집합 인지 확인) 과 마이너스 전망 (다음 에 나타 나 지 말 아야 할 특정한 문자 집합 을 검사 합 니 다) 이 존재 합 니 다.  다음 에 지정 한 문자열 n 과 일치 하지만 n 을 포함 하지 않 는 문자열 입 니 다. 괄호 는 그룹 이 아 닙 니 다.  마이너스 전망 (?! n) 은 다음 문자열 n 이 지정 되 지 않 은 문자열 과 일치 합 니 다. 예 를 들 어:  

var sToMatch1 = "bedroom"; 
var sToMatch2 = "bedding"; 
var reBed1 = /(bed(?=room))/; 
var reBed2 = /(bed(?!room))/; 
alert(reBed1.test(sToMatch1)); //true 
alert(RegExt.$1); //  "bed"   "bedroom" 
alert(reBed1.test(sToMatch2)); //false 
alert(reBed2.test(sToMatch1)); //false 
alert(reBed2.test(sToMatch2)); //true 
alert(RegExt.$1); //     "bed" 

복잡 한 패턴 의 경계: 정규 표현 식 에서 패턴 의 위 치 를 표시 하 는 데 사 용 됩 니 다.  n $는 n 으로 끝 나 는 모든 문자열 과 일치 합 니 다. 예 를 들 어: / (\ w +) \. $/ 줄 끝 단어 "one.", "to." 등 입 니 다.  ^n. 시작 이 n 인 모든 문자열 과 일치 합 니 다. 예 를 들 어 / ^ (. +?) \ b / 시작 위치 에 있 는 하나 이상 의 단어 문자 와 일치 합 니 다.  \b. 단어의 시작 이나 끝 에 있 는 일치 하 는 단 어 를 찾 습 니 다. 예 를 들 어 / \ b (\ S +?) \ b / g 또는 / (\ w +) / g 일치 하 는 단 어 를 문자열 에서 추출 합 니 다.  \B 단어의 시작 이나 끝 에 없 는 일치 찾기  복잡 모드 의 여러 줄 모드: 

var sToMatch = "First second
third fourth
fifth sixth"; var reLastWordOnLine = /(\w+)$/gm; alert(sToMatch.match(reLastWordOnLine)); // ["second", "fourth", "sixth"] "sixth"

RegExp 대상 의 속성 과 방법:  global  //RegExp 대상 에 표지 g 가 있 는 지 여부  ignoreCase  //RegExp 대상 에 표지 i 가 있 는 지 여부  multiline  //RegExp 대상 에 표지 m 가 있 는 지 여부  source  //정규 표현 식 의 원본 텍스트  lastIndex  //다음 일치 하 는 정 수 를 표시 합 니 다.  실제 사용 한 것 은 lastIndex 입 니 다. 예 를 들 어:  

 
var sToMatch = "bbq is short for barbecue"; 
var reB = /b/g; 
reB.exec(sToMatch); 
alert(reB.lastIndex); //1,     0,lastIndex 1 
reB.exec(sToMatch); 
alert(reB.lastIndex); //2 
reB.exec(sToMatch); 
alert(reB.lastIndex); //18 
reB.lastIndex = 0; //       
reB.exec(sToMatch); 
alert(reB.lastIndex); //1   21 

정적 속성  input, 짧 은 이름 은 $,마지막 으로 일치 하 는 문자열 (exec () 또는 test () 에 전달 하 는 문자열)  left Context, 짧 은 이름 은 $^ 입 니 다. 지난번 에 일치 하 는 하위 문자열 입 니 다.  rightContext, 짧 은 이름 은 $^ 입 니 다. 지난번 에 일치 한 하위 문자열 입 니 다.  lastMatch, 짧 은 이름 은 $&, 마지막 일치 하 는 문자  lastParen, 짧 은 이름 은 $+, 마지막 으로 일치 하 는 그룹  multiline, 짧 은 이름 은 $* 입 니 다. 모든 표현 식 이 다 중 모드 의 불 값 을 사용 할 지 여 부 를 지정 하 는 데 사 용 됩 니 다. 다른 속성 과 달리 마지막 으로 실 행 된 일치 에 의존 하지 않 습 니 다. 모든 정규 표현 식 의 m 옵션 을 설정 할 수 있 습 니 다. RegExp. mliline = "true";IE 와 Opera 가 실행 되 지 않도록 주의 하 세 요.  

 var sToMatch = "this has been a short, short summer"; 
 var reShort = /(s)hort/g; 
 reShort.test(sToMatch); 
 alert(RegExg.input); //"this has been a short, short summer"; 
 alert(RegExg.leftContext); //"this has been a "; 
 alert(RegExg.rightContext); //", short summer"; 
 alert(RegExg.lastMatch); //"short" 
 alert(RegExg.lastParen); //"s" 
 
compile() //        
alert(reCat.exec("a cat, a Cat, a cAt caT")); //      ,               ,         
alert(reCat.test("cat")); //true,          ,   true   false。 

정규 표현 식 의 String 대상 을 지원 하 는 방법 

var sToMatch = "a bat, a Cat, a fAt, a faT cat"; 
var reAt = /at/gi; 
alert(sToMatch.match(reAt)); //                    
alert(sToMatch.search(reAt)); //               3,    g search()      
alert(sToMatch.replace(reAt, "Dog")); //              
alert(sToMatch.replace(reAt, function(sMatch){ 
 return "Dog"; 
})); 
alert(sToMatch.split(/\,/)); //             

상용 모드  날짜: / (?: 0 [1 - 9] | [12] [0 - 9] | 3 [01]) \ / (?: 0 [1 - 9] | 1 [0 - 2]) \ / (?: 19 | 20 \ d {2}) /  URL:/^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$/  이메일 주소: / ^ (?: \ w + \.?) * \ w + @ (?: \ w + \.?) * \ w + $/  국내 전화번호: d {3} - d {8} | d {4} - d {7}  텐 센트 QQ 번호: [1 - 9] [0 - 9] {4,}  우편 번호: [1 - 9] d {5} (?! d)  신분증: d {15} | d {18}  ip 주소: d + d + d + d + d +  중국어 문자: [u4e00 - u9fa 5]  두 바이트 문자 (한자 포함): [^ x00 - xff]      String.prototype.len=function(){return this.replace([^x00-xff]/g,"aa").length;}  전역 문자: / [^ uFF 00 - ufff] / g  일치 하 는 숫자: 

^[1-9]\d*$    //      
^-[1-9]\d*$   //      
^-?[1-9]\d*$   //     
^[1-9]\d*|0$  //      (    + 0) 
^-[1-9]\d*|0$   //      (    + 0) 
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$   //       
^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$  //       
^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$  //      
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$   //       (     + 0) 
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$  //       (     + 0) 

전면적 이 고 상세 하 며 느낌 이 좋 은 것 은 이 글 을 잘 소장 하 세 요. js 정규 표현 식 은 매우 중요 한 학습 부분 입 니 다. 여러분 은 반드시 열심히 공부 하 세 요.

좋은 웹페이지 즐겨찾기