JS 정규 표현식에 대한 Regexp 객체 및 괄호 사용에 대한 간단한 토론

regexp 객체 생성 :

정기 정규 표현식의 생성은 직접 수행 할 수 있습니다. 즉, 슬래시 "/"로 동봉 된 문자. 그러나 매개 변수 변경이 필요한 환경에서는 regexp () 생성자가 더 나은 선택입니다.

var reg1 =/'/w+'/g;

var reg2 = 새로운 regexp ( '/'// w+/'', 'g');

두 가지 생성 방법을 비교하면 Regexp의 첫 번째 매개 변수는 생성 할 일반 문자열입니다. 한편으로, 그것은 수량의 직접적인 표현이 아니므로 슬래시 "/"로 둘러싸여 있지 않습니다. 대신, 인용 표시 " '"및 Escape Symbol "/"는 문자열에서 2 차 탈출되어야합니다.

또한, 직접 수량이든 Regexp () 생성자이든, 새로운 regexp 객체가 생성되어 변수에 할당됩니다.

match ()와 exec ()의 유사성과 차이점 :

매치와 exec는 정규 표현식의 문자열을 일치시키는 일반적인 방법입니다. 이 둘이 구현 한 기능은 비슷하며 약간의 차이가 있습니다.

1. 사용 방법

일치는 문자열로 개체를 포장하는 방법, 사용법 : String.match (regexp);

exec는 정규 표현식 객체, 사용법입니다 : regexp.exec (string);

2. 결과를 반환했습니다

regexp가 글로벌 플래그 "g"를 설정하지 않으면 :

둘 다의 반환 결과는 동일합니다. 즉, 일치하는 값이 없으면 NULL을 반환하고 일치하는 값이 있으면 배열 (배열)을 반환합니다. 배열 [0]은 일치하는 문자열, 배열 [1], 배열 [2] ... 일반 표현식에서 괄호 일치하는 하위 통과에 해당합니다. 동시에 배열에는 두 가지 속성이 있습니다. Array.index는 일치하는 문자열의 초기 위치를 나타내고 Array.input은 검색되는 문자열을 나타냅니다.

regexp가 글로벌 플래그 "g"세트가있을 때 :

일치 값이 있으면 배열 배열을 반환합니다. 배열의 각 항목은 일치하는 모든 문자열을 나타내므로 괄호와 일치하는 하위 문자열이 더 이상 없습니다. 현재 배열에는 인덱스 속성 및 입력 속성이 없습니다.

Exec는 글로벌 레이블 "G"가없는 성능과 다르지 않습니다. 반환 된 배열, 배열 [0]은 현재 일치하는 문자열, 배열 [1], 배열 [2]는 현재 일치하는 문자열입니다. 현재 REGEXP 객체의 LastIndex 속성에주의를 기울이는데, 이는 원래 문자열에서 일치하는 문자열의 마지막 위치를 나타냅니다. 더 일치하는 결과가 없으면 LastIndex 속성이 0으로 설정됩니다. 따라서 LastIndex 루프를 사용하여 모든 일치하는 문자열을 찾을 수 있습니다.

여러 매칭 방법을 지원합니다.

JS 코드

 var teststr = "지금 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 : 표현 "C"가 문자열 "abcde"와 일치 할 때 일치하는 결과는 다음과 같습니다. 일치하는 내용은 다음과 같습니다. "C"; 일치하는 위치는 : 2에서 시작하고 3시에 끝납니다 (참고 : 첨자는 0 또는 1에서 시작하여 현재 프로그래밍 언어에 따라 다를 수 있습니다).

예 2 : "bcd"표현이 "abcde"문자열과 일치 할 때 일치하는 결과는 다음과 같습니다. 일치하는 내용은 "BCD"; 일치하는 위치는 다음과 같습니다. 1에서 시작하고 4시에 끝납니다.

1.2 간단한 탈출 문자

쓰기에 불편한 일부 문자의 경우 "/"를 전면에 추가하는 방법을 사용하십시오. 우리는 이미이 캐릭터들에 익숙합니다.

다음 장에서는 특별한 구두점이 있습니다. "/"를 앞쪽에 추가 한 후에는 기호 자체를 나타냅니다. 예를 들면 : ^와 $는 특별한 의미가 있습니다. 문자열의 "^"및 "$"문자를 일치 시키려면 표현식을 "/^"및 "/$"로 작성해야합니다.

이 탈출 된 문자의 일치하는 방법은 "일반 문자"와 유사합니다. 또한 같은 캐릭터와 일치합니다.

예 1 : "/$ d"표현식이 문자열 "abc $ de"와 일치 할 때 일치하는 결과는 다음과 같습니다. 일치하는 내용은 "$ d"입니다. 일치하는 위치는 : 3에서 시작하고 5시에 끝납니다.

1.3 '여러 문자'와 일치 할 수있는 표현식

정규 표현식의 일부 표현 방법은 '여러 문자'와 일치 할 수 있습니다. 예를 들어, "/d"표현은 모든 숫자와 일치 할 수 있습니다. 그것은 어떤 문자라도 일치 할 수 있지만, 다중이 아닌 하나 일 수 있습니다. 이것은 포커 카드를 할 때와 같으며, 크고 작은 왕은 모든 카드를 교체 할 수 있지만 하나의 카드 만 교체 할 수 있습니다.

예 1 : "/d/d"표현이 "ABC123"과 일치 할 때 일치 결과는 다음과 같습니다. 일치하는 내용은 "12"; 일치하는 위치는 다음과 같습니다. 3시에 시작하고 5시에 끝납니다.

예 2 : "AAA100"과 일치 할 때 "A./d"표현이있을 때, 일치 결과는 다음과 같습니다. 일치하는 내용은 "AA1"; 일치하는 위치는 다음과 같습니다. 1에서 시작하고 4시에 끝납니다.

1.4 '여러 문자'와 일치 할 수있는 표현식 사용자 정의

사각형 브래킷을 사용하여 일련의 문자를 포함하여 일련의 문자를 포함합니다. [^]을 사용하여 일련의 문자를 포함하는 경우 캐릭터 이외의 캐릭터와 일치 할 수 있습니다. 마찬가지로 마찬가지로, 그 중 하나와 일치 할 수는 있지만 여러 가지가 아닌 하나 일 수 있습니다.

예 1 : "[BCD] [BCD]" "ABC123"표현이 일치 할 때, 일치 결과는 다음과 같습니다. 일치하는 내용은 "BC"; 일치하는 위치는 다음과 같습니다. 1에서 시작하고 3시에 끝납니다.

예 2 : "[^abc]"표현이 "ABC123"과 일치 할 때, 일치 결과는 다음과 같습니다. 일치하는 내용은 "1"; 일치하는 위치는 다음과 같습니다. 3시에 시작하고 4시에 끝납니다.

1.5 일치 수를 수정하는 특수 기호

이전 장에서 언급 한 표현은 한 문자 또는 여러 문자 중 하나만 일치 할 수 있습니다. 일치 수를 수정하는 표현식과 특수 기호를 사용하는 경우 표현식을 반복해서 쓰지 않고 경기를 반복 할 수 있습니다.

이를 사용하는 방법은 "수정 된 표현"이후에 "수정 수"가 배치된다. 예를 들어 : "[bcd] [bcd]"는 "[bcd] {2}"로 쓸 수 있습니다.

예 1 : "/d+/ .?/d*"라는 표현이 "$ 12.5"와 일치하면 일치 결과는 다음과 같습니다. 일치하는 내용은 "12.5"; 일치하는 위치는 다음과 같습니다. 10시에 시작하여 14 세로 끝납니다.

예 2 : "go {2,8} gle"이 "ads by gooooogle"과 일치하는 경우, 일치 결과는 다음과 같습니다. 일치하는 컨텐츠는 다음과 같습니다. "Gooooogle"; 일치하는 위치는 다음과 같습니다. 7시에 시작하여 17 세로 끝납니다.

1.6 추상적 의미를 나타내는 다른 특별한 상징

일부 기호는 표현에서 추상화의 특별한 의미를 나타냅니다.

추가 텍스트 설명은 여전히 상대적으로 추상적이므로 모든 사람이 이해하는 데 도움이되는 예를 제공하십시오.

예 1 : "^aaa"표현이 "xxx aaa xxx"와 일치하면 일치하는 결과는 다음과 같습니다. "^"은 문자열이 시작되는 곳에 일치해야하기 때문에 "aaa"는 "aaa"가 문자열의 시작 부분에있을 때만 일치 할 수 있습니다 : "AAA XXX XXX".

예 2 : "aaa $"표현이 "xxx aaa xxx"와 일치하는 경우 일치하는 결과는 다음과 같습니다. "$"는 문자열의 끝과 일치해야하기 때문에 "AAA $"는 "AAA"가 문자열의 끝에있을 때만 일치 할 수 있습니다 (예 : "XXX XXX AAA".

예 3 : 표현 "./B"시점. "@@@ abc"와 일치하고 일치하는 결과는 다음과 같습니다. 일치하는 내용은 다음과 같습니다. "@A"; 일치하는 위치는 다음과 같습니다. 2에서 시작하고 4시에 끝납니다.

추가 설명 : "/b"는 "^"및 "$"와 유사하며 문자 자체와 일치하지 않지만 일치 결과에서 위치의 왼쪽과 오른쪽에 있어야하며 한쪽은 "/w"범위이고 다른 쪽은 비-"/W"범위입니다.

예 4 : "/bend/b"표현이 "주말, 끝, 종료"와 일치 할 때, 일치하는 결과는 다음과 같습니다. 일치하는 내용은 다음과 같습니다. "END"; 일치하는 위치는 다음과 같습니다. 15에서 시작하고 18 세로 끝납니다.

일부 기호는 표현 내부의 하위 표현 사이의 관계에 영향을 줄 수 있습니다.

예 5 : "Tom | Jack"표현이 문자열 "I 'm Tom, 그는 Jack입니다"와 일치 할 때, 일치하는 결과는 다음과 같습니다. 일치하는 내용은 "Tom"; 일치하는 위치는 다음과 같습니다. 4시에 시작하고 7시에 끝납니다. 다음과 일치하는 경우 일치하는 결과는 다음과 같습니다. 성공; 일치하는 내용은 "잭"입니다. 일치 할 때 : 15에서 시작하여 19 세로 끝납니다.

예 6 : 표현 "(go/s*)+" "Let 's Go Go!"와 일치 할 때 일치하는 결과는 다음과 같습니다. 일치하는 내용은 다음과 같습니다. "Go Go Go"; 일치하는 위치는 다음과 같습니다. 6시에 시작하여 14 세로 끝납니다.

예 7 : "￥ (/d+/.?/d*)"표현이 "￥ 10.9, ￥ 20.5"와 일치하는 경우, 일치 결과는 다음과 같습니다. 일치하는 내용은 다음과 같습니다. "￥ 20.5"; 일치하는 위치는 : 6에서 시작하고 10시에 끝납니다. 브래킷 범위를 따르는 내용은 "20.5"입니다.

2. 정기적 인 표현의 일부 고급 규칙

2.1 경기 시간의 탐욕과 비가비

일치 수를 수정하는 특수 기호를 사용하는 경우 "{m, n}", "{m,}", "?", ","*","+"와 같은 동일한 표현이 다른 시간과 일치 할 수있는 몇 가지 표현 방법이 있습니다. 특정 일치 수는 일치하는 문자열에 따라 다릅니다. 불확실한 수의 반복되는 경기를 갖는이 표현은 일치하는 과정에서 항상 가능한 여러 번 일치합니다. 예를 들어, "dxxxdxxxd"텍스트의 경우 다음은 다음과 같습니다.

"/w+"가 일치 할 때 항상 규칙을 충족하는 많은 문자와 일치한다는 것을 알 수 있습니다. 두 번째 예에서는 마지막 "D"와 일치하지 않지만 전체 표현식을 성공적으로 일치시키는 것입니다. 마찬가지로 "*"및 "{m, n}"가있는 표현식은 가능한 한 많은 것을 일치시키고 "?" 또한 일치하거나 불일치 할 수있을 때 가능한 한 "일치"됩니다. 이 일치하는 원리를 "탐욕"패턴이라고합니다.

비 그리스도 모드 :

"?"추가 일치 수의 특수 상징을 수정 한 후 부호는 가능한 한 다양한 일치 경기를 가진 표현식을 만들 수 있으므로 일치하거나 불일치 할 수있는 표현이 가능한 한 "일치"할 수 있습니다. 이 일치하는 원리는 "비 가비"패턴이라고하며 "바브"패턴이라고도합니다. 일치가 거의 없으면 전체 표현식이 실패하게됩니다. Greedy Mode와 유사하게, 비가비 모드는 전체 표현식을 성공적으로 일치시키기 위해 최소한까지 일치합니다. 예를 들어, "dxxxdxxxd"텍스트의 경우 :

자세한 내용은 다음을 참조하십시오.

예 1 : "<td> (.*) </td>"표현이 문자열과 일치 할 때 "<td> <p> aa </p> </td> <td> <p> bb </p> </td>"와 일치하는 결과는 다음과 같습니다. 일치는 "<td> <p> aa </p> </td>"전체 문자열이고 표현식의 "</td>"는 문자열의 마지막 "</td>"입니다.

예 2 : 대조적으로, "<td> (.*?) </td>"표현이 예 1에서 동일한 문자열과 일치 할 때 "<td> <p> aa </p> </td>"만 얻게됩니다. 다음과 다시 일치하면 두 번째 "<td> <p> bb </p> </td>"가 나타납니다.

2.2 Backreferences /1, /2 ...

표현식이 일치하면 표현 엔진은 브래킷 "()"에 포함 된 표현식과 일치하는 문자열을 기록합니다. 일치하는 결과를 얻을 때, 브래킷에 포함 된 표현식과 일치하는 문자열은 별도로 얻을 수 있습니다. 이것은 이전 예에서 여러 번 입증되었습니다. 실제 응용 분야에서 특정 경계를 검색하는 데 사용하고 검색 할 컨텐츠에는 경계가 포함되어 있지 않으면 브래킷을 사용하여 원하는 범위를 지정해야합니다. 예를 들어, 이전 "<td> (.*?) </td>"입니다.

실제로, "괄호 안에 포함 된 표현식과 일치하는 문자열"은 경기가 끝난 후뿐만 아니라 일치하는 과정에서도 사용할 수 있습니다. 표현식 후 부분은 괄호 안에 "일치하는 하위 매치 문자열"을 참조 할 수 있습니다. 참조 방법은 숫자 "/"를 추가하는 것입니다. "/1"은 첫 번째 브래킷 쌍에 일치하는 문자열을 말하며, "/2"는 두 번째 브래킷 쌍에 일치하는 문자열을 나타냅니다. 한 쌍의 브래킷 쌍에 다른 괄호가 포함되어 있으면 외부 브래킷이 먼저 정렬됩니다. 다시 말해, 쌍에 왼쪽 브래킷이 있으면 "("이전에, 쌍은 먼저 정렬됩니다.

예를 들어 :

예제 1 : 표현 "( '|") (.*?) (/1) ""'hello ","world ""와 일치 할 때는 일치하는 결과가 성공적입니다. 일치하는 내용은 " 'Hello" "입니다."hello "". 다시 일치하는 경우 "World" "와 일치 할 수 있습니다.

예 2 : "(/w)/1 {4,}"표현이 "AA BBBB ABCDEFG CCCCC 111121111 999999999999"와 일치하는 경우 일치 결과는 다음과 같습니다. 일치하는 콘텐츠는 "CCCCCC"입니다. 다음을 다시 일치 시키면 99999999999999999999999999999999999999999999999999999999999999999999999오까지 "/W"범위의 문자가 5 배 이상 반복되어야하며 "/w {5,}"와의 차이에주의를 기울여야합니다.

예제 3 : "<(/w+)/s*(/w+(= ( '|")).*?/4)?/s*)*>. 성공적인.

