コンテンツにスキップ

文字列の操作

String#gsub

  • 文字列中でパターンにマッチするすべての部分を置換した文字列を返す。
p 'abcdefg'.gsub(/def/, '!!')           # => "abc!!g"
p 'abcabc'.gsub(/b/, '<<\&>>')          # => "a<<b>>ca<<b>>c"
p 'xxbbxbb'.gsub(/x+(b+)/, 'X<<\1>>')   # => "X<<bb>>X<<bb>>"
p '2.5'.gsub('.', ',')                  # => "2,5"

String#sub

  • 文字列中でパターンにマッチする最初の部分を置換した文字列を返す。
p 'abcdefg'.sub(/def/, '!!')            # => "abc!!g"
p 'abcabc'.sub(/b/, '<<\&>>')           # => "a<<b>>cabc"
p 'xxbbxbb'.sub(/x+(b+)/, 'X<<\1>>')    # => "X<<bb>>xbb"

String#replace

  • 与えられた文字列でレシーバの内容を置き換える。
str = "foo"
str.replace "bar"
p str   # => "bar"

String#delete

  • self から、指定された文字を全て取り除く。
  • 破壊的に取り除く場合は、String#delete! を使用する。
p "123456789".delete("2378")         # => "14569"
p "123456789".delete("2-8", "^4-6")  # => "14569"

String#delete_prefix

  • self の先頭から、指定された文字を取り除く。
  • 破壊的に取り除く場合は、String#delete_prefix! を使用する。
"hello".delete_prefix("hel")  # => "lo"
"hello".delete_prefix("llo")  # => "hello"

String#delete_suffix

  • self の末尾から、指定された文字を取り除く。
  • 破壊的に取り除く場合は、String#delete_suffix! を使用する。
"hello".delete_suffix("llo")  # => "he"
"hello".delete_suffix("hel")  # => "hello"

String#strip

  • self の先頭と末尾の空白文字（\t, \r, \n, \f, \v）を取り除く。
  • 破壊的に取り除く場合は、String#strip! を使用する。
"  abc  \r\n".strip     # => "abc"
"abc\n".strip           # => "abc"
"  abc".strip           # => "abc"
"abc".strip             # => "abc"
"  \0  abc  \0".strip   # => "abc"

String#chomp

  • self の末尾から改行コードを取り除く。
  • 破壊的に取り除く場合は、String#chomp! を使用する。
"foo\n".chomp             # => "foo"
"foo\n".chomp("\n")       # => "foo"
"foo\r\n".chomp("\r\n")   # => "foo"

$/ = "\n"   # デフォルト値と同じ
"foo\r".chomp             # => "foo"
"foo\r\n".chomp           # => "foo"
"foo\n".chomp             # => "foo"
"foo\n\r".chomp           # => "foo\n"

"string\n".chomp(nil)     # => "string\n"

"foo\r\n\n".chomp("")     # => "foo"
"foo\n\r\n".chomp("")     # => "foo"
"foo\n\r\r".chomp("")     # => "foo\n\r\r"

String#chop

  • self の末尾の文字を取り除く。ただし、末尾が \r\n であれば、２文字とも取り除く。
  • 破壊的に取り除く場合は、String#chop! を使用する。
"string\n".chop     # => "string"
"string\r\n".chop   # => "string"
"string".chop       # => "strin"
"strin".chop        # => "stri"
"".chop             # => ""

String#[]

  • 指定した範囲の文字列を取り出す。
  • 負の数を指定した場合は文字列の末尾から数える。
  • String#slice は別名メソッド
# n 番目の 1 文字取り出し
p 'bar'[2]        # => "r"
p 'bar'[-1]       # => "r"
p 'bar'[3]        # => nil
p 'bar'[-4]       # => nil

# n 番目から m 文字取り出し
p 'bar'[2, 1]     # => "r"
p 'bar'[2, 0]     # => ""
p 'bar'[2, 100]   # => "r"  (右側を超えても平気)
p 'bar'[-1, 1]    # => "r"
p 'bar'[-1, 2]    # => "r"  (右に向かって len 文字)
p 'bar'[3, 1]     # => ""
p 'bar'[4, 1]     # => nil
p 'bar'[-4, 1]    # => nil

# 指定範囲の取り出し
'abcd'[2..1]      # => ""
'abcd'[2..2]      # => "c"
'abcd'[2..3]      # => "cd"
'abcd'[2..4]      # => "cd"
'abcd'[2..-1]     # => "cd"  (str[f..-1] は「f 文字目から文字列の最後まで」を表す慣用句)
'abcd'[3..-1]     # => "d"
'abcd'[1..2]      # => "bc"
'abcd'[2..2]      # => "c"
'abcd'[3..2]      # => ""
'abcd'[4..2]      # => ""
'abcd'[5..2]      # => nil
'abcd'[-3..2]     # => "bc"
'abcd'[-4..2]     # => "abc"
'abcd'[-5..2]     # => nil

# 指定範囲の取り出し（終端を含まない）
'abcd'[2...3]     # => "c"
'abcd'[2...4]     # => "cd"
'abcd'[2...5]     # => "cd"
'abcd'[1...2]     # => "b"
'abcd'[2...2]     # => ""
'abcd'[3...2]     # => ""
'abcd'[4...2]     # => ""
'abcd'[5...2]     # => nil
'abcd'[-3...2]    # => "b"
'abcd'[-4...2]    # => "ab"
'abcd'[-5...2]    # => nil

String#slice!

  • 指定した範囲を文字列から取り除いた上で取り除いた部分文字列を返す。
  • 引数が範囲外を指す場合は nil を返す。
string = "this is a string"

# 非破壊的メソッド ( String#[] の別名メソッド)
string.slice(2)         # => "i"
string.slice(4..7)      # => " is "
string.slice(4, 4)      # => " is "
string.slice(/s.*t/)    # => "sa st"
string.slice("r")       # => "r"
string                  # => "this is a string"

# 破壊的メソッド
string.slice!(2)        # => "i"
string.slice!(3..6)     # => " is "
string.slice!(/s.*t/)   # => "sa st"
string.slice!("r")      # => "r"
string                  # => "thing"

String#index

  • 文字列の右から検索し、最初に見つかった部分文字列の左端のインデックスを返す。見つからなければ nil を返す。
  • 探索を開始するインデックスが負の場合は、文字列の末尾から数えた位置より探索する。
p "astrochemistry".index("str")         # => 1
p "regexpindex".index(/e.*x/, 2)        # => 3
p "character".index(?c)                 # => 0

p "foobarfoobar".index("bar", 6)        # => 9
p "foobarfoobar".index("bar", -6)       # => 9

String#rindex

  • 文字列の左から検索し、最初に見つかった部分文字列の左端のインデックスを返す。見つからなければ nil を返す。
  • 探索を開始するインデックスが負の場合は、文字列の末尾から数えた位置より探索する。
p "astrochemistry".rindex("str")        # => 10
p "character".rindex(?c)                # => 5
p "regexprindex".rindex(/e.*x/, 2)      # => 1

p "foobarfoobar".rindex("bar", 6)       # => 3
p "foobarfoobar".rindex("bar", -6)      # => 3