MatchData

MatchData는 Regexp를 문자열과 매칭한 결과를 담는 객체예요. Regexp#match나 String#match가 돌려주고, Regexp.last_match가 돌려주는 전역 변수에도 저장돼요.

url = 'https://docs.ruby-lang.org/en/2.5.0/MatchData.html'
m = url.match(/(\d\.?)+/)   # => #<MatchData "2.5.0" 1:"0">
m.string  # => "https://docs.ruby-lang.org/en/2.5.0/MatchData.html"
m.regexp  # => /(\d\.?)+/

출처: Ruby 4.0 API

본문

전체 매치와 캡처를 인덱스로 접근하는 기본 패턴부터 볼게요.

# entire matched substring:
m[0]        # => "2.5.0"

# Working with unnamed captures
m = url.match(%r{([^/]+)/([^/]+)\.html$})
m.captures  # => ["2.5.0", "MatchData"]
m[1]        # => "2.5.0"
m.values_at(1, 2)  # => ["2.5.0", "MatchData"]

# Working with named captures
m = url.match(%r{(?<version>[^/]+)/(?<module>[^/]+)\.html$})
m.captures        # => ["2.5.0", "MatchData"]
m.named_captures  # => {"version"=>"2.5.0", "module"=>"MatchData"}
m[:version]       # => "2.5.0"
m.values_at(:version, :module)  # => ["2.5.0", "MatchData"]

# Numerical indexes are working, too
m[1]  # => "2.5.0"
m.values_at(1, 2)  # => ["2.5.0", "MatchData"]