2.3 사전 검색, 불일치; 리버스 사전 검색, 불일치

이전 장에서는 추상적 의미를 나타내는 몇 가지 특별한 기호에 대해 이야기했습니다 : "^", "$", "/b". 그들은 모두 공통점을 가지고 있습니다. 그들은 스스로 캐릭터와 일치하지 않고 "문자열의 두 끝"또는 "문자 사이의 슬릿"에 조건을 첨부합니다. 이 개념을 이해 한 후,이 섹션에서는 "두 끝"또는 "슬릿"에 조건을 추가하는 또 다른 유연한 표현 방법을 계속 소개합니다.

전방 사전 검색 : "(? = xxxxx)", "(?! xxxxx)"

형식 : "(? = xxxxx)", 일치하는 문자열에서 "슬릿"또는 "두 끝"에 첨부 된 조건은 간격의 오른쪽이 xxxxx 부분의 표현식과 일치 할 수 있어야한다는 것입니다. 이 차이에 대한 추가 조건 일 뿐이 므로이 간격 후에 캐릭터와 진정으로 일치하는 후속 표현식에 영향을 미치지 않습니다. 이것은 "/b"와 유사하며 문자 자체와 일치하지 않습니다. "/b"는 격차 전후의 캐릭터를 가져 와서 판단을 내리며 진정으로 일치시키기 위해 배후의 표현에 영향을 미치지 않습니다.

