Regexp 클래스

Regexp 클래스

Regexp는 정규식(regular expression)을 다루는 클래스예요. 정규식은 문자열 안에서 패턴을 검색할 때 쓰는 강력한 도구랍니다. /.../ 리터럴로 만들 수 있어요.

출처: Ruby 3.3 API

본문

정규식 만들기 (Creating a Regexp)

정규식은 리터럴로 만들거나 Regexp.new로 만들 수 있어요:

/foo/
Regexp.new('foo')   # => /foo/
%r{foo}             # => /foo/

문자열에서 두 배 슬래시(|)나 옵션을 포함해 만들 수도 있어요.

Regexp.new('foo|bar', Regexp::IGNORECASE) # => /foo|bar/i

// 비어 있는 정규식, / \/ 같은 이스케이프, 그리고 /world/ 같은 리터럴이 서로 같은 객체가 아닐 수 있다는 점(리터럴은 C-말단에서 동결되어 재사용될 수 있지만 일반적으로는 아님)에 주의하세요.

/world/.object_id == /world/.object_id   # => false (보통)
/world/.frozen?                          # => false

패턴 (Patterns)

정규식 패턴은 문자열과 "일치(match)"하는지를 검사하는 규칙이에요. 대부분의 문자는 문자 그대로 자신과 일치해요.

/a/ =~ 'abc'   # => 0
/b/ =~ 'abc'   # => 1
/c/ =~ 'abc'   # => 2

메타문자 (Metacharacters)

일부 문자는 특별한 "메타" 의미를 가져요:

  • . : 개행을 제외한 모든 문자
  • * : 앞의 항목이 0번 이상 반복
  • + : 앞의 항목이 1번 이상 반복
  • ? : 앞의 항목이 0번 또는 1번
  • [] : 문자 클래스
  • () : 그룹(캡처)
  • | : 대안(alternation)
  • ^, $ : 문자열/줄의 시작·끝
  • \ : 이스케이프

메타문자를 문자 그대로 쓰려면 \로 이스케이프해요: /\./, /a\+b/처럼.

문자 클래스 (Character Classes)

  • [abc] : a, b, c 중 하나
  • [^abc] : a, b, c를 제외한 문자
  • [a-z] : a부터 z까지 범위
  • \d : 숫자 (0-9), \D는 숫자 아님
  • \w : 단어 문자 (a-z, A-Z, 0-9, _), \W는 그 외
  • \s : 공백 문자, \S는 공백 아님

그룹과 캡처 (Grouping and Capturing)

(...)는 그룹을 만들어 일치한 부분을 캡처해요. (?<name>...)로 이름을 붙일 수도 있어요.

md = /(foo)(bar)/.match('foobar')
md[1]   # => "foo"
md[2]   # => "bar"

md = /(?<first>\d+)-(?<second>\d+)/.match('12-34')
md[:first]   # => "12"
md[:second]  # => "34"

비캡처 그룹 (?:...)는 그룹은 만들지만 캡처하지 않아요.

앵커 (Anchors)

  • ^ : 줄의 시작
  • $ : 줄의 끝
  • \A : 문자열의 시작
  • \z : 문자열의 끝
  • \b : 단어 경계

수량자 (Quantifiers / Repetition)

  • a* : a가 0개 이상 (탐욕적)
  • a+ : a가 1개 이상
  • a? : a가 0개 또는 1개
  • a{n} : a가 정확히 n개
  • a{n,} : a가 n개 이상
  • a{n,m} : a가 n개 이상 m개 이하
  • a*? : 게으른(lazy) 반복

플래그 (Options / Flags)

정규식에 플래그를 붙여 동작을 바꿀 수 있어요:

  • i (IGNORECASE) : 대소문자 무시
  • m (MULTILINE) : .이 개행도 포함
  • x (EXTENDED) : 공백과 주석 허용
  • o : 한 번만 컴파일(리터럴에서 유효)
/foo/i =~ 'FOO'   # => 0
/FOO/i =~ 'foo'   # => 0

공개 클래스 메서드 (Public Class Methods)

new(string, options = 0, timeout: nil) → new_regexp / compile

주어진 문자열과 옵션으로 새 정규식을 만들어요. Regexp.compile은 new의 별칭이에요.

r = Regexp.new('foo')            # => /foo/
r = Regexp.new('foo', Regexp::IGNORECASE)  # => /foo/i

escape(string) → new_string / quote

문자열에서 정규식 메타문자를 이스케이프해요. 결과는 독해 가능한 패턴이 돼요. Regexp.quote는 escape의 별칭이에요.

Regexp.escape('.*?')   # => "\.\*\?"

last_match → matchdata / nil, last_match(n) → string

현재 스코프에서 마지막으로 일치한 결과(MatchData)를 반환해요. 정수 n이 주어지면 MatchData#[]처럼 마지막 일치의 n번째 부분 문자열을 반환해요.

/(.)(.)(.)/.match("abc")
Regexp.last_match      # => #<MatchData "abc" 1:"a" 2:"b" 3:"c">
Regexp.last_match(2)   # => "b"

try_convert(object) → new_regexp or nil