마지막 MatchData(Regexp.last_match이 돌려주는 것)의 일부는 전역 변수로도 별칭돼 있어요. $~는 Regexp.last_match이고, $&는 Regexp.last_match[0]이에요. $1, $2 등은 Regexp.last_match[i](번호로 캡처), $`는 Regexp.last_match.pre_match, $'는 Regexp.last_match.post_match, $+는 Regexp.last_match[-1](마지막 캡처)에 대응돼요.

Public Instance Methods

matchdata == object → true or false

object가 self와 대상 문자열, regexp, 매치, 캡처가 모두 같은 다른 MatchData 객체면 true를, 아니면 false를 돌려줘요. eql?의 별칭이에요.

matchdata[index] → string or nil
matchdata[start, length] → array
matchdata[range] → array
matchdata[name] → string or nil

index, start+length, range 인자가 주어지면 Array#[] 방식으로 매치와 캡처를 돌려줘요.

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m[0]      # => "HX1138"
m[1, 2]   # => ["H", "X"]
m[1..3]   # => ["H", "X", "113"]
m[-3, 2]  # => ["X", "113"]

name(문자열 또는 심볼) 인자가 주어지면 해당 이름의 매치된 부분 문자열을 돌려줘요.

m = /(?<foo>.)(.)(?<bar>.+)/.match("hoge")
# => #<MatchData "hoge" foo:"h" bar:"ge">
m['foo']  # => "h"
m[:bar]   # => "ge"

여러 캡처가 같은 이름을 가질 땐 마지막에 매치된 부분 문자열을 돌려줘요.

m = /(?<foo>.)(?<foo>.+)/.match("hoge")
# => #<MatchData "hoge" foo:"h" foo:"oge">
m[:foo] #=> "oge"

m = /\W(?<foo>.+)|\w(?<foo>.+)|(?<foo>.+)/.match("hoge")
#<MatchData "hoge" foo:nil foo:"oge" foo:nil>
m[:foo] #=> "oge"

begin(n) → integer
begin(name) → integer

지정된 매치의 시작 오프셋(문자 단위)을 돌려줘요. 음이 아닌 정수 n이 주어지면 n번째 매치의 시작 오프셋을 돌려줘요.

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m[0]        # => "HX1138"
m.begin(0)  # => 1
m[3]        # => "113"
m.begin(3)  # => 3

문자열이나 심볼 name이 주어지면 이름 있는 매치의 시작 오프셋을 돌려줘요. 관련: MatchData#end, MatchData#offset, MatchData#byteoffset.

bytebegin(n) → integer
bytebegin(name) → integer

지정된 매치의 시작 오프셋(바이트 단위)을 돌려줘요. 정수 n이면 n번째, name이면 그 이름의 매치의 시작 오프셋이에요. 관련: MatchData#byteend, MatchData#byteoffset.

byteend(n) → integer
byteend(name) → integer

지정된 매치의 끝 오프셋(바이트 단위)을 돌려줘요. 관련: MatchData#bytebegin, MatchData#byteoffset.

byteoffset(n) → array

n번째 매치의 시작·끝 바이트 오프셋을 담은 2-요소 배열을 돌려줘요. n은 이름 있는 캡처를 가리키는 문자열이나 심볼일 수도 있어요.

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
m.byteoffset(0)  #=> [1, 7]
m.byteoffset(4)  #=> [6, 7]

m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
p m.byteoffset(:foo) #=> [0, 1]
p m.byteoffset(:bar) #=> [2, 3]

captures → array

m[0]을 제외한 모든 매치인 캡처 배열을 돌려줘요.

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m[0]        # => "HX1138"
m.captures  # => ["H", "X", "113", "8"]

관련: MatchData.to_a. deconstruct로도 부를 수 있어요.

deconstruct_keys(array_of_names) → hash

주어진 이름들에 대한 이름 있는 캡처를 해시로 돌려줘요.

m = /(?<hours>\d{2}):(?<minutes>\d{2}):(?<seconds>\d{2})/.match("18:37:22")
m.deconstruct_keys([:hours, :minutes])  # => {:hours => "18", :minutes => "37"}
m.deconstruct_keys(nil)                 # => {:hours => "18", :minutes => "37", :seconds => "22"}

이름 있는 캡처가 정의되지 않았으면 빈 해시를 돌려줘요.

m = /(\d{2}):(\d{2}):(\d{2})/.match("18:37:22")
m.deconstruct_keys(nil) # => {}

end(n) → integer
end(name) → integer

지정된 매치의 끝 오프셋(문자 단위)을 돌려줘요. 정수 n이면 n번째, name이면 그 이름의 매치의 끝 오프셋이에요. 관련: MatchData#begin, MatchData#offset, MatchData#byteoffset.

hash → integer

대상 문자열, regexp, 매치, 캡처를 바탕으로 한 self의 정수 해시 값을 돌려줘요. Object#hash도 참고하세요.

inspect → string

self의 문자열 표현을 돌려줘요.

m = /.$/.match("foo")
# => #<MatchData "o">
m.inspect # => "#<MatchData \"o\">"

관련: MatchData#to_s.

match(n) → string or nil
match(name) → string or nil

주어진 인자에 해당하는 매치된 부분 문자열을 돌려줘요. 정수 n이면 n번째 매치, 문자열/심볼 name이면 그 이름의 매치이에요.

m = /(.)(.)(\d+)(\d)(\w)?/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8" 5:nil>
m.match(0) # => "HX1138"
m.match(4) # => "8"
m.match(5) # => nil

match_length(n) → integer or nil
match_length(name) → integer or nil

주어진 인자에 해당하는 매치된 부분 문자열의 길이(문자 단위)를 돌려줘요. 매치가 없으면 nil이에요.

named_captures(symbolize_names: false) → hash

이름 있는 캡처를 해시로 돌려줘요. 키는 캡처 이름, 값은 그 캡처 문자열 또는 nil이에요.

m = /(?<foo>.)(.)(?<bar>.+)/.match("hoge")
# => #<MatchData "hoge" foo:"h" bar:"ge">
m.named_captures # => {"foo"=>"h", "bar"=>"ge"}

m = /(?<a>.)(?<a>.)/.match("01")
# => #<MatchData "01" a:"0" a:"1">
m.named_captures #=> {"a" => "1"}

symbolize_names 키워드 인자에 참 값을 주면 결과 해시의 키가 Symbol이 돼요.

m = /(?<a>.)(?<a>.)/.match("01")
m.named_captures(symbolize_names: true) #=> {:a => "1"}

names → array_of_names

캡처 이름들의 배열을 돌려줘요.

m = /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge")
# => #<MatchData "hog" foo:"h" bar:"o" baz:"g">
m.names # => ["foo", "bar", "baz"]

m = /foo/.match('foo')  # => #<MatchData "foo">
m.names # => [] # No named captures.

다음과 동일해요.

m.regexp.names # => ["foo", "bar", "baz"]

offset(n) → [start_offset, end_offset]
offset(name) → [start_offset, end_offset]

지정된 매치의 시작·끝 오프셋(문자 단위)을 담은 2-요소 배열을 돌려줘요. 관련: MatchData#byteoffset, MatchData#begin, MatchData#end.

post_match → str

self(즉 self[0])의 첫 매치 끝부터 대상 문자열 끝까지의 부분 문자열을 돌려줘요. regexp 전역 변수 $'와 같아요.

m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m.post_match # => ": The Movie"