예 1 : "Windows (? = nt | xp)"이 "Windows 98, Wind

예제 2 : 표현 "(/w) ((? =/1/1/1) (/1))+"문자열 "AAA FFFFFF 999999999"와 일치 할 때 6 중 첫 4 "F"와 9 중 첫 번째 7 "9"와 일치 할 수 있습니다. 이 표현식은 다음과 같이 읽고 해석 할 수 있습니다. 영숫자 번호를 4 배 이상 반복하면 마지막 2 자리 전에 부분과 일치합니다. 물론,이 표현은 이와 같이 쓸 수 없으며 여기서 목적은 데모 목적입니다.

형식 : "(?! xxxxx)", 간격의 오른쪽은 xxxxx 표현과 일치하지 않아야합니다.

예제 3 : 표현 "((?!/bstop/b).)+" "fdjka ljfdl stop fjdsla fdj"와 일치하면 "정지"전에 처음부터 위치로 일치합니다. 문자열에 "정지"가 없으면 전체 문자열이 일치합니다.

예 4 : 표현 "do (?!/w)" "문자열과 일치 할 때만"Doing, do, dog "라는 표현. 이 기사에서는 "do"(?!/w) "와"/b "를 사용하는 효과는 동일합니다.

리버스 프리 검색 : "(? <= xxxxx)", "(? <! xxxxx)"

