MatchData encapsulates the result of matching a Regexp against string. It is returned by Regexp#match and String#match, and also stored in a global variable returned by Regexp.last_match.
url = 'https://docs.ruby-lang.org/en/2.5.0/MatchData.html' m = url.match(/(\d\.?)+/) # => # m.string # => "https://docs.ruby-lang.org/en/2.5.0/MatchData.html" m.regexp # => /(\d\.?)+/ # 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(?[^/]+)/(?[^/]+)\.html$>) m.captures # => ["2.5.0", "MatchData"] m.named_captures # => "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"] Parts of last MatchData (returned by Regexp.last_match) are also aliased as global variables:
See also “Special global variables” section in Regexp documentation.
Equality—Two matchdata are equal if their target strings, patterns, and matched positions are identical.
Match Reference – MatchData acts as an array, and may be accessed using the normal array indexing techniques.
Returns the offset of the start of the nth element of the match array in the string. Returns the array of captures; equivalent to mtch.to_a[1..-1] .Returns the offset of the character immediately following the end of the nth element of the match array in the string.
Equality—Two matchdata are equal if their target strings, patterns, and matched positions are identical.
Produce a hash based on the target string, regexp and matched positions of this matchdata. Returns a printable version of mtch. Returns the number of elements in the match array. Returns a Hash using named capture. Returns a list of names of captures as an array of strings. Returns a two-element array containing the beginning and ending offsets of the nth match. Returns the portion of the original string after the current match. Returns the portion of the original string before the current match. Returns the regexp. Returns the number of elements in the match array. Returns a frozen copy of the string passed in to match . Returns the array of matches. Returns the entire matched string. Uses each index to access the matching values, returning an array of the corresponding matches.Match Reference – MatchData acts as an array, and may be accessed using the normal array indexing techniques. mtch[0] is equivalent to the special variable $& , and returns the entire matched string. mtch[1] , mtch[2] , and so on return the values of the matched backreferences (portions of the pattern between parentheses).
m = /(.)(.)(\d+)(\d)/.match("THX1138.") m #=> # m[0] #=> "HX1138" m[1, 2] #=> ["H", "X"] m[1..3] #=> ["H", "X", "113"] m[-3, 2] #=> ["X", "113"] m = /(?a+)b/.match("ccaaab") m #=> # m["foo"] #=> "aaa" m[:foo] #=> "aaa" 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
# File 're.c', line 2026 static VALUE match_aref(int argc, VALUE *argv, VALUE match) < VALUE idx, length; match_check(match); rb_scan_args(argc, argv, "11", &idx, &length); if (NIL_P(length)) < if (FIXNUM_P(idx)) < return rb_reg_nth_match(FIX2INT(idx), match); >else < int num = namev_to_backref_number(RMATCH_REGS(match), RMATCH(match)->regexp, idx); if (num >= 0) < return rb_reg_nth_match(num, match); >else < return match_ary_aref(match, idx, Qnil); >> > else < long beg = NUM2LONG(idx); long len = NUM2LONG(length); long num_regs = RMATCH_REGS(match)->num_regs; if (len < 0) < return Qnil; >if (beg < 0) < beg += num_regs; if (beg < 0) return Qnil; >else if (beg > num_regs) < return Qnil; >else if (beg+len > num_regs) < len = num_regs - beg; >return match_ary_subseq(match, beg, len, Qnil); > >
Returns the offset of the start of the nth element of the match array in the string. n can be a string or symbol to reference a named capture.
m = /(.)(.)(\d+)(\d)/.match("THX1138.") m.begin(0) #=> 1 m.begin(2) #=> 2 m = /(?.)(.)(?.)/.match("hoge") p m.begin(:foo) #=> 0 p m.begin(:bar) #=> 2 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
# File 're.c', line 1242 static VALUE match_begin(VALUE match, VALUE n) < int i = match_backref_number(match, n); struct re_registers *regs = RMATCH_REGS(match); match_check(match); if (i < 0 || regs->num_regs rmatch->char_offset[i].beg); >
Returns the array of captures; equivalent to mtch.to_a[1..-1] .
f1,f2,f3,f4 = /(.)(.)(\d+)(\d)/.match("THX1138.").captures f1 #=> "H" f2 #=> "X" f3 #=> "113" f4 #=> "8" 1917 1918 1919 1920 1921# File 're.c', line 1917 static VALUE match_captures(VALUE match)
Returns the offset of the character immediately following the end of the nth element of the match array in the string. n can be a string or symbol to reference a named capture.
m = /(.)(.)(\d+)(\d)/.match("THX1138.") m.end(0) #=> 7 m.end(2) #=> 3 m = /(?.)(.)(?.)/.match("hoge") p m.end(:foo) #=> 1 p m.end(:bar) #=> 3 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
# File 're.c', line 1277 static VALUE match_end(VALUE match, VALUE n) < int i = match_backref_number(match, n); struct re_registers *regs = RMATCH_REGS(match); match_check(match); if (i < 0 || regs->num_regs rmatch->char_offset[i].end); >
Equality—Two matchdata are equal if their target strings,
patterns, and matched positions are identical. 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113
# File 're.c', line 3097 static VALUE match_equal(VALUE match1, VALUE match2) < const struct re_registers *regs1, *regs2; if (match1 == match2) return Qtrue; if (!RB_TYPE_P(match2, T_MATCH)) return Qfalse; if (!RMATCH(match1)->regexp || !RMATCH(match2)->regexp) return Qfalse; if (!rb_str_equal(RMATCH(match1)->str, RMATCH(match2)->str)) return Qfalse; if (!rb_reg_equal(match_regexp(match1), match_regexp(match2))) return Qfalse; regs1 = RMATCH_REGS(match1); regs2 = RMATCH_REGS(match2); if (regs1->num_regs != regs2->num_regs) return Qfalse; if (memcmp(regs1->beg, regs2->beg, regs1->num_regs * sizeof(*regs1->beg))) return Qfalse; if (memcmp(regs1->end, regs2->end, regs1->num_regs * sizeof(*regs1->end))) return Qfalse; return Qtrue; >
Produce a hash based on the target string, regexp and matched positions of this matchdata.
See also Object#hash.
3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086
# File 're.c', line 3071 static VALUE match_hash(VALUE match) < const struct re_registers *regs; st_index_t hashval; match_check(match); hashval = rb_hash_start(rb_str_hash(RMATCH(match)->str)); hashval = rb_hash_uint(hashval, reg_hash(match_regexp(match))); regs = RMATCH_REGS(match); hashval = rb_hash_uint(hashval, regs->num_regs); hashval = rb_hash_uint(hashval, rb_memhash(regs->beg, regs->num_regs * sizeof(*regs->beg))); hashval = rb_hash_uint(hashval, rb_memhash(regs->end, regs->num_regs * sizeof(*regs->end))); hashval = rb_hash_end(hashval); return ST2FIX(hashval); >
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
# File 're.c', line 1059 static VALUE match_init_copy(VALUE obj, VALUE orig) < struct rmatch *rm; if (!OBJ_INIT_COPY(obj, orig)) return obj; RMATCH(obj)->str = RMATCH(orig)->str; RMATCH(obj)->regexp = RMATCH(orig)->regexp; rm = RMATCH(obj)->rmatch; if (rb_reg_region_copy(&rm->regs, RMATCH_REGS(orig))) rb_memerror(); if (RMATCH(orig)->rmatch->char_offset_num_allocated) < if (rm->char_offset_num_allocated < rm->regs.num_regs) < REALLOC_N(rm->char_offset, struct rmatch_offset, rm->regs.num_regs); rm->char_offset_num_allocated = rm->regs.num_regs; > MEMCPY(rm->char_offset, RMATCH(orig)->rmatch->char_offset, struct rmatch_offset, rm->regs.num_regs); RB_GC_GUARD(orig); > return obj; >
Returns a printable version of mtch.
puts /.$/.match("foo").inspect #=> # puts /(.)(.)(.)/.match("foo").inspect #=> # puts /(.)(.)?(.)/.match("fo").inspect #=> # puts /(?.)(?.)(?.)/.match("hoge").inspect #=> # 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306
# File 're.c', line 2258 static VALUE match_inspect(VALUE match) < VALUE cname = rb_class_path(rb_obj_class(match)); VALUE str; int i; struct re_registers *regs = RMATCH_REGS(match); int num_regs = regs->num_regs; struct backref_name_tag *names; VALUE regexp = RMATCH(match)->regexp; if (regexp == 0) < return rb_sprintf("#", cname, (void*)match); > else if (NIL_P(regexp)) < return rb_sprintf("#", cname, rb_reg_nth_match(0, match)); > names = ALLOCA_N(struct backref_name_tag, num_regs); MEMZERO(names, struct backref_name_tag, num_regs); onig_foreach_name(RREGEXP_PTR(regexp), match_inspect_name_iter, names); str = rb_str_buf_new2("# <"); rb_str_append(str, cname); for (i = 0; i < num_regs; i++) < VALUE v; rb_str_buf_cat2(str, " "); if (0 < i) < if (names[i].name) rb_str_buf_cat(str, (const char *)names[i].name, names[i].len); else < rb_str_catf(str, "%d", i); >rb_str_buf_cat2(str, ":"); > v = rb_reg_nth_match(i, match); if (v == Qnil) rb_str_buf_cat2(str, "nil"); else rb_str_buf_append(str, rb_str_inspect(v)); > rb_str_buf_cat2(str, ">"); return str; >
Returns the number of elements in the match array.
m = /(.)(.)(\d+)(\d)/.match("THX1138.") m.length #=> 5 m.size #=> 5