[JS] 정규표현식 옵션 설정

정규식 패턴(표현식)

  • 정규표현식에 다양한 특수기호를 사용해 옵션을 설정하기

    ^ : 줄(Line)의 시작에서 일치 /^abc/
    $ : 줄(Line)의 끝에서 일치 /xyz$/
    . : (특수기호, 띄어쓰기를 포함한) 임의의 한 문자
    a|b : a or b 와 일치, 인덱스가 작은 것을 우선 반환
    * : 0회 이상 연속으로 반복되는 문자와 가능한 많이 일치. {0,} 와 동일
    *? :0회 이상 연속으로 반복되는 문자와 가능한 적게 일치. {0} 와 동일
    + : 1회 이상 연속으로 반복되는 문자와 가능한 많이 일치. {1,} 와 동일
    +? : 1회 이상 연속으로 반복되는 문자와 가능한 적게 일치. {0} 와 동일
    {3} : 숫자 3개 연속 일치
    {3,} :3개 이상 연속 일치
    {3, 5} :3개 이상 5개 이하 연속 일치
    () : 캡쳐(capture)할 그룹
    [a-z] : a부터 z 사이의 문자 구간에 일치(영어 소문자)
    [A-Z] : A부터 Z 사이의 문자 구간에 일치(영어 대문자)
    [0-9] : 0부터 9 사이의 문자 구간에 일치(숫자)
    \ : escape 문자. 특수 기호 앞에 \를 붙이면 정규식 패턴이 아닌, 기호 자체로 인식
    \d : 숫자를 검색함. /[0-9]/와 동일
    \D : 숫자가 아닌 문자를 검색함. /[^0-9]/와 동일
    \w : 영어대소문자, 숫자, (underscore)를 검색함. /[A-Za-z0-9]/ 와 동일
    \W : 영어대소문자, 숫자, (underscore)가 아닌 문자를 검색함. /[^A-Za-z0-9]/ 와 동일
    [^] : []안의 문자열 앞에 ^이 쓰이면, []안에 없는 문자를 검색함

1. Anchors

1) ^

"kkakka is cat".match(/^kk/) // ['kk']
"kkakka is cat".match(/^cat/) // null
  • 문자열의 처음을 의미
  • 문자열에서 ^ 뒤에 붙은 단어로 시작하는 부분을 찾음
  • 일치하는 부분이 있더라도, 그 부분이 문자열의 시작 부분이 아니면 null을 리턴

2) $

"kkakka is cat".match(/at$/) // ['at']
"kkakka is cat".match(/is$/) // null
"kkakka is cat".match(/^kkakka is cat$/) // ["kkakka is cat"]
// 문자열을 ^와 $로 감싸주면 그 사이에 들어간 문자열과 정확하게 일치하는 부분을 찾음
  • $는 문자열의 끝을 의미
  • 문자열에서 $ 앞의 표현식으로 끝나는 부분을 찾음
  • 일치하는 부분이 있더라도, 그 부분이 문자열의 끝부분이 아니면 null을 리턴

2. Quantifiers

1) *

"ca cat catt cattt catttt cattttt".match(/cat*/g)
// ["ca", "cat", "catt", "cattt", "catttt", "cattttt"]
  • *바로 앞의 문자가 0번 이상 나타나는 경우를 검색

2) +

"ca cat catt cattt catttt cattttt".match(/cat+/g)
// ["cat", "catt", "cattt", "catttt", "cattttt"]
  • *와 같은 방식으로 작동하지만 + 바로 앞의 문자가 1번 이상 나타나는 경우를 검색

3) ?

"ca cat catt cattt catttt cattttt".match(/cat?/g)
// ["ca", "cat", "cat", "cat", "cat", "cat"]
  • ?* 또는 +와 비슷하지만, ? 앞의 문자가 0번 혹은 1번 나타나는 경우만 검색

4) {}

"ca cat catt cattt catttt cattttt".match(/cat{2}/g)
// "t"가 2개
// ["catt", "catt", "catt", "catt"]

"ca cat catt cattt catttt cattttt".match(/cat{2,3}/g)
// "t"가 2개 이상 3개 이하
// ["catt", "cattt", "cattt", "cattt"]

"ca cat catt cattt catttt cattttt".match(/cat{2,}/g)
// "t"를 2개 이상 포함한 문자열
// ["catt", "cattt", "catttt", "cattttt"]
  • {}는 직접 숫자를 넣어서 연속되는 개수를 설정 가능

3. | : OR operator

"gG AA Gg aA".match(/G|a/g) // ["G", "G", "a"]

"gG AA Gg aA".match(/g+|A+/g) // ["g", "AA", "g", "A"]
// + 는 1번 이상 반복을 의미
  • | 는 or 조건으로 검색하여 |의 왼쪽 또는 오른쪽의 검색 결과를 반환

4. [] : Bracket Operator

"Kkk AAa Ggg AAaaa".match(/[ka]+/g)
// k 또는 a가 한 번 이상 반복
// ["kk", "a", "aaa"]

"AA 12 ZZ Ad %% Az !# dd 54 zz".match(/[A-Za-z]+/g)
// a~z 또는 A~Z 에서 한 번 이상 반복되는 문자열을 반복 검색
// ["AA", "ZZ", "Ad", "Az", "dd", "zz"]
"AA 12 ZZ Ad %% Az !# dd 54 zz".match(/[A-Z]+/gi)
// flag i 는 대소문자를 구분하지 않기 때문에 위와 동일한 결과를 반환
// ["AA", "ZZ", "Ad", "Az", "dd", "zz"]