이 두 형식의 개념은 전방 사전 검색과 유사합니다. 리버스 사전 검색에 대한 요구 사항은 다음과 같습니다. 간격의 "왼쪽". 두 형식은 오른쪽을 판단하기보다는 일치 할 수 있어야하며 지정된 표현식과 일치 할 수 없어야합니다. "Forward Pre-Search"와 마찬가지로 : 이들은 모두 위치에있는 간격에 대한 추가 조건이며 문자 자체와 일치하지 않습니다.

예 5 : 표현 "(? <=/d {4})/d+(? =/d {4})" "1234567890123456"과 일치 할 때 첫 4 숫자를 제외한 중간 8 숫자와 마지막 4 숫자는 일치합니다. jscript.regexp는 리버스 사전 검색을 지원하지 않으므로이 기사를 시연 할 수 없습니다. 다른 많은 엔진은 Java.util.regex 패키지와 같은 역 미리 검색을 지원할 수 있습니다.

3. 다른 일반적인 규칙

이전 설명에는 언급되지 않은 다양한 정규식 엔진 중에서 더 일반적인 규칙도 있습니다.

3.1 표현식에서 "/xxx"및 "/uxxxx"는 문자를 나타내는 데 사용될 수 있습니다 ( "x"는 16 진수를 의미합니다)

