JS 정규식에서 RegExp 객체 및 대괄호 사용 정보
- 不言원래의
- 2018-06-30 13:49:571664검색
다음 기사에서는 JS 정규식에서 RegExp 객체와 대괄호 사용에 대해 간략하게 설명합니다. 내용이 꽤 괜찮아서 지금 공유해서 참고용으로 올려드리겠습니다.
RegExp 객체 생성:
기존 정규식은 직접 수량, 즉 슬래시 "/"로 묶인 문자를 사용하여 생성할 수 있습니다. 그러나 매개변수 변경이 필요한 환경에서는 RegExp() 생성자가 더 나은 선택입니다.
var reg1 = /'w+'/g;
var reg2 = new RegExp(''\w+'','g' );
두 가지 생성 방법을 비교하면 RegExp의 첫 번째 매개변수는 생성될 일반 문자열입니다. 한편으로는 직접적인 표현이 아니기 때문에 슬래시 "/"로 묶이지 않습니다. " ' " 표시와 이스케이프 기호 " "는 문자열에서 두 번 이스케이프되어야 합니다.
또한 직접 변수이든 RegExp() 생성자이든 새로운 RegExp 개체가 생성되어 변수에 할당됩니다.
match()와 exec()의 유사점과 차이점:
match와 exec는 문자열을 정규식과 일치시키는 일반적인 방법입니다. 두 가지로 구현된 함수는 비슷하지만 약간의 차이점이 있습니다.
1. 사용법
match는 문자열 패키징 개체의 방법입니다. 사용법: String.match(RegExp)
exec는 정규 표현식입니다. object 메서드, 사용법: RegExp.exec(String);
2. 반환된 결과
RegExp가 전역 플래그 "g"를 설정하지 않은 경우:
둘의 반환 결과는 동일합니다. 즉, 일치하는 값이 없으면 null을 반환하고, 일치하는 값이 있으면 배열(let array)을 반환한다. array[0]은 일치하는 문자열이고, array[1], array[2]...는 정규식에서 괄호로 묶인 하위 문자열 $1, $2...에 해당합니다. 동시에 배열에는 두 가지 속성이 있습니다. array.index는 일치하는 문자열의 초기 위치를 나타내고 array.input은 검색되는 문자열을 나타냅니다.
RegExp에 전역 플래그 "g"가 설정된 경우:
match는 값이 있으면 배열을 반환합니다. 배열의 각 항목은 일치하는 모든 문자열을 차례로 나타내므로 괄호와 일치하는 하위 문자열이 더 이상 없습니다. 현재 배열에는 인덱스 속성과 입력 속성이 없습니다.
exec는 전역 플래그 "g"가 없는 것과 동일하게 동작합니다. 이때 반환되는 것은 배열 배열이고, array[0]은 현재 일치하는 문자열이고, array[1], array[2]...는 현재 일치하는 항목 아래 괄호와 일치하는 문자열입니다. 이때, 원본 문자열에서 일치하는 문자열의 끝 이후의 위치를 나타내는 RegExp 객체의 lastIndex 속성에 주목해야 합니다. 더 이상 일치하는 결과가 없으면 lastIndex 속성이 0으로 설정됩니다. 따라서 lastIndex 루프를 사용하여 일치하는 모든 문자열을 찾을 수 있습니다.
여러 매칭 방법 지원:
js code
var testStr = "now test001 test002";
var re = /test(\d+)/ig;
var r = "";
while(r = re.exec(testStr)) {
alert(r[0] + " " + r[1]);
} 또한 testStr.match(re)를 사용할 수도 있지만 이 경우에는 없습니다. g 옵션을 사용하면 첫 번째 일치 항목만 얻을 수 있습니다.
1. 정규식 규칙
1.1 일반 문자
다음 장에서 특별히 정의되지 않은 글자, 숫자, 한자, 밑줄, 구두점은 모두 "일반 문자"입니다. 표현식의 일반 문자는 문자열과 일치할 때 동일한 문자와 일치합니다.
예제 1: "abcde"라는 문자열을 일치시킬 때 일치하는 결과는 다음과 같습니다. 일치하는 내용은 "c"입니다. 일치하는 위치는 2에서 시작하여 3에서 끝납니다. (참고: 아래 첨자가 0으로 시작하는지 1로 시작하는지 여부는 현재 프로그래밍 언어에 따라 다를 수 있습니다.)
예 2: "bcd"라는 표현식, "abcde" 문자열을 일치시킬 때 일치 결과는 다음과 같습니다. 성공 일치; is: "bcd"; 일치하는 위치는 1에서 시작하여 4에서 끝납니다.
1.2 단순 이스케이프 문자
작성하기 불편한 일부 문자는 앞에 "/"를 추가하는 방법을 사용하세요. 사실 우리 모두는 이 캐릭터에 익숙합니다.
expression |
은 |
/r과 일치할 수 있습니다. /n |
은 캐리지 리턴 및 줄 바꿈을 나타냅니다. |
/t |
탭 |
// |
은 "/" 자체를 나타냅니다 |
이후 장에서 특별한 용도로 사용되는 다른 구두점도 있습니다. 구두점 앞에 "/"를 추가하면 기호 자체를 나타냅니다. 예를 들어 ^ 및 $에는 특별한 의미가 있습니다. 문자열에서 "^" 및 "$" 문자를 일치시키려면 표현식을 "/^" 및 "/$"로 작성해야 합니다.
expression |
은 |
/^ |
이 ^ 기호 자체와 일치합니다. |
|
/$ |
$ 기호 자체와 일치 |
/. |
은 소수점(.) 자체와 일치합니다. |
이 이스케이프된 문자의 일치 방법은 "일반 문자"와 유사합니다. 동일한 문자와도 일치합니다.
예제 1: 문자열 "abc$de"와 일치하는 경우 "/$d"라는 표현은 다음과 같습니다. 일치하는 내용은 "$d"입니다. 일치하는 위치는 3에서 시작하여 끝납니다. 5시에.
1.3 '여러 문자'와 일치할 수 있는 표현식
정규식의 일부 표현 방법은 '여러 문자' 중 하나와 일치할 수 있습니다. 예를 들어 "/d"라는 표현식은 모든 숫자와 일치할 수 있습니다. 어떤 문자와도 일치할 수 있지만 여러 개가 아닌 하나만 일치할 수 있습니다. 이는 포커 게임과 같습니다. 킹과 킹은 어떤 카드든 교체할 수 있지만 카드는 하나만 교체할 수 있습니다.
expression |
은 |
/d |
0에서 9까지의 숫자 |
/w와 일치할 수 있습니다. |
any 문자, 숫자 또는 밑줄 , 즉 A~Z, a~z, 0~9,_ |
/s |
중 하나 공백, 탭, 폼 피드 및 기타 공백 문자 포함 |
. |
소수점은 개행 문자(/n)를 제외한 모든 문자와 일치할 수 있습니다. |
예 1: 일치하는 표현식 "/d/d" "abc123"이 사용되는 경우, 일치 결과는 성공입니다. 일치하는 내용은 "12"입니다. 일치하는 위치는 3에서 시작하여 5에서 끝납니다.
예 2: "a./d"라는 표현에서 "aaa100"과 일치하면 일치 결과는 다음과 같습니다. 일치하는 내용은 "aa1"입니다. 일치하는 위치는 1에서 시작하여 4에서 끝납니다.
1.4 '여러 문자'와 일치할 수 있는 사용자 정의 표현식
어느 문자와도 일치할 수 있는 일련의 문자를 포함하려면 대괄호 [ ]를 사용하세요. [^]를 사용하면 해당 문자를 제외한 모든 문자와 일치하는 일련의 문자를 포함할 수 있습니다. 마찬가지로, 그 중 어느 하나라도 일치할 수는 있지만, 여러 개일 수는 없고 하나만 일치할 수 있습니다.
expression |
은 |
[ab5@] |
과 일치합니다. "a" 또는 "b" 또는 "5" 또는 "@" |
[^ abc] |
는 "a","b","c" |
[f-k] |
는 "f"~"k"와 일치합니다. 모든 문자 |
[^A-F0-3] |
은 "A"~"F","0"~"3"을 제외한 모든 문자 |
예 1: "[bcd][bcd]" 표현식이 "abc123"과 일치하는 경우 일치하는 내용은 "bc"입니다. 일치하는 위치는 1에서 시작하여 3에서 끝납니다.
예 2: "[^abc]" 표현식이 "abc123"과 일치하는 경우 일치하는 내용은 "1"입니다. 일치하는 위치는 3에서 시작하여 4에서 끝납니다.
1.5 일치 횟수를 수정하는 특수 기호
이전 장에서 언급한 표현식은 한 가지 유형의 문자만 일치할 수 있는지, 여러 문자 중 하나와 일치할 수 있는지 여부는 한 번만 일치할 수 있습니다. 표현식과 일치 항목 수를 수정하는 특수 기호를 사용하면 표현식을 다시 작성하지 않고도 반복적으로 일치시킬 수 있습니다.
사용 방법은 "수정 표현" 뒤에 "횟수 수정"을 붙이는 것입니다. 예를 들어 "[bcd][bcd]"는 "[bcd]{2}"로 쓸 수 있습니다.
Expression |
Function |
{n} |
n번 반복되는 표현식(예: "/w{2}"는 "/w/w"와 동일) "a{5}"는 "aaaaa" |
{m,n} |
표현식은 최소 m번, 최대 n번 반복됩니다. 예: "ba{1,3" }"는 "ba", "baa" 또는 "baaa"와 일치할 수 있습니다. |
{m,} |
표현식은 최소한 m번 반복됩니다(예: "/w/d{2,}). "는 "a12", "_456", "M12344"와 일치할 수 있습니다... |
? |
는 표현식 0 또는 1번과 일치하며, 이는 {0,1}과 동일합니다. 예: "a[ cd]?"는 "a","ac","ad"와 일치할 수 있습니다 |
+ |
표현식은 적어도 한 번 나타납니다. 이는 {1,}과 동일합니다. 예: "a+b" can "ab", "aab","aaab" 일치... |
* |
표현식은 나타나지 않거나 여러 번 나타납니다. 예를 들면 다음과 같습니다: "/ ^*b"는 "b"," ^^^b"와 일치할 수 있습니다... |
예 1: "/d+/.?/d*" 표현식이 "It Cost $12.5"와 일치하는 경우 일치하는 항목은 다음과 같습니다. 결과는 성공입니다. 일치하는 내용은 "12.5"입니다. 일치하는 위치는 10에서 시작하여 14에서 끝납니다.
예 2: "go{2,8}gle"이라는 표현이 "Ads by goooooogle"과 일치하는 경우 일치하는 내용은 다음과 같습니다. 일치하는 콘텐츠는 "goooooogle"입니다. 17시에.
1.6 추상적 의미를 나타내는 기타 특수 기호
일부 기호는 표현에서 추상적 특수 의미를 나타냅니다.
| $ | ||||||||||||||
| /b | ||||||||||||||
| ( ) | (1). 일치하는 수를 수정하면 괄호 안의 표현식이 전체적으로 수정될 수 있습니다 (2) 일치 결과를 얻을 때 괄호 안의 표현식과 일치하는 내용을 개별적으로 얻을 수 있습니다 |
예 5: "Tom|Jack"이라는 표현식은 "I'm Tom, he is Jack"과 일치합니다. ", 일치 결과는 성공입니다. 일치하는 내용은 "Tom"입니다. 일치하는 위치는 4에서 시작하여 7에서 끝납니다. 다음 일치 시 일치 결과는 다음과 같습니다. 일치된 내용은 "Jack"입니다. 일치하는 위치는 15에서 시작하여 19에서 끝납니다. | 예 6: "(go/s*)+" 표현식이 "Let's go go go!"와 일치하면 일치 결과는 다음과 같습니다. 일치하는 내용은 "go go go"입니다. 6시에 끝나고 14시에 끝납니다. 예 7: "\(/d+/.?/d*)"라는 표현이 "＄10.9,\20.5"와 일치하면 일치 결과는 다음과 같습니다. 일치하는 내용은 "\20.5"입니다. 도달 시간은 6시부터 10시까지입니다. 대괄호 범위만 얻어서 일치하는 내용은 "20.5"입니다. |
| 2.1 일치 횟수에 있어서 탐욕과 비탐욕 |
(d)(/w+)
"/w+" "xxxdxxxd"
| (d)(/w+)(d) | "/w+"는 첫 번째 "d"와 마지막 "d" 뒤의 모든 문자와 일치합니다. "xxxdxxx" 사이의 모든 문자입니다. "/w+"는 마지막 "d"와도 일치할 수 있지만 전체 표현식을 성공적으로 일치시키기 위해 "/w+"는 일치할 수 있었던 마지막 "d"를 "포기"할 수 있습니다 | ||||
expression |
일치 결과 |
(d)(/w+?) |
"/w+?" 가능한 한 첫 번째 "d" 뒤의 문자와 덜 일치합니다. 결과는 다음과 같습니다. "/w+?"는 하나의 "x" |
(d)(/w+?)(d) | for 전체 표현식이 성공적으로 일치하려면 "/w+?"가 "xxx"와 일치해야 다음 "d"가 일치해야 전체 표현식이 성공적으로 일치합니다. 따라서 결과는 다음과 같습니다. "/w+?"는 "xxx" |
추가 사례는 다음과 같습니다.
예 1: 표현식 "b6c5a531a458a2e790c1fd6421739d1c(.*)b90dd5946f0946207856a8a37f441edf" 및 문자열 "b6c5a531a458a2e790c1fd6421739d1ce388a4556c0f65e1904146cc1a846beeaa94b3e26ee717c64999d7867364b1b4a3< /td> ; b6c5a531a458a2e790c1fd6421739d1ce388a4556c0f65e1904146cc1a846beebb94b3e26ee717c64999d7867364b1b4a3b90dd5946f0946207856a8a37f441edf" 일치 시 일치 결과는 다음과 같습니다. 일치하는 콘텐츠는 "b6c5a531a458a2e790c1fd6421739d1ce388a4556c0f65e1904146cc1a846beeaa94b3e26ee717c64999d7867364b1b4a3 /td>b6c5a531a458a2e790c1fd6421739d1ce388a4556c0f65e1904146cc1a846beebb94b3e26ee717c64999d7867364b1b4a3b90dd5946f0946207856a8a37f441edf"인 경우 표현식의 "b90dd5946f0946207856a8a37f441edf"는 문자열의 마지막 "4f8426b303fd482c2b5cad5323c6ce0d'가 일치합니다.
예 2: 대조적으로 "b6c5a531a458a2e790c1fd6421739d1c(.*?)b90dd5946f0946207856a8a37f441edf" 표현식이 예 1의 동일한 문자열과 일치하면 "b6c5a531a458a2e790c1fd6421739d1ce388a4556c0f65e1904146cc1a846bee aa6fb279ad3fd4344cbdd93aac6ad173acb90dd5946f0946207856a8a37f441edf", 다음 항목을 다시 일치시키면 두 번째 "b6c5a531a458a2e790c1fd6421739d1ce388a4556c0f65e1904146cc1a846beebb94b3e26ee717c64999d7867364b1b4a3b90dd5946f0946207856a8a37f441edf"를 얻을 수 있습니다.
2.2 역참조 /1, /2...
표현식이 일치하면 표현식 엔진은 괄호 "( )"에 포함된 표현식과 일치하는 문자열을 기록합니다. 일치 결과를 얻을 때 괄호 안의 표현식과 일치하는 문자열을 별도로 얻을 수 있습니다. 이는 이전 예제에서 여러 번 설명되었습니다. 실제 적용에서 특정 경계를 사용하여 검색하고 구하는 내용에 경계가 포함되지 않은 경우 괄호를 사용하여 원하는 범위를 지정해야 합니다. 예를 들어, 이전의 "b6c5a531a458a2e790c1fd6421739d1c(.*?)b90dd5946f0946207856a8a37f441edf"입니다.
실제로 "괄호 안의 표현식과 일치하는 문자열"은 일치가 완료된 후에 사용할 수 있을 뿐만 아니라 일치 과정에서도 사용할 수 있습니다. 표현식 뒤의 부분은 이전의 "이미 문자열과 일치하는 괄호 안의 부분 일치"를 참조할 수 있습니다. 참조 방법은 "/"에 숫자를 더한 것입니다. "/1"은 첫 번째 대괄호 쌍에 일치하는 문자열을 나타내고, "/2"는 두 번째 대괄호 쌍에 일치하는 문자열을 나타냅니다. 한 쌍의 대괄호에 다른 대괄호 쌍이 포함된 경우에도 마찬가지입니다. 외부 쌍 레이어의 괄호가 먼저 정렬됩니다. 즉, 왼쪽 대괄호 "("가 먼저 있는 쌍이 먼저 정렬되고, 그러면 이 쌍이 먼저 정렬됩니다.
예는 다음과 같습니다.
예 1: 표현식 "('|")(.*?)(/ 1 )" " 'Hello', "World" "를 일치시키면 일치 결과는 성공입니다. 일치하는 내용은 " 'Hello' "입니다. 다음 항목을 다시 일치시키면 " "World" "가 일치할 수 있습니다.
예 2: "(/w)/1{4,}" 표현식이 "aa bbbb abcdefg ccccc 111121111 999999999"와 일치하면 일치 결과는 다음과 같습니다. 일치하는 콘텐츠가 다시 "ccccc"이면 999999999를 얻게 됩니다. . 이 표현식에서는 "/w" 범위의 문자가 5번 이상 반복되어야 합니다. "/w{5,}"와의 차이점에 유의하세요.
예 3: 표현식 "4a15099835c6dc15f5ce8fbb367d89a3.*?2ee782f0106f0749f2e5b493ad47d49b"는 "acf88b8b14427de2d14ba15ccba4260bb90dd5946f0946207856a8a37f441edf"는 일치 결과가 성공합니다. "b90dd5946f0946207856a8a37f441edf"가 일치하지 않으면 다른 일치로 변경되면 일치가 실패합니다. 성공적으로 일치할 수 있습니다.
2.3 사전 검색, 역 사전 검색, 일치 없음
이전 장에서는 "^", "$", "와 같은 추상적 의미를 나타내는 몇 가지 특수 기호에 대해 설명했습니다. /b". 모두 한 가지 공통점이 있습니다. 즉, 문자 자체와 일치하지 않고 "문자열의 양쪽 끝" 또는 "문자 사이의 간격"에만 조건을 첨부한다는 것입니다. 이 개념을 이해한 후에는 섹션 "두 끝" 또는 "간극"에 조건을 부여하는 또 다른 보다 유연한 표현 방법을 계속해서 소개할 예정입니다.
앞으로 사전 검색: "(?=xxxxx)", "(?!xxxxx)"
형식: " (?=xxxxx)"는 일치하는 문자열에서 자신이 위치한 "gap" 또는 "양쪽 끝"에 조건을 붙인다: gap의 오른쪽은 xxxxx 부분의 표현과 일치할 수 있어야 한다. 이는 이 간격에 대한 추가 조건으로만 사용되며, 이 간격 뒤의 문자를 실제로 일치시키는 후속 표현식에 영향을 주지 않습니다. 이는 앞뒤의 문자를 일치시키지 않는 "/b"와 유사합니다.
예 1: "Windows (?=NT|XP)"라는 표현은 "Windows 98, Windows NT, Windows 2000"에만 해당됩니다. "Windows NT"의 "Windows"와 일치하며 다른 "Windows" 단어는 일치하지 않습니다.
예 2: "(/w)((?=/1/1/1)(/1))+" 표현식이 "aaa ffffff 999999999" 문자열과 일치하는 경우 처음 6개의 "f"와 일치합니다. 4는 9개의 "9" 중 처음 7개와 일치할 수 있습니다. 이 표현식은 다음과 같이 읽을 수 있습니다. 문자와 숫자가 4회 이상 반복되면 마지막 2자리 앞 부분이 일치합니다. 물론, 이 표현은 꼭 이렇게 쓸 필요는 없고 단지 예시용으로만 사용된 것입니다.
형식: 공백 오른쪽에 있는 "(?!xxxxx)"는 표현식의 xxxxx 부분과 일치해서는 안 됩니다.
예 3: "((?!/bstop/b).)+"라는 표현이 "fdjka ljfdl stop fjdsla fdj"와 일치하는 경우 "stop"이 없으면 처음부터 일치합니다. 문자열 stop"에서는 전체 문자열과 일치합니다.
예 4: "do(?!/w)" 표현식이 "done, do, dog" 문자열과 일치하는 경우 "do"만 일치할 수 있습니다. 이 예에서 "do" 뒤에 "(?!/w)"를 사용하면 "/b"를 사용하는 것과 동일한 효과가 있습니다.
역방향 사전 검색: "(?aa5865467148ae06297349ef69ec55c7/: 많은 프로그래밍 언어에서 이스케이프 문자로 사용됩니다. 일반적으로
/ 기호 뒤에 일반 문자 c가 오면 /c는 특별한 의미를 나타냅니다. 예를 들어, n은 원래 문자 n을 나타내지만 /n은 개행 문자를 나타냅니다.
/ 기호 뒤에 특수 문자 c가 오면 /c는 일반 문자 c를 나타냅니다. 예를 들어 /는 일반적으로 이스케이프 문자로 사용되지만 //는 일반 문자 /를 나타냅니다.
Javascript의 정규식에서 /의 사용법은 프로그래밍 언어에 따라 특수 문자 테이블이 다를 수 있다는 점을 제외하면 위와 동일합니다.
2>^：匹配输入字符串的起始端，如果是多行匹配，即表达式的附加参数中含有m，则也在一个换行符后匹配。
例子：
/^B/匹配 “Bab Bc ”中的第一个B
例子2：
/^B/gm匹配
“Badd B
cdaf
B dsfB”
中的第一行第一个B，第三行中的第一个B
3>$：匹配输入字符创的尾端，如果是多行匹配，即表达式的附加参数中含有m，则也在一个换行符前匹配。
与^的用法相反。
例子：/t$/匹配“bat”中的t，但是不匹配“hate”中的t
例子2：/t$/匹配
“tag at
bat”
中第一行的最后一个t和第二行的t。
4>*：匹配前一个字符0次或多次。
例子：/ab*/匹配“dddabbbbc”中的“abbbb”，也匹配“ddda”中的“a”
5>+：匹配前一个字符1次或多次。
例子：/ab+/匹配“dddabbbbc”中的“abbbb”，但不匹配“ddda”
与后面的{1,}（原型：{n,}）的用法类似
6>?：?的用法比较特殊，一般来说它用来对前一个字符做0次或1次匹配，但是它有另外两种特殊的用法：
如果紧跟在*、+、?和{ }之后，则表示原始匹配的最小次数匹配，例如：
/ba*/本来匹配“bbbaaaa”中的“baaaa”，但是/ba*?/则匹配“bbbaaaa”中的“b”（因为*表示0次或多次匹配，而加?应该表示最少次数匹配，即0次匹配）。
同理：/ba+?/则匹配“baaaa”中的“ba”。
作为语法结构符号，使用于前置断言中，即后面要说到的x(?=y)和x(?!=y)
7>.：小数点中的“.”号，匹配任何一个单独的字符，但是换行符除外。
标准中总共有哪些字符？请参考：字符集
例如：/a.b/匹配“acbaa”中的“acb”，但是不匹配“abbb”。
8>(x)：表示匹配x(并非特指字符x或者特指一个字符，x表示一个字符串)，而且匹配会被记住，在语法中这种()被称为“capturing parentheses ”，即捕捉用的小括号。
匹配会被记住，是因为在表达式提供的函数中，有些函数返回一个数组，该数组会保存所匹配的所有字符串，例如exec()函数。
另外还要注意()中的x被记住的前提是匹配x。
例子1：
var regx=/a(b)c/; var rs=regx.exec(“abcddd”);
从上面可以看出,/a(b)c/匹配“abcddd”中的“abc”，因为()的原因，b也会记录下来，因此rs返回的数字内容为：
{abc,b}
例子2：
var regx=/a(b)c/; var rs=regx.exec(“acbcddd”);
rs返回null，因为/a(b)c/不匹配“acbcddd”，所以()中的b不会被记录下来（尽管字符串中含有b）
9>(?:x)：匹配x，但不会记住x，这种格式中的()被称为“non-capturing parentheses ”，即非捕捉用的小括号。
例子：
var regx=/a(?:b)c/; var rs=regx.exec(“abcddd”);
从上面可以看出,/a(?:b)c/匹配“abcddd”中的“abc”，因为(?:)的原因，b不会记录下来，因此rs返回的数字内容为：
{abc}
10>X(?=y)：匹配x，仅当后面紧跟着y时。如果符合匹配，则只有x会被记住，y不会被记住。
例子：
var regx=/user(?=name)/; var rs=regx.exec(“The username is Mary”);
结果：匹配成功，而且rs的值为{user}
11>X(?!y)：匹配x，仅当后面不紧跟着y时。如果符合匹配，则只有x会被记住，y不会被记住。
例子：
var regx=/user(?!name)/; var rs=regx.exec(“The user name is Mary”);
结果：匹配成功，而且rs的值为{user}
例子2：
var regx=//d+(?!/.)/; var rs=regx.exec(“54.235”);
结果：匹配成果，rs的值为{5}，不匹配54是因为54后面跟着“.”号，当然235也匹配，但是由于exec方法的行为，235不会被返回
12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。
例子：
var regx=/beijing|shanghai/; var rs=regx.exec(“I love beijing and shanghai”);
结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。
13>{n}：匹配前一个字符的n次出现。
n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。
例子：
var regx=/ab{2}c/;
var rs=regx.exec(“abbcd”);结果：匹配成功，rs的值为：{abbc}。
14>{n,}：匹配前一个字符的至少n次出现。
例子：
var regx=/ab{2,}c/;
var rs=regx.exec(“abbcdabbbc”);结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。
15>{n,m}：匹配前一个字符的至少n次最多m次的出现。
只要n与m为数字，而且m>=n就不会报语法错误。
例子：
var regx=/ab{2,5}c/;
var rs=regx.exec(“abbbcd”);结果：匹配成功，rs的值为：{abbbc}。
例子2：
var regx=/ab{2,2}c/;
var rs=regx.exec(“abbcd”);结果：匹配成功，rs的值为：{abbc}。
例子3：
var regx=/ab(2,5)/; var rs=regx.exec(“abbbbbbbbbb”);
结果：匹配成功，rs的值为：{abbbbb}，这说明，如果前一个字符出现多于m次，则只匹配m次。另外：
var regx=/ab(2,5)c/;
var rs=regx.exec(“abbbbbbbbbbc”);
结果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b后面是c，但字符串中5个b之后还是b所以会报错。
16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[x-z]。
例子：
var regx=/a[bc]d/; var rs=regx.exec(“abddgg”);
结果：匹配成功，rs的值为：{abd}
例子2：
var regx=/a[bc]d/; var rs=regx.exec(“abcd”);
结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。
17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^x-z]。
例子：
var regx=/a[^bc]d/; var rs=regx.exec(“afddgg”);
结果：匹配成功，rs的值为：{afd}
例子2：
var regx=/a[^bc]d/; var rs=regx.exec(“abd”);
结果：匹配失败，rs的值为：。
18>[/b]：匹配退格键。
19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。
例子：
var regx=//bc./; var rs=regx.exec(“Beijing is a beautiful city”);
结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。
20>/B：代表一个非单词边界。
例子：
var regx=//Bi./; var rs=regx.exec(“Beijing is a beautiful city”);
结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。
21>/cX，匹配一个控制字符。例如， /cM 匹配一个 Control-M 或
回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一
个原义的 'c' 字符。（实际的例子还需补充）
21>/d：匹配一个数字字符，等同于[0-9]。
例子：
var regx=/user/d/; var rs=regx.exec(“user1”);
结果：匹配成功，rs的值为：{user1}
22>/D：匹配一个非数字字符，等同于[^0-9]。
例子：
var regx=/user/D/; var rs=regx.exec(“userA”);
结果：匹配成功，rs的值为：{userA}
23>/f：匹配一个换页符。
24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。
例子：
var regx=/a/nbc/m; var str=“a bc”; var rs=regx.exec(str);
结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。
25>/r：匹配一个回车符
26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029].
例子：
var regx=//si/; var rs=regx.exec(“Beijing is a city”);
结果：匹配成功，rs的值为：{ i}
27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].
例子：
var regx=//si/; var rs=regx.exec(“Beijing is a city”);
结果：匹配成功，rs的值为：{ei}
28>/t：匹配一个tab
例子：
var regx=/a/tb/; var rs=regx.exec(“a bc”);
结果：匹配成功，rs的值为： {a bc}
29>/v：匹配一个竖向的tab
30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。
例子：
var regx=//w/; var rs=regx.exec(“$25.23”);
结果：匹配成功，rs的值为：{2}
31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。
例子：
var regx=//w/; var rs=regx.exec(“$25.23”);
结果：匹配成功，rs的值为：{$}
32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。
例子：
var regx=/user([,-])group/1role/; var rs=regx.exec(“user-group-role”);
结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。
33>/0：匹配一个NUL字符。
34>/xhh：匹配一个由两位16进制数字所表达的字符。
35>/uhhhh：匹配一个由四位16进制数字所表达的字符。
3，表达式操作
1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。
2）表达式对象（RegExp）方法：
1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如：
var regx=//d+/; var rs=regx.exec(“3432ddf53”);
返回的rs值为：{3432}
var regx2=new RegExp(“ab(/d+)c”); var rs2=regx2.exec(“ab234c44”);
返回的rs值为：{ab234c,234}
另外，如果有多个合适的匹配，则第一次执行exec返回一个第一个匹配，此时继续执行exec，则依次返回第二个第三个匹配。例如：
var regx=/user/d/g; var rs=regx.exec(“ddduser1dsfuser2dd”); var rs1=regx.exec(“ddduser1dsfuser2dd”);
则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。
2>test(str)，判断字符串str是否匹配表达式，返回一个布尔值。例如：
var regx=/user/d+/g; var flag=regx.test(“user12dd”);
flag的值为true。
3）String对象方法
1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配
例子：
var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.match(regx);
rs的值为：{user1,user3}
2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。
例子：
var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.search(regx);
rs的值为：0
3>replace(expr,str)，将字符串中匹配expr的部分替换为str。另外在replace方法中，str中可以含有一种变量符号$，格式为$n，代表匹配中被记住的第n的匹配字符串（注意小括号可以记忆匹配）。
例子：
var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.replace(regx,”00”);
rs的值为：003userddd0045
例子2：
var regx=/u(se)r/d/g; var str=“user13userddduser345”; var rs=str.replace(regx,”$1”);
rs的值为：se3userdddse45
对于replace(expr,str)方法还要特别注意一点，如果expr是一个表达式对象则会进行全局替换（此时表达式必须附加参数g，否则也只是替换第一个匹配），如果expr是一个字符串对象，则只会替换第一个匹配的部分，例如：
var regx=“user” var str=“user13userddduser345”; var rs=str.replace(regx,”00”);
rs的值为： 0013userddduser345
4>split(expr)，将字符串以匹配expr的部分做分割，返回一个数组，而且表达式是否附加参数g都没有关系，结果是一样的。
例子：
var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.split(regx);
rs的值为：{3userddd,45}
4，表达式相关属性
1）表达式相关属性，是指和表达式相关的属性，如下面的形式：
var regx=/myexpr/; var rs=regx.exec(str);
其中，和表达式自身regx相关的属性有两个，和表达式匹配结果rs相关的属性有三个，下面将逐一介绍。
2）和表达式自身相关的两个属性：
1>lastIndex，返回开始下一个匹配的位置，注意必须是全局匹配（表达式中带有g参数）时，lastIndex才会有不断返回下一个匹配值，否则该值为总是返回第一个下一个匹配位置，例如：
var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex1=regx.lastIndex; rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex2=regx.lastIndex; rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex3=regx.lastIndex;
上面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。
2>source，返回表达式字符串自身。例如：
var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var source=regx.source;
source的值为user/d
3）和匹配结果相关的三个属性：
1>index，返回当前匹配的位置。例如：
var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var index1=rs.index; rs=regx.exec(“sdsfuser1dfsfuser2”); var index2=rs.index; rs=regx.exec(“sdsfuser1dfsfuser2”); var index3=rs.index;
index1为4，index2为4，index3为4，如果表达式加入参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。
2>input，用于匹配的字符串。例如：
var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var input=rs.input;
input的值为sdsfuser1dfsfuser2。
3>[0]，返回匹配结果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还可以取[1]、[2]等等。例如：
var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var value1=rs[0]; rs=regx.exec(“sdsfuser1dfsfuser2”); var value2=rs[0];
value1的值为user1,value2的值为user2
5，实际应用
1）实际应用一
描述：有一表单，其中有一个“用户名”input域
要求：汉字，而且不能少于2个汉字，不能多于4个汉字。
实现：
<script>
function checkForm(obj){
var username=obj.username.value;
var regx=/^[/u4e00-/u9fa5]{2,4}$/g
if(!regx.test(username)){
alert(“Invalid username!”);
return false;
}
return true;
}
</script>
<form name=“myForm”onSubmit=“return checkForm(this)”>
<input type=“text” name=“username”/>
<input type=“submit” vlaue=“submit”/>
</form>2）实际应用二
描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。
实现：
<script>
function toPlainText(htmlStr){
var regx=/<[^>]*>|<//[^>]*>/gm;
var str=htmlStr.replace(regx,"");
return str;
}
</script>
<form name=“myForm”>
<textarea id=“htmlInput”></textarea>
<input type=“button” value=“submit” onclick=“toPlainText(document.getElementById(‘htmlInput').value”/>
</form>三，小结
1，Javascript正则表达式，我想在一般的程序员之中，使用者应该不是很多，因为我们处理的页面一般都不是很复杂，而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转，富客户端已经被越来越多的人接受，而Javascript就是其中的关键技术，对于复杂的客户端逻辑而言，正则表达式的作用也是很关键的，同时它也是Javascript高手必须要掌握的重要技术之一。
2，为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识，我将前面的一些关键点和容易犯糊涂的地方再系统总结一下，这部分很关键！
总结1：附件参数g的用法
表达式加上参数g之后，表明可以进行全局匹配，注意这里“可以”的含义。我们详细叙述：
1）对于表达式对象的exec方法，不加入g，则只返回第一个匹配，无论执行多少次均是如此，如果加入g，则第一次执行也返回第一个匹配，再执行返回第二个匹配，依次类推。例如
var regx=/user/d/;
var str=“user18dsdfuser2dsfsd”;
var rs=regx.exec(str);//此时rs的值为{user1}
var rs2=regx.exec(str);//此时rs的值依然为{user1}如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2}
通过这个例子说明：对于exec方法，表达式加入了g，并不是说执行exec方法就可以返回所有的匹配，而是说加入了g之后，我可以通过某种方式得到所有的匹配，这里的“方式”对于exec而言，就是依次执行这个方法即可。
2）对于表达式对象的test方法，加入g于不加上g没有什么区别。
3）对于String对象的match方法，不加入g，也只是返回第一个匹配，一直执行match方法也总是返回第一个匹配，加入g，则一次返回所有的匹配（注意这与表达式对象的exec方法不同，对于exec而言，表达式即使加上了g，也不会一次返回所有的匹配）。例如：
var regx=/user/d/;
var str=“user1sdfsffuser2dfsdf”;
var rs=str.match(regx);//此时rs的值为{user1}
var rs2=str.match(regx);//此时rs的值依然为{user1}如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2}
4）对于String对象的replace方法，表达式不加入g，则只替换第一个匹配，如果加入g，则替换所有匹配。（开头的三道测试题能很好的说明这一点）
5）对于String对象的split方法，加上g与不加g是一样的，即：
var sep=/user/d/; var array=“user1dfsfuser2dfsf”.split(sep);
则array的值为{dfsf, dfsf}
此时sep=/user/d/g，返回值是一样的。
6）对于String对象的search方法，加不加g也是一样的。
总结2：附加参数m的用法
附加参数m，表明可以进行多行匹配，但是这个只有当使用^和$模式时才会起作用，在其他的模式中，加不加入m都可以进行多行匹配（其实说多行的字符串也是一个普通字符串），我们举例说明这一点
1）使用^的例子
var regx=/^b./g;
var str=“bd76 dfsdf
sdfsdfs dffs
b76dsf sdfsdf”;
var rs=str.match(regx);此时加入g和不加入g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，注意如果regx=/^b./m，则也只返回第一个匹配。所以，加入m表明可以进行多行匹配，加入g表明可以进行全局匹配，综合到一起就是可以进行多行全局匹配
2）使用其他模式的例子，例如
var regx=/user/d/;
var str=“sdfsfsdfsdf
sdfsuser3 dffs
b76dsf user6”;
var rs=str.match(regx);此时不加参数g，则返回{user3}，加入参数g返回{user3,user6}，加不加入m对此没有影响。
3）因此对于m我们要清楚它的使用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不加入m，则只能在第一行进行匹配，如果加入m则可以在所有的行进行匹配。我们再看一个^的例子
var regx=/^b./;
var str=“ret76 dfsdf
bjfsdfs dffs
b76dsf sdfsdf”;
var rs=str.match(regx);此时rs的值为null，如果加入g，rs的值仍然为null，如果加入m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以可以继续去下面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g说明，可以去多行进行匹配，但是找到一个匹配后就返回，加入g表明将多行中所有的匹配返回，当然对于match方法是如此，对于exec呢，则需要执行多次才能依次返回）
总结3：
在HTML的textarea输入域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，我们看一个前面我们举过的例子：
var regx=/a/r/nbc/;
var str=“a
bc”;
var rs=regx.exec(str);结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。
以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！
相关推荐：
위 내용은 JS 정규식에서 RegExp 객체 및 대괄호 사용 정보의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!