์ ๊ท ํํ์
์ ๊ท ํํ์, ๋๋ ์ ๊ท์์ ๋ฌธ์์ด์์ ํน์ ๋ฌธ์ ์กฐํฉ์ ์ฐพ๊ธฐ ์ํ ํจํด์
๋๋ค. JavaScript์์๋ ์ ๊ท ํํ์๋ ๊ฐ์ฒด๋ก์, RegExp์ exec()์ test() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. String์ match(), matchAll(), replace(), replaceAll(), search(), split() ๋ฉ์๋์๋ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด ์ฅ์์๋ JavaScript์ ์ ๊ท ํํ์์ ์ค๋ช
ํฉ๋๋ค.
์ ๊ท ํํ์ ๋ง๋ค๊ธฐ
์ ๊ท ํํ์์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ๋ง๋ค ์ ์์ต๋๋ค.
-
์ ๊ท ํํ์ ๋ฆฌํฐ๋ด. ๋ค์๊ณผ ๊ฐ์ด ์ฌ๋์๋ก ํจํด์ ๊ฐ์ธ์ ์์ฑํฉ๋๋ค.
jsconst re = /ab+c/;์ ๊ท ํํ์ ๋ฆฌํฐ๋ด์ ์คํฌ๋ฆฝํธ๋ฅผ ๋ถ๋ฌ์ฌ ๋ ์ปดํ์ผ๋๋ฏ๋ก, ๋ฐ๋ ์ผ์ด ์๋ ํจํด์ ๊ฒฝ์ฐ ๋ฆฌํฐ๋ด์ ์ฌ์ฉํ๋ฉด ์ฑ๋ฅ์ด ํฅ์๋ ์ ์์ต๋๋ค.
-
RegExp๊ฐ์ฒด์ ์์ฑ์ ํธ์ถ.jsconst re = new RegExp("ab+c");์์ฑ์ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ ๊ท ํํ์์ด ๋ฐํ์์ ์ปดํ์ผ๋ฉ๋๋ค. ๋ฐ๋ ์ ์๋ ํจํด์ด๋, ์ฌ์ฉ์ ์ ๋ ฅ ๋ฑ ์ธ๋ถ ์ถ์ฒ์์ ๊ฐ์ ธ์ค๋ ํจํด์ ๊ฒฝ์ฐ ์ด๋ ๊ฒ ์ฌ์ฉํ์ธ์.
์ ๊ท ํํ์ ํจํด ์์ฑํ๊ธฐ
์ ๊ท ํํ์ ํจํด์ /abc/์ฒ๋ผ ๋จ์ํ ๋ฌธ์๋ก ๊ตฌ์ฑํ๊ฑฐ๋, /ab+c/์ /Chapter (\d+)\.\d*/์ฒ๋ผ ๋จ์ํ ๋ฌธ์์ ํน์ ๋ฌธ์์ ์กฐํฉ์ผ๋ก ๊ตฌ์ฑํ ์๋ ์์ต๋๋ค. ํนํ (\d+)์ ๋ํ๋ ๊ดํธ๋ ์ ๊ท ํํ์์์ ๊ธฐ์ต ์ฅ์น์ฒ๋ผ ์ฐ์ฌ์, ๊ดํธ์ ์์ชฝ ํจํด๊ณผ ์ผ์นํ ๋ถ๋ถ์ ๋์ค์ ์ฌ์ฉํ ์ ์๋๋ก ๊ธฐ์ตํฉ๋๋ค. ๊ทธ๋ฃน ์ฌ์ฉํ๊ธฐ์์ ๋ ์์๋ณด์ธ์.
๋จ์ ํจํด ์ฌ์ฉํ๊ธฐ
๋จ์ ํจํด์ ๋ฌธ์์ด์ ์๋ ๊ทธ๋๋ก ํ์ํ ๋ ์ฌ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด, /abc/ ํจํด์ ๋ฌธ์์ด์์ ์ ํํ ์์๋ก "abc"๋ผ๋ ๋ฌธ์์ ์กฐํฉ์ด ๋ํ๋๋ ๋ถ๋ถ๊ณผ ์ผ์นํฉ๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ด ํจํด์ "Hi, do you know your abc's?"์ "The latest airplane designs evolved from slabcraft." ๋ ๋ฌธ์์ด์์ ์ผ์น์ ์ฑ๊ณตํ๊ณ , ์ผ์นํ๋ ๋ถ๋ถ์ "abc"์ผ ๊ฒ์
๋๋ค. ๋ฐ๋ฉด "Grab crab"์์๋ ์ผ์นํ์ง ์๋๋ฐ, ์ด ๋ฌธ์์ด์ ๋ถ๋ถ ๋ฌธ์์ด๋ก "ab c"๋ฅผ ํฌํจํ๊ธด ํ์ง๋ง, ์ ํํ๊ฒ "abc"๋ฅผ ํฌํจํ์ง๋ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
ํน์ ๋ฌธ์ ์ฌ์ฉํ๊ธฐ
ํ๋ ์ด์์ "b"๋ฅผ ์ฐพ๋๋ค๊ฑฐ๋ ๊ณต๋ฐฑ ๋ฌธ์๋ฅผ ์ฐพ๋ ๋ฑ ์ง์ ์ ์ธ ์ผ์น ์ด์์ ํ์์ด ํ์ํ ๋ ํน์ ๋ฌธ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์์ปจ๋ "ํ๋์ "a" ์ดํ์ 0๊ฐ ์ด์์ "b", ๊ทธ ๋ค์ "c""์ ์ผ์นํด์ผ ํ๋ฉด /ab*c/ ํจํด์ ์ฌ์ฉํ ์ ์์ต๋๋ค. "b" ๋ค์ *๋ "์ด์ ํญ๋ชฉ์ 0๋ฒ ์ด์ ๋ฐ๋ณต"์ ์๋ฏธํฉ๋๋ค. ์ด ํจํด์ ๋ฌธ์์ด "cbbabbbbcdebc"์ ๋ํด ์ฌ์ฉํ๋ฉด, ์ผ์นํ๋ ๋ถ๋ถ ๋ฌธ์์ด์ "abbbbc"์ผ ๊ฒ์
๋๋ค.
์๋์ ๋ฌธ์๋ค์์ ๊ฐ๊ฐ์ ๋ฒ์ฃผ์ ์ํ๋ ๋ค์ํ ํน์ ๋ฌธ์์ ๋ชฉ๋ก๊ณผ ์ค๋ช , ์์ ๋ฅผ ์ฐพ์๋ณผ ์ ์์ต๋๋ค.
- ์ด์์
-
์ด์์ ์๋ ์ค์ด๋ ๋จ์ด์ ์์๊ณผ ๋์ ๋ํ๋ด๋ ๊ฒฝ๊ณ์, ์ผ์น๊ฐ ๊ฐ๋ฅํ ๋ฐฉ๋ฒ์ ๋ํ๋ด๋ ํจํด(์ ๋ฐฉํ์, ํ๋ฐฉํ์, ์กฐ๊ฑด ํํ์ ๋ฑ)์ด ํฌํจ๋ฉ๋๋ค.
- ๋ฌธ์ ํด๋์ค
-
๊ธ์์ ์ซ์์ฒ๋ผ ๋ค๋ฅธ ์ ํ์ ๋ฌธ์๋ฅผ ๊ตฌ๋ถํฉ๋๋ค.
- ๊ทธ๋ฃน๊ณผ ๋ฒ์
-
ํํ ๋ฌธ์์ ๊ทธ๋ฃน๊ณผ ๋ฒ์๋ฅผ ๋ํ๋ ๋๋ค.
- ์๋์
-
์ผ์นํ ๋ฌธ์๋ ํํ์ด ๋ฐ๋ณต๋์ด์ผ ํ ํ์๋ฅผ ๋ํ๋ ๋๋ค.
- ์ ๋์ฝ๋ ์์ฑ ์ด์ค์ผ์ดํ
-
๋/์๋ฌธ์, ์ํ ๊ธฐํธ, ๋ฌธ์ฅ ๋ถํธ์ฒ๋ผ, ์ ๋์ฝ๋ ๋ฌธ์ ์์ฑ์ ๋ฐ๋ผ ๋ฌธ์๋ฅผ ๊ตฌ๋ถํฉ๋๋ค.
์๋ ํ๋ ์ ๊ท ํํ์์์ ์ฌ์ฉํ๋ ๋ชจ๋ ํน์๋ฌธ์์ ๋ชฉ๋ก์ ๋๋ค.
| ๋ฌธ์ / ์กฐํฉ | ๋ฌธ์ |
|---|---|
\, ., \cX, \d,
\D, \f, \n, \r,
\s, \S, \t, \v,
\w, \W, \0, \xhh,
\uhhhh, \uhhhhh, [\b]
|
|
^, $, x(?=y),
x(?!y), (?<=y)x,
(?<!y)x, \b, \B
|
|
(x), (?:x), (?<Name>x),
x|y, [xyz], [^xyz],
\Number
|
|
*, +, ?,
x{n}, x{n,},
x{n,m}
|
|
\p{UnicodeProperty},
\P{UnicodeProperty}
|
์ ๋์ฝ๋ ์์ฑ ์ด์ค์ผ์ดํ |
์ฐธ๊ณ : ์ ๋ฌธ์์ ์ผ๋ถ๋ง ๋ฐ์ทํด ์ ๋ฆฌํด๋์, ๋ ํฐ ์นํธ ์ํธ๋ ์์ต๋๋ค.
์ด์ค์ผ์ดํ
ํน์ ๋ฌธ์๋ฅผ ์๋ ๊ทธ๋๋ก ํ์("*"์ ์ง์ ์ฐพ๋ ๋ฑ)ํด์ผ ํ๋ ๊ฒฝ์ฐ, ํน์ ๋ฌธ์ ์์ ์ญ์ฌ๋์(\)๋ฅผ ๋ฐฐ์นํด์ ์ด์ค์ผ์ดํ ํด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด "a" ๋ค์ ๋ณํ("*") ๋ค์ "b"์ ์ผ์นํด์ผ ํ๋ฉด /a\*b/๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค. ์ญ์ฌ๋์๊ฐ "*"๋ฅผ "์ด์ค์ผ์ดํ"ํด์, ํน์ ๋ฌธ์๊ฐ ์๋ ๋ฌธ์ ๋ฆฌํฐ๋ด๋ก ์ทจ๊ธํฉ๋๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก, ์ฌ๋์(/)์ ์ผ์นํด์ผ ํ๋ ๊ฒฝ์ฐ์๋ ์ด์ค์ผ์ดํ๋ฅผ ํด์ผ ํฉ๋๋ค. ๊ทธ๋ฅ ๋น๊ธ์ ์ฌ์ฉํ๋ฉด ํจํด์ด ๋๋๋ฒ๋ฆฝ๋๋ค. ์๋ฅผ ๋ค์ด ๋ฌธ์์ด "/example/"๊ณผ ๊ทธ ๋ค ํ๋ ์ด์์ ์ํ๋ฒณ์ ์ฐพ์ผ๋ ค๋ฉด /\/example\/[a-z]/๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๊ฐ๊ฐ์ ์ฌ๋์ ์์ ๋์ธ ์ญ์ฌ๋์๊ฐ ์ฌ๋์๋ฅผ ์ด์ค์ผ์ดํํฉ๋๋ค.
๋ฆฌํฐ๋ด ์ญ์ฌ๋์์ ์ผ์นํ๋ ค๋ฉด ์ญ์ฌ๋์๋ฅผ ์ด์ค์ผ์ดํํฉ๋๋ค. "A:\", "B:\", "C:\", ..., "Z:\"์ ์ผ์นํ๋ ํจํด์ /[A-Z]:\\/์
๋๋ค. ์์ ์ญ์ฌ๋์๊ฐ ๋ค์ ์ญ์ฌ๋์๋ฅผ ์ด์ค์ผ์ดํํด์, ๊ฒฐ๊ณผ์ ์ผ๋ก ํ๋์ ๋ฆฌํฐ๋ด ์ญ์ฌ๋์์ ์ผ์นํ๊ฒ ๋ฉ๋๋ค.
RegExp ์์ฑ์์ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ์ญ์ฌ๋์๊ฐ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ด์ค์ผ์ดํ๋ก๋ ์๋ํ๋ค๋ ๊ฒ์ ๊ธฐ์ตํด์ผ ํฉ๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ ๊ท ํํ์์ ์ญ์ฌ๋์๋ฅผ ๋ํ๋ด๋ ค๋ฉด ๋ฌธ์์ด ๋ฆฌํฐ๋ด ์์ค์ ์ด์ค์ผ์ดํ๋ ํด์ค์ผ ํฉ๋๋ค. ์ฆ, ์์ ์ดํด๋ณธ /a\*b/ ํจํด์ ์์ฑํ๋ ค๋ฉด new RegExp("a\\*b")๊ฐ ๋์ด์ผ ํฉ๋๋ค.
์ด์ค์ผ์ดํ ๋์ง ์์ ๋ฌธ์์ด์ ์ด๋ฏธ ๊ฐ์ง๊ณ ์์ ๋ String.replace๋ฅผ ํ์ฉํด ์ด์ค์ผ์ดํ๋ฅผ ํด์ค ์ ์์ต๋๋ค.
function escapeRegExp(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $&์ ์ผ์นํ ๋ฌธ์์ด ์ ์ฒด๋ฅผ ์๋ฏธ
}
์ ๊ท ํํ์ ๋ค์ "g"๋ ์ ์ฒด ๋ฌธ์์ด์ ํ์ํด์ ๋ชจ๋ ์ผ์น๋ฅผ ๋ฐํํ๋๋ก ์ง์ ํ๋ ์ ์ญ ํ์ ํ๋๊ทธ์ ๋๋ค. ํ๋๊ทธ์ ๋ํด์๋ ์๋์ ํ๋๊ทธ๋ฅผ ํ์ฉํ ๊ณ ๊ธ ํ์์์ ํ์ธํ ์ ์์ต๋๋ค.
"์ escapeRegExp()๊ฐ JavaScript์ ์ผ๋ถ๊ฐ ์๋๊ฐ์?" ๊ด๋ จ ์ ์์ ์์์ผ๋ TC39๊ฐ ๊ฑฐ๋ถํ์ต๋๋ค.
๊ดํธ ์ฌ์ฉํ๊ธฐ
์ ๊ท ํํ์์ ์๋ฌด ๋ถ๋ถ์ด๋ ๊ดํธ๋ก ๊ฐ์ธ๊ฒ ๋๋ฉด, ๊ทธ ๋ถ๋ถ๊ณผ ์ผ์นํ๋ ๋ถ๋ถ ๋ฌธ์์ด์ ๊ธฐ์ตํ๊ฒ ๋ฉ๋๋ค. ๊ธฐ์ตํ ๋ถ๋ถ ๋ฌธ์์ด์ ๋ถ๋ฌ์์ ๋ค์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๊ทธ๋ฃน๊ณผ ๋ฒ์ ๋ฌธ์์์ ์์ธํ ์์๋ณด์ธ์.
JavaScript์์ ์ ๊ท ํํ์ ์ฌ์ฉํ๊ธฐ
์ ๊ท ํํ์์ RegExp์ ๋ฉ์๋ test()์ exec(), String์ ๋ฉ์๋ match(), replace(), search(), split()์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
| ๋ฉ์๋ | ์ค๋ช |
|---|---|
exec() |
๋ฌธ์์ด์์ ์ผ์นํ๋ ๋ถ๋ถ์ ํ์ํฉ๋๋ค. ์ผ์น ์ ๋ณด๋ฅผ ๋ํ๋ด๋ ๋ฐฐ์ด, ๋๋ ์ผ์น๊ฐ ์๋ ๊ฒฝ์ฐ null์ ๋ฐํํฉ๋๋ค. |
test() |
๋ฌธ์์ด์ ์ผ์นํ๋ ๋ถ๋ถ์ด ์๋์ง ํ์ธํฉ๋๋ค. true ๋๋ false๋ฅผ ๋ฐํํฉ๋๋ค. |
match() |
์บก์ฒ ๊ทธ๋ฃน์ ํฌํจํด์ ๋ชจ๋ ์ผ์น๋ฅผ ๋ด์ ๋ฐฐ์ด์ ๋ฐํํฉ๋๋ค. ์ผ์น๊ฐ ์์ผ๋ฉด null์ ๋ฐํํฉ๋๋ค. |
matchAll() |
์บก์ฒ ๊ทธ๋ฃน์ ํฌํจํด์ ๋ชจ๋ ์ผ์น๋ฅผ ๋ด์ ๋ฐ๋ณต๊ธฐ๋ฅผ ๋ฐํํฉ๋๋ค. |
search() |
๋ฌธ์์ด์์ ์ผ์นํ๋ ๋ถ๋ถ์ ํ์ํฉ๋๋ค. ์ผ์นํ๋ ๋ถ๋ถ์ ์ธ๋ฑ์ค, ๋๋ ์ผ์น๊ฐ ์๋ ๊ฒฝ์ฐ -1์ ๋ฐํํฉ๋๋ค. |
replace() |
๋ฌธ์์ด์์ ์ผ์นํ๋ ๋ถ๋ถ์ ํ์ํ๊ณ , ๊ทธ ๋ถ๋ถ์ ๋์ฒด ๋ฌธ์์ด๋ก ๋ฐ๊ฟ๋๋ค. |
replaceAll() |
๋ฌธ์์ด์์ ์ผ์นํ๋ ๋ถ๋ถ์ ๋ชจ๋ ํ์ํ๊ณ , ๋ชจ๋ ๋์ฒด ๋ฌธ์์ด๋ก ๋ฐ๊ฟ๋๋ค. |
split() |
์ ๊ท ํํ์ ๋๋ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ฌ์ฉํด์ ๋ฌธ์์ด์ ๋ถ๋ถ ๋ฌธ์์ด์ ๋ฐฐ์ด๋ก ๋๋๋๋ค. |
๋ฌธ์์ด ๋ด๋ถ์ ํจํด๊ณผ ์ผ์นํ๋ ๋ถ๋ถ์ด ์กด์ฌํ๋์ง๋ง ์์๋ด๋ ค๋ฉด test()๋ search() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ธ์. ๋ ๋๋ฆฌ๋๋ผ๋ ์ผ์น์ ๊ดํ ์ถ๊ฐ ์ ๋ณด๊ฐ ํ์ํ๋ฉด exec()๊ณผ match() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ธ์. ์ผ์นํ๋ ๋ถ๋ถ์ด ์กด์ฌํ๋ฉด, exec()๊ณผ match()๋ ์ผ์น์ ๊ดํ ๋ฐ์ดํฐ๋ฅผ ํฌํจํ ๋ฐฐ์ด์ ๋ฐํํ๊ณ , ์ผ์น์ ์ฌ์ฉํ ์ ๊ท ํํ์ ๊ฐ์ฒด์ ์์ฑ์ ์
๋ฐ์ดํธํฉ๋๋ค. ์ผ์นํ์ง ๋ชปํ ๊ฒฝ์ฐ null์ ๋ฐํํฉ๋๋ค. (null์ ์กฐ๊ฑด ํ๊ฐ ์ false์ ๊ฐ์ต๋๋ค)
์๋์ ์์ ์์๋, ๋ฌธ์์ด์์ ์ผ์นํ๋ ๋ถ๋ถ์ ์ฐพ๊ธฐ ์ํด exec() ๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค.
const myRe = /d(b+)d/g;
const myArray = myRe.exec("cdbbdbsbz");
๋ง์ฝ ์ ๊ท ํํ์ ๊ฐ์ฒด์ ์์ฑ์ ์ ๊ทผํ ํ์๊ฐ ์์ผ๋ฉด ์๋์ ๊ฐ์ด ์งง๊ฒ ์ธ ์๋ ์์ต๋๋ค.
const myArray = /d(b+)d/g.exec("cdbbdbsbz");
// 'cdbbdbsbz'.match(/d(b+)d/g); ์ ๋น์ทํ์ง๋ง,
// 'cdbbdbsbz'.match(/d(b+)d/g)์ ๋ฐํ ๊ฐ์ [ 'dbbd' ]์ธ ๋ฐ๋ฉด
// /d(b+)d/g.exec('cdbbdbsbz')์ ๋ฐํ ๊ฐ์ [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]
(์๋์ exec()๊ณผ ์ ์ญ ํ์ ํ๋๊ทธ ์ฌ์ฉํ๊ธฐ์์ ๋์ ๋ฐฉ์์ ์ฐจ์ด์ ๋ํด ๋ ์์๋ณด์ธ์)
์ ๊ท ํํ์์ ๋ฌธ์์ด์์ ๋ง๋ค๊ณ ์ถ์ผ๋ฉด ์๋์ฒ๋ผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
const myRe = new RegExp("d(b+)d", "g");
const myArray = myRe.exec("cdbbdbsbz");
์๋์ ํ๋ ์ ์คํฌ๋ฆฝํธ์์ ์ผ์น๋ฅผ ์ฑ๊ณตํ ํ, ๋ฐํํ๋ ๋ฐฐ์ด๊ณผ ์ ๋ฐ์ดํธ๋๋ ์ ๊ท ํํ์ ๊ฐ์ฒด์ ์์ฑ์ ๋๋ค.
| ๊ฐ์ฒด | ์์ฑ ๋๋ ์ธ๋ฑ์ค | ์ค๋ช | ์ ์์ ์์์ ๊ฐ |
|---|---|---|---|
myArray |
์ผ์นํ ๋ฌธ์์ด ๋ฐ ๊ธฐ์ตํ ๋ชจ๋ ๋ถ๋ถ ๋ฌธ์์ด. | ['dbbd', 'bb', index: 1, input: 'cdbbdbsbz'] |
|
index |
์ผ์นํ ๋ถ๋ถ์ด ์ฃผ์ด์ง ๋ฌธ์์ด์์ ์์นํ ์ธ๋ฑ์ค. (0๋ถํฐ ์์) | 1 |
|
input |
์ฃผ์ด์ง ์๋ณธ ๋ฌธ์์ด. | 'cdbbdbsbz' |
|
[0] |
๋ง์ง๋ง์ผ๋ก ์ผ์นํ ๋ถ๋ถ ๋ฌธ์์ด. | 'dbbd' |
|
myRe |
lastIndex |
๋ค์ ์ผ์น๋ฅผ ์์ํ ์ธ๋ฑ์ค. (g ์ต์ ์ ์ง์ ํ ์ ๊ท ํํ์์ ๊ฒฝ์ฐ์๋ง ์ค์ ๋ฉ๋๋ค. ํ๋๊ทธ๋ฅผ ํ์ฉํ ๊ณ ๊ธ ํ์์ ์ฐธ๊ณ ํ์ธ์) | 5 |
source |
ํจํด์ ํ ์คํธ. ์ ๊ท ํํ์์ด ์์ฑ๋ ๋ ๊ฐฑ์ ๋ฉ๋๋ค. ์คํ ์์ ์๋ ๊ฐฑ์ ๋์ง ์์ต๋๋ค. | 'd(b+)d' |
์ ์์ ์ ๋ ๋ฒ์งธ ํํ์ฒ๋ผ, ์ ๊ท ํํ์ ๊ฐ์ฒด๋ฅผ ๋ณ์์ ๋์ ํ์ง ์๊ณ ๋ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ์ง๋ง, ์ด๋ฌ๋ฉด ๋งค ์ฌ์ฉ๋ง๋ค ์ ๊ท ํํ์ ๊ฐ์ฒด๊ฐ ์๋ก ์์ฑ๋๋ฉฐ, ์ ๋ฐ์ดํธ๋๋ ์์ฑ์ ์ ๊ทผํ ์ ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ฅผ ์๊ฐํด๋ณด๊ฒ ์ต๋๋ค.
const myRe = /d(b+)d/g;
const myArray = myRe.exec("cdbbdbsbz");
console.log(`lastIndex์ ๊ฐ์ ${myRe.lastIndex}`);
// "lastIndex์ ๊ฐ์ 5"
๊ทธ๋ฌ๋ ์์ ์ฝ๋ ๋์ ์๋ ์ฝ๋๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด...
const myArray = /d(b+)d/g.exec("cdbbdbsbz");
console.log(`lastIndex์ ๊ฐ์ ${/d(b+)d/g.lastIndex}`);
// "lastIndex์ ๊ฐ์ 0"
๋ ๊ฐ์ /d(b+)d/g ๋ ์๋ก ๋ค๋ฅธ ์ ๊ท ํํ์ ๊ฐ์ฒด์ด๋ฏ๋ก ๋ณ๊ฐ์ lastIndex ์์ฑ์ ๊ฐ์ต๋๋ค. ์ ๊ท ํํ์ ๊ฐ์ฒด์ ์์ฑ์ ์ ๊ทผํด์ผ ํ๋ฉด, ์ฐ์ ๋ณ์์ ํ ๋นํ์ธ์.
ํ๋๊ทธ๋ฅผ ํ์ฉํ ๊ณ ๊ธ ํ์
์ ๊ท ํํ์์ ์ ์ญ ํ์์ด๋ ๋์๋ฌธ์ ๋ฌด์์ ๊ฐ์ ํน์ฑ์ ์ง์ ํ๋ ํ๋๊ทธ๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค. ํ๋๊ทธ๋ ๋จ๋ ์ผ๋ก ์ฌ์ฉํ ์๋ ์๊ณ , ์์์ ์๊ด ์์ด ํ๊บผ๋ฒ์ ์ฌ๋ฟ์ ์ง์ ํ ์๋ ์์ต๋๋ค.
| ํ๋๊ทธ | ์ค๋ช | ๋์ํ๋ ์์ฑ |
|---|---|---|
d |
๋ถ๋ถ ๋ฌธ์์ด ์ผ์น์ ๋ํด ์ธ๋ฑ์ค ์์ฑ. | RegExp.prototype.hasIndices |
g |
์ ์ญ ํ์. | RegExp.prototype.global |
i |
๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์์. | RegExp.prototype.ignoreCase |
m |
์ฌ๋ฌ ์ค์ ๊ฑธ์ณ ํ์. | RegExp.prototype.multiline |
s |
๊ฐํ ๋ฌธ์๊ฐ .๊ณผ ์ผ์นํจ. |
RegExp.prototype.dotAll |
u |
"unicode", ํจํด์ ์ ๋์ฝ๋ ์ฝ๋ ํฌ์ธํธ์ ์ํ์ค๋ก ๊ฐ์ฃผํจ. | RegExp.prototype.unicode |
y |
"์ ์ฐฉ" ํ์, ๋์ ๋ฌธ์์ด์ ํ์ฌ ์์น์์ ํ์์ ์์ํจ. sticky๋ฅผ ์ฐธ๊ณ ํ์ธ์. |
RegExp.prototype.sticky |
ํ๋๊ทธ๋ ๋ค์๊ณผ ๊ฐ์ ๊ตฌ๋ฌธ์ผ๋ก ์ ๊ท ํํ์์ ์ง์ ํ ์ ์์ต๋๋ค.
const re = /pattern/flags;
์์ฑ์๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ ์ด๋ ๊ฒ ์ง์ ํฉ๋๋ค.
const re = new RegExp("pattern", "flags");
ํ๋๊ทธ๋ ์ ๊ท์๊ณผ ์์ ํ ํฉ์ณ์ง๋ฏ๋ก ๋์ค์ ์ถ๊ฐํ๊ฑฐ๋ ์ ๊ฑฐํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, re = /\w+\s/g๋ ํ ๊ฐ ์ด์์ ๊ธ์์ ๊ทธ ๋ค์ ๊ณต๋ฐฑ ํ๋๋ฅผ, ๋ฌธ์์ด ์ ์ฒด์ ๋ํด ํ์ํฉ๋๋ค.
const re = /\w+\s/g;
const str = "fee fi fo fum";
const myArray = str.match(re);
console.log(myArray);
// ["fee ", "fi ", "fo "]
์๋ ์ฝ๋๋...
const re = /\w+\s/g;
์ด๋ ๊ฒ ์์ฑ์๋ฅผ ์ฌ์ฉํ๋๋ก ๋ฐ๊ฟ ์๋ ์์ต๋๋ค.
const re = new RegExp("\\w+\\s", "g");
๋ ๊ตฌ๋ฌธ ๋ชจ๋ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ณ์ต๋๋ค.
m ํ๋๊ทธ๋ ์ฌ๋ฌ ์ค์ ๊ฑธ์น ์
๋ ฅ ๋ฌธ์์ด์ ์ฌ๋ฌ ์ค๋ก ์ทจ๊ธํ๊ฒ ํฉ๋๋ค. ๋ฌ๋ฆฌ ๋งํด, m ํ๋๊ทธ๋ฅผ ์ง์ ํ ๊ฒฝ์ฐ, ^์ $๋ ๊ฐ๊ฐ ์ ์ฒด ์
๋ ฅ ๋ฌธ์์ด์ ์์๊ณผ ๋์ด ์๋๋ผ, ๊ฐ ์ค์ ์์๊ณผ ๋์ ๋์ํ๊ฒ ๋ฉ๋๋ค.
exec()๊ณผ ์ ์ญ ํ์ ํ๋๊ทธ ์ฌ์ฉํ๊ธฐ
RegExp.prototype.exec() ๋ฉ์๋์ g ํ๋๊ทธ๋ฅผ ์ฌ์ฉํ๋ฉด, ์ผ์นํ ๋ถ๋ถ ๋ฌธ์์ด๋ค๊ณผ ๊ฐ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ํ๋์ฉ ์์ฐจ์ ์ผ๋ก ๋ฐํํฉ๋๋ค.
const str = "fee fi fo fum";
const re = /\w+\s/g;
console.log(re.exec(str)); // ["fee ", index: 0, input: "fee fi fo fum"]
console.log(re.exec(str)); // ["fi ", index: 4, input: "fee fi fo fum"]
console.log(re.exec(str)); // ["fo ", index: 7, input: "fee fi fo fum"]
console.log(re.exec(str)); // null
๋ฐ๋ฉด, String.prototype.match() ๋ฉ์๋๋ ๋ชจ๋ ์ผ์น๋ฅผ ํ ๋ฒ์ ๋ฐํํ์ง๋ง, ๊ฐ๊ฐ์ ์ธ๋ฑ์ค๋ ํฌํจํ์ง ์์ต๋๋ค.
console.log(str.match(re)); // ["fee ", "fi ", "fo "]
์์
์ฐธ๊ณ : ๋ค์ ๋ฌธ์์์๋ ์ ๊ท ํํ์์ ์ฌ์ฉ ์์ ๋ฅผ ๋ณผ ์ ์์ต๋๋ค.
exec(),test(),match(),matchAll(),search(),replace(),split()๋ฉ์๋ ์ฐธ์กฐ- ์ด ์๋ด์์ ํ์ ๋ฌธ์: ๋ฌธ์ ํด๋์ค, ์ด์์ , ๊ทธ๋ฃน๊ณผ ๋ฒ์, ์๋์, ์ ๋์ฝ๋ ์์ฑ ์ด์ค์ผ์ดํ
์ ๊ท ํํ์ ํน์ ๋ฌธ์๋ฅผ ์ฌ์ฉํ ์ ๋ ฅ ๊ฐ ๊ฒ์ฆ
์๋ ์์ ์์๋ ์ฌ์ฉ์๊ฐ ์ ํ๋ฒํธ๋ฅผ ์ ๋ ฅํด์ผ ํฉ๋๋ค. ์ฌ์ฉ์๊ฐ "ํ์ธ" ๋ฒํผ์ ๋๋ฅด๋ฉด ์ ๋ ฅํ ๊ฐ์ ์คํฌ๋ฆฝํธ๋ก ๊ฒ์ฆํฉ๋๋ค. ๊ฐ์ด ์ ํจํ๋ฉด, ์ฆ ์ ๊ท ํํ์๊ณผ ์ผ์นํ๋ ๋ฌธ์์ ์ํ์ค๋ฅผ ๋ฐ์์ผ๋ฉด, ์คํฌ๋ฆฝํธ๋ ๊ฐ์ฌ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํฉ๋๋ค. ๊ฐ์ด ์ ํจํ์ง ์์ผ๋ฉด, ์ฌ์ฉ์์๊ฒ ์ฌ๋ฐ๋ฅด์ง ์์ ๊ฐ์์ ์๋ ค์ค๋๋ค.
์ ๊ท ํํ์์ ๊ตฌ์กฐ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ๋ฐ์ดํฐ์ ์์์ (
^) - ๋น์บก์ฒ ๊ทธ๋ฃน(
(?:))์ผ๋ก, 1์ ๋ค๋ฅผ ์๋ ์ธ ๊ฐ์ ์ซ์(\d{3}), ๋๋(|), ์ฌ๋ ๊ดํธ(\()์ ๋ค๋ฅผ ์๋ ์ธ ๊ฐ์ ์ซ์(\d{3})์ ๋ค๋ฅผ ์๋ ๋ซ๋ ๊ดํธ(\)) - ์บก์ฒ ๊ทธ๋ฃน(
())์ผ๋ก, 2์ ๋ค๋ฅผ ์๋ ํ๋์ ๋์, ์ฌ๋์, ๋๋ ๋ง์นจํ - 3์ ๋ค๋ฅผ ์๋ ๋ค ๊ฐ์ ์ซ์(
\d{4}) - 4์ ๋ค๋ฅผ ์๋, ์ฒซ ๋ฒ์งธ ์บก์ฒ ๊ทธ๋ฃน์์ ๊ธฐ์ตํ ๋ถ๋ถ ๋ฌธ์์ด(
\1) - 5์ ๋ค๋ฅผ ์๋ ๋ค ๊ฐ์ ์ซ์(
\d{4}) - ๋ฐ์ดํฐ์ ๋์ (
$)
HTML
<p>
์ ํ๋ฒํธ๋ฅผ ์
๋ ฅ ํ "ํ์ธ" ๋ฒํผ์ ๋๋ฅด์ธ์.
<br />
###-####-####์ ํ์์ผ๋ก ์
๋ ฅํ์ธ์.
</p>
<form id="form">
<input id="phone" />
<button type="submit">ํ์ธ</button>
</form>
<p id="output"></p>
JavaScript
const form = document.querySelector("#form");
const input = document.querySelector("#phone");
const output = document.querySelector("#output");
const re = /^(?:\d{3}|\(\d{3}\))([-\/\.])\d{4}\1\d{4}$/;
function testInfo(phoneInput) {
const ok = re.exec(phoneInput.value);
if (!ok) {
output.textContent = `ํ์์ ๋ง์ง ์๋ ์ ํ๋ฒํธ์
๋๋ค. (${phoneInput.value})`;
} else {
output.textContent = `๊ฐ์ฌํฉ๋๋ค. ์ ํ๋ฒํธ๋ ${ok[0]} ์
๋๋ค.`;
}
}
form.addEventListener("submit", (event) => {
event.preventDefault();
testInfo(input);
});
๊ฒฐ๊ณผ
๋๊ตฌ
- RegExr
-
์ ๊ท ํํ์์ ๋ฐฐ์ฐ๊ณ , ๋ง๋ค๊ณ , ์ํํ ์ ์๋ ์จ๋ผ์ธ ๋๊ตฌ์ ๋๋ค.
- Regex tester
-
์ ๊ท ํํ์ ์์ฑ๊ธฐ/๋๋ฒ๊ฑฐ์ ๋๋ค.
- Regex visualizer
-
์๊ฐ์ ์ ๊ท ํํ์ ํ ์คํฐ์ ๋๋ค.