3.2 표현식 "/s", "/d", "/w", "/b"표현이 특수한 의미를 나타내는 동안 해당 대문자는 반대 의미를 나타냅니다.

3.3 표현에는 특별한 의미가 있으며 문자 자체의 문자 요약과 일치하도록 "/"를 추가해야합니다.

3.4 괄호 안의 하위 표현 "()". 일치하는 결과가 향후 사용을 위해 기록되지 않으려면 "(? : xxxxx)"형식을 사용할 수 있습니다.

예 1 : 표현 "(? : (/w)/1)+"bbccdd efg "와 일치 할 때 결과는"bbccdd "입니다. 브래킷의 일치 결과 "(? :)"범위는 기록되지 않으므로 "(/w)"는이를 참조하는 데 사용됩니다.

3.5 일반적으로 사용되는 표현식 속성 설정 소개 : IGNORECASE, 단일 라인, 멀티 린, 글로벌

4. 다른 팁

4.1 고급 일반 엔진이 복잡한 일반 구문도 지원한다는 것을 이해하려면이 사이트의 Deelx 일반 엔진 문서를 참조하십시오.

4.2 문자열과 일치하도록 표현식을 요구하려면 문자열에서 부분을 찾는 대신 표현식의 시작과 끝에서 "^"및 "$"를 사용할 수 있습니다. "^/d+$"는 전체 문자열에 숫자 만 필요합니다.

