정규식 패턴(표현식)

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

  ^ : 줄(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

"kka_7@C.At".match(/\w/) // ["k"]
"kka_7@C.At".match(/\w/g) // ["k", "k", "a", "_", "7", "C", "A", "t"]

"kka_7@C.At".match(/\W/) // ["@"]
"kka_7@C.At".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"]