object.to_regexp를 호출해 정규식으로 변환을 시도해요. 변환이 불가능하면 nil을 반환해요.

union(patterns) → new_regexp

주어진 패턴들을 |로 연결해 하나의 정규식으로 만들어요. 문자열, 정규식, 문자 클래스 배열이 인자로 올 수 있어요.

Regexp.union("cat", "dog")          # => /cat|dog/
Regexp.union([/a/, /b/])            # => /a|b/

공개 인스턴스 메서드 (Public Instance Methods)

self =~ string → integer or nil

string에서 정규식과 일치하는 첫 위치를 반환해요. 일치가 없으면 nil. =~는 반대 순서로도 동작해요 (string =~ regexp).

/at/ =~ 'input data'   # => 3

주의: =~는 오퍼랜드가 정규식이 아니면 NilClass#=~나 다른 타입에 위임할 수 있어요.

~ regexp → integer or nil (일치일치)

$_(마지막으로 읽은 줄)에서 정규식과 일치하는 위치를 반환해요. 일치가 없으면 nil. 일치하면 $~가 채워져요.

$_ = "input data"
~ /at/   # => 3

self === string → true or false

string에서 정규식이 일치하면 true, 아니면 false를 반환해요. match의 별칭(alias for match)이에요. case 문에서 정규식을 쓸 때 유용해요.

Regexp.new("e") === "hello"   # => true
Regexp.new("z") === "hello"   # => false

casefold? → true or false

정규식이 대소문자를 무시하는지(i 플래그) 반환해요.

/foo/.casefold?      # => false
/foo/i.casefold?     # => true

encoding → encoding

정규식의 인코딩을 반환해요. 어떤 인코딩으로 해석되는지 알려줘요.

eql?(other) / ==

두 정규식이 같은 소스, 옵션, 인코딩을 가지면 true를 반환해요. ==는 eql?의 별칭이에요.

/foo/ == /foo/      # => true
/foo/ == /bar/      # => false

fixed_encoding? → true or false

정규식의 인코딩이 고정되어 있고, 문자열에 따라 자동으로 바뀌지 않는지 반환해요.

/foo/.fixed_encoding?      # => false
/\u{6666}/.fixed_encoding? # => true

hash → integer

정규식의 해시 값을 반환해요. 같은 소스·옵션을 가진 정규식은 같은 해시를 가져요.

inspect → string

검사용 문자열 표현을 반환해요. to_s와 유사하지만, 이스케이프된 소스를 반환해요.

/ab+c/ix.inspect   # => "/ab+c/ix"

match(string, pos = 0) → matchdata or nil

string에서 정규식과 일치하는 첫 MatchData를 반환해요. 일치가 없으면 nil. pos는 검색 시작 위치예요.

r = /(.)(.)(.)/
r.match("abc")[:2]   # => "b"
r.match("abc", 1)[:2]   # => "c"

블록이 주어지면 일치할 때만 블록을 호출해요.

r.match("abc") { |m| puts m[1] }   # => "a"

match?(string, pos = 0) → true or false

string에서 정규식이 일치하는지 여부만 반환해요. match와 달리 캡처 ($~)를 설정하지 않아서 더 빨라요.

/a/.match?("abc")   # => true
/a/.match?("xyz")   # => false

named_captures → hash

이름 있는 캡처 그룹들을 <name> => 번호 해시로 반환해요.

r = /(?<foo>bar)(?<baz>qux)/
r.named_captures   # => {"foo"=>1, "baz"=>2}

names → array

정규식에 있는 이름 있는 캡처 그룹들의 이름 배열을 반환해요.

r = /(?<foo>bar)(?<baz>qux)/
r.names   # => ["foo", "baz"]

options → integer

정규식을 만들 때 설정된 옵션(플래그)의 정수 값을 반환해요.

/foo/.options          # => 0
/foo/i.options         # => 1
/foo/m.options         # => 2
/foo/im.options        # => 3
/foo/ix.options        # => 5

source → string

정규식의 원본 소스 문자열을 반환해요(슬래시 제외).

/foo/.source        # => "foo"
/foo|bar/.source    # => "foo|bar"

string → string

정규식이 만들어진 원본 문자열을 반환해요. new에 준 문자열이나 리터럴의 소스예요.

Regexp.new("foo").string   # => "foo"
/foo/.string               # => "foo"

to_s → string

정규식을 다시 리터럴로 쓸 수 있는 문자열로 반환해요. 옵션 플래그를 포함해요.

r = /foo|bar/i
r.to_s   # => "(?i-mx:foo|bar)"

상수 (Constants)

  • IGNORECASE: 대소문자 무시 플래그(1)
  • EXTENDED: 확장 모드 플래그(2)
  • MULTILINE: 멀티라인 플래그(4)
  • FIXEDENCODING: 고정 인코딩 플래그(16)
  • NOENCODING: 인코딩 없는 바이너리 플래그(32)

더 알아보기

  • Regexp 사용법 — 정규식의 상세 문법(메타문자, 문자 클래스, 그룹, 앵커 등)은 이 페이지에서 더 자세히 다뤄요.
  • MatchData — match가 반환하는 일치 결과 객체