4.3 일치하는 데 필요한 내용이 단어의 일부가 아닌 완전한 단어 인 경우, 표현식의 시작과 끝에서 "/b"를 사용하십시오 : 예 : "/b(if| whighile| else| void|int...)/b"를 사용하여 프로그램의 키워드와 일치하십시오.

4.4 표현식은 빈 문자열과 일치하지 않습니다. 그렇지 않으면 경기는 항상 성공할 것이며 아무것도 일치하지 않을 것입니다. 예를 들면 : "123", "123.", "123.5", ".5"등, 정수, 소수점 및 소수점 번호와 일치하는 표현을 작성할 때는 생략 될 수 있지만 "/d*/ .?/d*"로 표현을 작성하지 않으면이 표현이 성공적으로 일치 할 수 있습니다. 글을 쓰는 더 좋은 방법은 "/d+/.? /d*|/./d+"입니다.

4.5 빈 문자열과 일치 할 수있는 서브 매치에 대해서는 무한대로 루프하지 마십시오. 괄호 안의 서브 표현의 각 부분이 0 번 일치 할 수 있고 전체적으로 괄호가 무한한 시간과 일치 할 수 있다면, 상황이 이전 기사가 말한 것보다 더 심각 할 수 있으며 일치하는 프로세스는 죽은 루프 일 수 있습니다. .NET 정규식과 같은이 상황에서 일부 정규식 엔진은 이제 Dead Loop을 피했지만 여전히이 상황을 피해야합니다. 표현식을 작성할 때 죽은 루프가 발생하면이 관점에서 시작하여 이것이이 기사에서 언급 한 이유인지 알아낼 수 있습니다.

4.6 합리적으로 욕심 많은 모드와 비 기존 모드를 선택하고 주제 토론을 참조하십시오.

4.7 또는 "|" 왼쪽과 오른쪽에서는 "|"의 양쪽에있는 표현이 특정 캐릭터의 한쪽 만 일치하는 것이 가장 좋습니다. 교환 위치로 인해 다르지 않습니다.

Next article-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1. 정규 표현을 정의하십시오

1) 정규 표현식 정의에는 두 가지 형태가 있으며, 하나는 일반적인 방법이고 다른 하나는 생성자 방법입니다.

2) 정상 방법 : var reg =/표현/추가 매개 변수

표현식 : 특정 규칙을 나타내는 문자열, 특정 특수 문자를 사용하여 특수 규칙을 나타내는 데 사용될 수 있으며 나중에 자세히 설명합니다.

추가 매개 변수 : 표현식의 의미를 확장하는 데 사용되며 현재 세 가지 주요 매개 변수가 있습니다.

G : 글로벌 매칭을 수행 할 수 있음을 의미합니다.

I : 그것은 케이스 무감각 일치를 의미합니다.

M : 다중 행 매칭을 수행 할 수 있음을 의미합니다.

위의 세 가지 매개 변수는 자의적으로 결합하여 화합물 의미를 나타낼 수 있으며 물론 매개 변수는 추가되지 않습니다.

예:

var reg =/a*b/;

var reg =/abc+f/g;

3) 생성자 방법 : var reg = new regexp ( "표현", "매개 변수 추가");

"표현"및 "추가 매개 변수"의 의미는 위의 정의 방법과 동일합니다.

예:

var reg = 새로운 regexp ( "a*b");

var reg = 새로운 regexp ( "ABC+F", "G");

4) 일반 방법과 생성자 방법의 차이

정상적인 방식의 표현식은 일정한 문자열이어야하며, 생성자의 표현식은 사용자의 입력 등을 기반으로 한 표현식 매개 변수와 같은 일정한 문자열 또는 JS 변수 일 수 있습니다.

var reg = new regexp (document.forms [0] .exprfiled.value, "g");

2. 발현 패턴