"AA 12 ZZ Ad %% Az !# dd 54 zz".match(/[0-9]+/g)
// 숫자도 검색 가능
// ["12", "54"]

"aAbB$#67Xz@9".match(/[^a-zA-Z]+/g);
// [] 안에 ^를 사용하면 문자열의 처음을 찾는것이 아닌 부정을 의미
// [] 안에 없는 값을 검색
// ["$#67", "@9"]
  • [] 안에 명시된 값을 검색
    *[]+ 등의 기호를 함께 사용할 수 있음
  • [abc] : a 또는 b 또는 c 를 검색
  • [a-c] : - 로 검색 구간을 설정

5. Character classes

1) \d & \D

"kkakka07".match(/\d/) //["0"]
"kkakka07".match(/\d/g) //["0", "7"]

"kkakka07".match(/\D/) // ["k"]
"kkakka07".match(/\D/g)// ["k", "k", "a", "k", "k", "a"]
  • \d는 digit을 의미하며 0 ~ 9 사이의 숫자 하나를 검색 ([0-9]와 동일)
  • \D는 not Digit을 의미하며 숫자가 아닌 문자 하나를 검색 ([^0-9]와 동일)

2) \w & \W

"[email protected]".match(/\w/) // ["k"]
"[email protected]".match(/\w/g) // ["k", "k", "a", "_", "7", "C", "A", "t"]

"[email protected]".match(/\W/) // ["@"]
"[email protected]".match(/\W/g) // ["@", "."]
  • \w는 알파벳 대소문자, 숫자, _ 중 하나를 검색 ([a-zA-Z0-9_]와 동일)
  • \W는 알파벳 대소문자, 숫자, _ 가 아닌 문자 하나를 검색 ([^a-zA-Z0-9_]와 동일)

6. () : Grouping and capturing

1) 그룹화(Grouping)

"kaka".match(/ka+/) // ["ka"]
"kaaakaaa".match(/ka+/) // ["kaaa"]

"kaka".match(/(ka)+/) // ["kaka", "ka"]
"kaaakaaa".match(/(ka)+/) // ["ka", "ka"]
  • 표현식의 일부를 ()로 묶어주면 그 안의 내용을 하나로 그룹화할 수 있음

2) 캡처(capturing)

  • 캡처된 값은 replace() 메소드를 사용하여 문자 치환 시 참조 패턴으로 사용될 수 있음

(1) 예시 1

"kaka".match(/(ka)+/) // ["kaka", "ka"]
  1. ()로 "ka"를 캡쳐
  2. 캡처한 "ka"는 일단 당장 사용하지 않고, +가 "ka"의 1회 이상 연속 반복을 검색하여 "kaka" 반환
  3. 캡처 이외 표현식이 모두 작동하고 나면, 캡처해 두었던 "ka" 반롼

(2) 예시 2

"2015KKAKKA".match(/(\d+)(\w)/)
// ["2015K", "2015", "K"]
  1. () 안의 표현식을 순서대로 캡처 ⇒ \d+ 와 \w
  2. 캡처 후 남은 표현식으로 검색 ⇒ 이번 예시에는 남은 표현식은 없음
  3. \d로 숫자를 검색하되 +로 1개 이상 연속되는 숫자를 검색 ⇒ 2015
  4. \w로 문자를 검색 ⇒ K
  5. 3번과 4번이 조합되어 "2015K" 반환
  6. 첫 번째 캡처한 (\d+)로 인해 "2015" 반환
  7. 두 번째 캡처한 (\w) 로 인해 "K" 가 반환

(3) 예시 3

"kkakka.cat".replace(/(\w+)\.(\w+)/, "$2.$1") // "cat.kkakka"

// /(\w+)\ 와 (\w+)/\사이의 . 은 . 앞에 역슬래시가 사용되었기 때문에 
//'임의의 한 문자'가 아닌 기호로서의 온점 . 을 의미
  1. 첫 번째 (\w+)가 "kkakka"를 캡처
  2. 두 번째 (\w+)가 "cat"을 캡처
  3. 각 캡처된 값은 첫 번째는 $1이 참조, 두 번째는 $2가 참조
  4. 참조된 값을 "$2.$1"이 대체하여 "cat.kkakka" 반환

3) non-capturing

"kaka".match(/(ka)+/) // ["kaka", "ka"]

"kaka".match(/(?:ka)+/) // ["kaka"]
  • (?:)로 사용하면 그룹은 만들지만 캡처는 하지 않음

4) lookahead

"ggakka".match(/kk(?=a)/) // ["kk"]
// kk가 a 앞에 있기 때문에 ["kk"]를 반환

"ggakka".match(/gg(?=k)/) // null
// k 앞에는 gga가 있기 때문에 null을 반환
  • (?=)는 검색하려는 문자열에 (?=여기)에 일치하는 문자가 있어야 (?=여기)앞의 문자열을 반환

(?!) :(?=)의 부정

"ggakka".match(/kk(?!a)/) // null
"ggakka".match(/gg(?!k)/) // ["gg"]

좋은 웹페이지 즐겨찾기