1) 발현 패턴은 발현의 표현 방법 및 스타일, 즉 var reg =/표현/추가 매개 변수에서 "발현"을 설명하는 방법을 지칭한다.

2) 표준화 된 관점에서 표현 패턴은 단순한 패턴과 복합 패턴으로 나뉩니다.

3) 간단한 패턴 : 예를 들어 일반 문자의 조합을 통해 표현 된 패턴을 나타냅니다.

var reg =/abc0d/;

간단한 패턴은 특정 일치만을 나타낼 수 있음을 알 수 있습니다.

4) 복합 패턴 : 와일드 카드 문자로 표현 된 패턴을 나타냅니다.

var reg =/a+b?/w/;

+,? 및 /w는 모두 와일드 카드 문자이며 특별한 의미를 나타냅니다. 따라서 복합 패턴은보다 추상적 인 논리를 표현할 수 있습니다.

복합 모드에서 각 와일드 카드의 의미와 사용에 초점을 맞추겠습니다.

5) 복합 모드에서 특수 문자 설명 :

1>/: 많은 프로그래밍 언어에서 탈출 문자로 사용됩니다. 일반적으로 말하면

/ 기호에 이어 일반 문자 C가 이어지면 / c는 특별한 의미를 나타냅니다. 예를 들어, n은 원래 문자 n을 나타내지 만 /n은 새로운 줄을 나타냅니다.

/ 기호에 이어 특수 문자 C가 이어지면 / c는 일반 문자 c를 나타냅니다. 예를 들어, /는 일반적으로 탈출 문자로 사용되지만 //는 일반 문자 /를 조정하는 데 사용됩니다.

JavaScript의 정규 표현식의 사용은 위와 동일하지만 다른 프로그래밍 언어에서는 특수 문자 테이블이 다를 수 있습니다.

2>^: 입력 문자열의 시작과 일치합니다. 다중선 일치 인 경우, 즉 표현식의 추가 매개 변수에는 M이 포함되어 있으면 Newline 이후에도 일치합니다.

예:

/^b/"BAB BC"에서 첫 번째 B와 일치

Example 2:

/^b/gm 매칭

“Badd b

CDAF

B DSFB”

첫 번째 B의 첫 번째 줄, 세 번째 줄의 첫 번째 B

3> $ : 입력 문자 생성의 끝을 일치시킵니다. 그것이 멀티 라인 일치, 즉 표현식의 추가 매개 변수에 m을 포함하는 경우, 새로운 라인 앞에 일치합니다.

^의 사용과는 반대로.

예 : / t $ / "bat"에서 t와 일치하지만 "증오"에서 t와 일치하지 않습니다.

예 2 : /t $ /match

“태그

박쥐"

첫 번째 줄의 마지막 t와 두 번째 줄의 t.

4>*: 이전 문자를 0 이상 일치시킵니다.

예 : /ab* /"dddabbbbc"에서 "abbbb", "ddda"에서 "a"와 일치합니다.

5>+: 이전 문자와 1 번 이상 일치합니다.

예 : / ab+ / "dddabbbbc"에서 "abbbb", "ddda"와 일치하지 않습니다.

다음 {1,} (프로토 타입 : {n,})의 사용과 유사합니다.

6>? : 사용법? 아주 특별합니다. 일반적으로 말하면, 이전 문자를 0 번 또는 1 회 일치시키는 데 사용되지만 다른 두 가지 특별 용도가 있습니다.

*, +,? {}, 원래 매치의 최소 일치 수를 의미합니다.

/ ba*/ 원래 "bbbaaaa"에서 "baaaa"와 일치했지만 "bbbaaaa"에서/ ba*?/ 일치 "b"(*는 0 이상의 일치를 의미하기 때문에 최소 일치 수를 의미해야합니다. 즉, 0 경기).

마찬가지로 : / ba+? / "baaa"에서 "ba"와 일치합니다.

구문 구조 기호로서, 그것은 사전 분석, 즉 x (? = y) 및 x (?! = y)에서 사용됩니다.

7>. : "." 소수점에서 로그인은 Newline 캐릭터를 제외한 단일 캐릭터와 일치합니다.

전체 표준의 문자는 무엇입니까? 문자 세트를 참조하십시오

예를 들면 : / ab / "acbaa"에서 "acb"는 "ABBB"와 일치하지 않습니다.

8> (x) : X와 일치하는 것을 의미합니다 (문자 X를 구체적으로 언급하지 않거나 특이 적으로 문자를 언급하지 않으면 X는 문자열을 나타냅니다). 구문에서는 이러한 종류의 ()를 "캡처하는 부모", 즉 캡처에 사용되는 괄호입니다.

표현식에 의해 제공된 함수에서 일부 함수는 Exec () 함수와 같은 모든 일치하는 문자열을 보유하는 배열을 반환하기 때문에 일치는 기억됩니다.

또한 x in ()가 기억된다는 전제는 x와 일치하는 것입니다.

Example 1:

var regx =/a (b) c/;

var rs = regx.exec ( "abcddd");

위에서 볼 수 있듯이 / a (b) c / matches "abcddd"에서 "abc". () 때문에 B도 기록하므로 RS가 반환 한 숫자 컨텐츠는 다음과 같습니다.

{ABC, B}

Example 2:

var regx =/a (b) c/;

var rs = regx.exec ( "acbcddd");

/ a (b) c /는 "acbcddd"와 일치하지 않기 때문에 rs는 null을 반환합니다. 그래서 b in ()은 기록되지 않습니다 (문자열에는 b가 포함되어 있지만).

9> (? : x) : 일치 x이지만 x를 기억하지 못합니다. ()이 형식에서는 "비과 accaptureparting parents", 즉 캡처되지 않은 괄호라고합니다.

예:

var regx =/a (? : b) c/;

var rs = regx.exec ( "abcddd");

위에서 볼 수 있듯이 / a (? : b) c / matches "abcddd"에서 "abc", (? :), b는 기록되지 않으므로 Rs가 반환 한 숫자 컨텐츠는 다음과 같습니다.

{알파벳}

10> x (? = y) : y를 일치시킵니다. 경기가 일치하면 X만이 기억되고 Y는 기억되지 않습니다.

예:

var regx =/user (? = name)/;

var rs = regx.exec ( "사용자 이름은 Mary");

결과 : 경기가 성공적이며 Rs의 값은 {user}입니다.

11> x (?! y) : y 일치 x, y가 즉시 따르지 않는 경우에만. 경기가 일치하면 X만이 기억되고 Y는 기억되지 않습니다.

예:

var regx =/user (?! name)/;

var rs = regx.exec ( "사용자 이름은 Mary");

결과 : 경기가 성공적이며 Rs의 값은 {user}입니다.

Example 2:

var regx = // d+(?!/.)/;

var rs=regx.exec(“54.235”);

Result: The matching result, the value of rs is {5}, and the mismatch is because 54 is followed by the "." 징후. Of course, 235 also matches, but due to the behavior of the exec method, 235 will not be returned.

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”);

Result: The match is successful, and the value of rs is: {abbbbb}, which means that if the previous character appears more than m times, it will only match m times. 게다가:

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]等同于[xz]。

예:

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]等同于[^xz]。

예:

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 的值必须为AZ 或az 之一。否则，将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

기원전";

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}

In addition, if there are multiple suitable matches, exec is executed for the first time and exec is continued, the second and third matches are returned in turn. 예를 들어:

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), determines whether the string str matches the expression, and returns a boolean value. 예를 들어:

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, return the expression string itself. 예를 들어:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var source=regx.source;

source的值为user/d

3）和匹配结果相关的三个属性：

1>index, return the current matching position. 예를 들어:

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, used for matching strings. 예를 들어:

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) For the exec method of the expression object, if g is not added, it will only return the first match, no matter how many times it is executed, if g is added, the first execution will also return the first match, and then the execution will return the second match, and so on. 예를 들어

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) For the match method of the String object, g is not added, and it only returns the first match. If the match method is executed all the time, it always returns the first match. If g is added, then all matches will be returned at once (note that this is different from the exec method of the expression object. For exec, even if g is added, all matches will not be returned at once). 예를 들어:

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域中是这样的。

The above article briefly discusses the use of RegExp objects and brackets for JS regular expressions is all the content I share with you. 나는 그것이 당신에게 참조를 줄 수 있기를 바랍니다. 그리고 당신이 wulin.com을 더 지원할 수 있기를 바랍니다.