Ruby文字列操作 チートシート

cheatsheet
Rubyメソッド操作文字列

目的別のRuby文字列操作メソッド一覧

文字列の作成

新しい文字列オブジェクトを生成する方法です。

メソッド / 構文 説明 コード例
"..." (ダブルクォート) 最も一般的な文字列リテラル。式展開 (#{...}) とバックスラッシュ記法 (\n, \t など) が有効。 
name = "Alice"
puts "Hello, #{name}!\nWelcome."
#=> Hello, Alice!
#   Welcome.
'...' (シングルクォート) 式展開と一部のバックスラッシュ記法 (\\' と \\\\ 以外) が無効な文字列リテラル。 
path = 'C:\Users\Bob'
puts 'Hello, #{name}!\nWelcome.'
#=> Hello, #{name}!\nWelcome.
%q{...}, %q(...), etc. シングルクォート相当の文字列リテラル。区切り文字は {}, (), [], <> や他の任意の非英数字を使用可能。 
puts %q{シングルクォート'を含む'文字列}
#=> シングルクォート'を含む'文字列
%Q{...}, %{...}, etc. ダブルクォート相当の文字列リテラル。式展開とバックスラッシュ記法が有効。区切り文字は %q と同様。 
value = 100
puts %Q|値は #{value} です。|
#=> 値は 100 です。
ヒアドキュメント (<<IDENTIFIER) 複数行の文字列を記述するのに便利。デフォルトでダブルクォート相当 (式展開可)。<<-'IDENTIFIER' でインデントを無視、<<'IDENTIFIER' でシングルクォート相当 (式展開不可)。 
query = <<SQL
SELECT *
FROM users
WHERE id = 1;
SQL
puts query

message = <<-MSG
  インデントされていても
  左端から始まる文字列。
  MSG
puts message
String.new(str = "") 新しい空の文字列、または指定した文字列のコピーを作成する。 
empty_str = String.new
puts empty_str #=> "" (空文字列)

copy_str = String.new("コピー元")
puts copy_str #=> コピー元

文字列の連結 🔗

複数の文字列を結合する方法です。

メソッド 説明 コード例
+ (other_str) 新しい文字列として、self と other_str を連結したものを返す。(非破壊的) 
str1 = "Hello, "
str2 = "World!"
result = str1 + str2
puts result #=> "Hello, World!"
puts str1   #=> "Hello, " (元の文字列は変化しない)
<< (obj) / concat(obj, ...) self の末尾に obj (文字列または整数 – 文字コードとして) を連結する。(破壊的) concat は複数の引数を取れる。 
str = "Ruby"
str << " on Rails"
puts str #=> "Ruby on Rails"

str.concat("!", "!!", 33) # 33は '!' の文字コード
puts str #=> "Ruby on Rails!!!!"
prepend(other_str, ...) self の先頭に other_str を連結する。(破壊的) 複数の引数を取れる。 
framework = "Rails"
framework.prepend("Ruby on ")
puts framework #=> "Ruby on Rails"

framework.prepend("Learn ", "Fast ")
puts framework #=> "Learn Fast Ruby on Rails"
式展開 ("#{...}") ダブルクォート文字列内で変数の内容などを埋め込む際に、事実上の連結が行われる。 
lang = "Ruby"
version = "3.2"
description = "#{lang} version #{version}"
puts description #=> "Ruby version 3.2"
* (integer) 文字列を指定された回数繰り返した新しい文字列を返す。(非破壊的) 
puts "Go! " * 3 #=> "Go! Go! Go! "

文字列の長さ・空判定📏

文字列の長さ（文字数またはバイト数）を取得したり、空かどうかを判定したりする方法です。

メソッド 説明 コード例
length / size 文字列の文字数を返す。多バイト文字も1文字としてカウントする。 
puts "Ruby".length       #=> 4
puts "ルビー".length     #=> 3
puts "ルビー".size       #=> 3 (lengthのエイリアス)
bytesize 文字列のバイト数を返す。エンコーディングによって結果が変わる。 
puts "Ruby".bytesize     #=> 4 (UTF-8)
puts "ルビー".bytesize   #=> 9 (UTF-8, 1文字3バイト * 3)
empty? 文字列が空 (長さが0) であれば true を、そうでなければ false を返す。 
puts "".empty?          #=> true
puts " ".empty?         #=> false (スペースは空ではない)
puts "Ruby".empty?       #=> false

文字列の比較 🤝

文字列同士を比較する方法です。

メソッド / 演算子 説明 コード例
== (other) 内容が等しい場合に true を返す。大文字小文字は区別される。 
puts "ruby" == "ruby"  #=> true
puts "ruby" == "Ruby"  #=> false
puts "ruby" == "other" #=> false
eql?(other) == と同様に内容を比較する。ハッシュのキー比較などで使われる。 
puts "ruby".eql?("ruby") #=> true
puts "ruby".eql?("Ruby") #=> false
equal?(other) 同一のオブジェクトを指している場合に true を返す (オブジェクトIDの比較)。 
a = "ruby"
b = "ruby"
c = a
puts a.equal?(b) #=> false (内容は同じだが別オブジェクト)
puts a.equal?(c) #=> true (同じオブジェクトを指す)
casecmp(other) 大文字小文字を区別せずに比較する。self が other より小さい場合は負の値、等しい場合は 0、大きい場合は正の値を返す。nil を返す場合は比較不能。 
puts "ruby".casecmp("Ruby")   #=> 0
puts "abc".casecmp("abd")   #=> -1
puts "abd".casecmp("abc")   #=> 1
puts "Ruby".casecmp("日本語") #=> nil (エンコーディング互換性がない場合など)
casecmp?(other) 大文字小文字を区別せずに比較し、等しい場合に true、そうでない場合に false を返す。 
puts "ruby".casecmp?("Ruby") #=> true
puts "ruby".casecmp?("java") #=> false
<=> (other) 辞書順で比較する。self が other より小さい場合は -1、等しい場合は 0、大きい場合は 1 を返す。大文字小文字は区別される。比較不能な場合は nil を返す。 
puts "abc" <=> "abd" #=> -1
puts "abc" <=> "abc" #=> 0
puts "abd" <=> "abc" #=> 1
puts "abc" <=> "ABC" #=> 1 (小文字 > 大文字)
puts "Ruby" <=> 123   #=> nil (比較不能)
<, <=, >, >= <=> を利用した辞書順比較の結果を真偽値で返す。 
puts "abc" < "abd"  #=> true
puts "abc" >= "abc" #=> true
puts "abd" > "abc"  #=> true

文字列の検索・置換 🔍

文字列内から特定のパターンを検索したり、置換したりする方法です。

メソッド 説明 コード例
include?(substring) 指定した部分文字列 substring が含まれていれば true を返す。 
puts "Hello Ruby".include?("Ruby") #=> true
puts "Hello Ruby".include?("Java") #=> false
index(pattern, offset = 0) 指定した pattern (文字列または正規表現) が最初に現れる位置 (インデックス) を返す。見つからない場合は nil を返す。offset で検索開始位置を指定できる。 
puts "Ruby Ruby".index("Ruby")   #=> 0
puts "Ruby Ruby".index("Ruby", 1) #=> 5
puts "Ruby Ruby".index("Java")   #=> nil
puts "Ruby123".index(/[0-9]+/) #=> 4
rindex(pattern, offset = length) 指定した pattern が最後に現れる位置を返す。見つからない場合は nil を返す。offset で検索終了位置を指定できる。 
puts "Ruby Ruby".rindex("Ruby")   #=> 5
puts "Ruby Ruby".rindex("Ruby", 4) #=> 0
puts "Ruby Ruby".rindex("Java")   #=> nil
start_with?(prefix, ...) 指定した接頭辞 prefix のいずれかで始まっていれば true を返す。 
puts "Ruby".start_with?("Ru")     #=> true
puts "Ruby".start_with?("ru", "Py") #=> false
puts "image.png".start_with?("img", "pic", "image") #=> true
end_with?(suffix, ...) 指定した接尾辞 suffix のいずれかで終わっていれば true を返す。 
puts "data.csv".end_with?(".csv")       #=> true
puts "data.csv".end_with?(".txt", ".log") #=> false
puts "report.pdf".end_with?(".doc", ".pdf") #=> true
sub(pattern, replacement)
sub(pattern) { |match| ... }		 最初に pattern にマッチした部分を replacement またはブロックの評価結果で置換した新しい文字列を返す。(非破壊的) 
puts "Ruby Ruby".sub("Ruby", "Python") #=> "Python Ruby"
puts "abc 123".sub(/\d+/) { |m| m.to_i * 2 } #=> "abc 246"
sub!(pattern, replacement)
sub!(pattern) { |match| ... }		 最初に pattern にマッチした部分を置換する。(破壊的) 置換が行われた場合は self を、行われなかった場合は nil を返す。 
str = "Ruby Ruby"
str.sub!("Ruby", "Python")
puts str #=> "Python Ruby"
result = str.sub!("Java", "Go")
puts result #=> nil (置換なし)
gsub(pattern, replacement)
gsub(pattern) { |match| ... }		 pattern にマッチした全ての部分を置換した新しい文字列を返す。(非破壊的) 
puts "Ruby Ruby".gsub("Ruby", "Python") #=> "Python Python"
puts "1, 2, 3".gsub(/\d+/) { |m| (m.to_i + 1).to_s } #=> "2, 3, 4"
gsub!(pattern, replacement)
gsub!(pattern) { |match| ... }		 pattern にマッチした全ての部分を置換する。(破壊的) 置換が行われた場合は self を、行われなかった場合は nil を返す。 
str = "Ruby Ruby"
str.gsub!("Ruby", "Python")
puts str #=> "Python Python"
result = str.gsub!("Java", "Go")
puts result #=> nil
scan(pattern)
scan(pattern) { |match| ... }		 pattern にマッチした部分文字列の配列を返す。ブロックが与えられた場合は、マッチごとにブロックを実行し self を返す。 
puts "Ruby, Java, Python".scan(/\w+/) #=> ["Ruby", "Java", "Python"]
"key1=val1 key2=val2".scan(/(\w+)=(\w+)/) do |k, v|
  puts "#{k} -> #{v}"
end
#=> key1 -> val1
#   key2 -> val2
match(pattern, pos = 0) pattern (文字列または正規表現) にマッチするかどうかを調べる。マッチした場合、MatchData オブジェクトを返す。マッチしない場合は nil を返す。pos で検索開始位置を指定。 
md = "Hello Ruby".match(/R.../)
puts md[0] if md #=> Ruby

md2 = "Version 3.2.1".match(/(\d+)\.(\d+)\.(\d+)/)
puts "Major: #{md2[1]}, Minor: #{md2[2]}, Patch: #{md2[3]}" if md2
#=> Major: 3, Minor: 2, Patch: 1
match?(pattern, pos = 0) match と同様だが、マッチした場合は true、しない場合は false を返す。MatchData オブジェクトは生成しないため、単純な存在確認にはこちらが効率的。 
puts "Hello Ruby".match?(/R.../) #=> true
puts "Version 3.2.1".match?(/\d+\.\d+\.\d+/) #=> true
puts "Hello World".match?(/Ruby/) #=> false

文字列の分割・結合 ✂️

文字列を区切り文字で分割して配列にしたり、配列要素を結合して文字列にしたりする方法です。

メソッド 説明 コード例
split(pattern = $;, limit = 0) 文字列を pattern (文字列または正規表現) で分割し、部分文字列の配列を返す。pattern 省略時は空白文字で分割。limit で分割数を制限できる。 
puts "Ruby Java Python".split      #=> ["Ruby", "Java", "Python"]
puts "one,two,three".split(",")   #=> ["one", "two", "three"]
puts "a-b-c-d".split("-", 3) #=> ["a", "b", "c-d"] (limit=3で3要素まで)
partition(pattern) 文字列を pattern (文字列または正規表現) で最初にマッチした箇所で3つに分割し、[マッチ前, マッチ部分, マッチ後] の配列を返す。マッチしない場合は [元の文字列, “”, “”] を返す。 
puts "user@example.com".partition("@").inspect #=> ["user", "@", "example.com"]
puts "filename".partition(".").inspect          #=> ["filename", "", ""]
rpartition(pattern) partition と似ているが、最後にマッチした箇所で分割する。 
puts "path/to/file.txt".rpartition("/").inspect #=> ["path/to", "/", "file.txt"]
puts "image.jpg.bak".rpartition(".").inspect    #=> ["image.jpg", ".", "bak"]
lines(separator = $/, chomp: false) 文字列を行ごとに分割し、各行を要素とする配列を返す。separator で区切り文字を指定可能。chomp: true で各行末尾の改行文字を削除。 
multi_line = "line1\nline2\nline3"
puts multi_line.lines.inspect          #=> ["line1\n", "line2\n", "line3"]
puts multi_line.lines(chomp: true).inspect #=> ["line1", "line2", "line3"]
chars 文字列を一文字ずつに分割し、各文字を要素とする配列を返す。 
puts "Ruby".chars.inspect #=> ["R", "u", "b", "y"]
puts "漢字".chars.inspect #=> ["漢", "字"]
codepoints 各文字のコードポイント (整数) の配列を返す。 
puts "ABC".codepoints.inspect #=> [65, 66, 67]
bytes 各バイトの値を表す整数 (0-255) の配列を返す。 
puts "R".bytes.inspect  #=> [82] (ASCII)
puts "€".bytes.inspect #=> [226, 130, 172] (UTF-8)
Array#join(separator = $,) (配列のメソッドだが関連深いため記載) 配列の要素を文字列に変換し、separator で連結した文字列を返す。 
arr = ["Ruby", "Java", "Python"]
puts arr.join(", ") #=> "Ruby, Java, Python"
puts arr.join       #=> "RubyJavaPython" (区切り文字なし)

文字列の抽出・部分文字列 🧩

文字列の一部を抜き出す方法です。

メソッド / 構文 説明 コード例
[] (index) 指定した index (整数) の位置にある1文字を返す。負のインデックスは末尾から数える。範囲外なら nil。 
str = "Ruby"
puts str[0]  #=> "R"
puts str[1]  #=> "u"
puts str[-1] #=> "y"
puts str[4]  #=> nil
[] (start, length) start の位置から length 文字分の部分文字列を返す。length が負なら nil。範囲外なら nil または部分的な文字列。 
str = "Hello Ruby"
puts str[0, 5]  #=> "Hello"
puts str[6, 4]  #=> "Ruby"
puts str[-4, 4] #=> "Ruby"
puts str[6, 10] #=> "Ruby" (範囲を超えても取れるだけ)
puts str[10, 1] #=> ""
puts str[11, 1] #=> nil
[] (range) range (範囲オブジェクト n..m や n...m) で指定された範囲の部分文字列を返す。 
str = "Hello Ruby"
puts str[0..4]   #=> "Hello" (0から4まで)
puts str[6..-1]  #=> "Ruby" (6から末尾まで)
puts str[0...5]  #=> "Hello" (0から5の手前まで)
[] (substring) 文字列内に substring が存在すれば、その substring 自身を返す。存在しなければ nil を返す。 
str = "Hello Ruby"
puts str["Ruby"]  #=> "Ruby"
puts str["Java"]  #=> nil
[] (regexp, capture = 0) 正規表現 regexp に最初にマッチした部分文字列を返す。capture に整数を指定すると、対応するキャプチャグループの内容を返す。マッチしなければ nil。 
str = "Name: Alice, Age: 30"
puts str[/Age: (\d+)/, 0] #=> "Age: 30" (マッチ全体)
puts str[/Age: (\d+)/, 1] #=> "30" (1番目のキャプチャ)
puts str[/Email: .+/, 0] #=> nil
slice(index)
slice(start, length)
slice(range)
slice(substring)
slice(regexp, capture = 0)		 [] と同じ機能を持つメソッド。(非破壊的) 
str = "Hello Ruby"
puts str.slice(6, 4) #=> "Ruby"
puts str.slice(/R.../) #=> "Ruby"
slice!(index)
slice!(start, length)
slice!(range)
slice!(substring)
slice!(regexp, capture = 0)		 指定した部分を文字列から削除し、削除した部分文字列を返す。(破壊的) マッチ/指定部分がない場合は nil を返す。 
str = "Hello Ruby World"
deleted = str.slice!(6, 5) # "Ruby " を削除
puts deleted #=> "Ruby "
puts str     #=> "Hello World"

deleted2 = str.slice!("Java")
puts deleted2 #=> nil

文字列の変換 ↔️

大文字・小文字変換など、文字列の内容を変換する方法です。

メソッド 説明 コード例
upcase 全てのアルファベットを大文字に変換した新しい文字列を返す。(非破壊的) 
puts "ruby".upcase #=> "RUBY"
puts "Ruby on Rails".upcase #=> "RUBY ON RAILS"
upcase! 全てのアルファベットを大文字に変換する。(破壊的) 変更があれば self を、なければ nil を返す。 
str = "ruby"
str.upcase!
puts str #=> "RUBY"
result = str.upcase!
puts result #=> nil (変更なし)
downcase 全てのアルファベットを小文字に変換した新しい文字列を返す。(非破壊的) 
puts "RUBY".downcase #=> "ruby"
puts "Ruby on Rails".downcase #=> "ruby on rails"
downcase! 全てのアルファベットを小文字に変換する。(破壊的) 変更があれば self を、なければ nil を返す。 
str = "RUBY"
str.downcase!
puts str #=> "ruby"
result = str.downcase!
puts result #=> nil
capitalize 先頭の文字を大文字に、残りを小文字に変換した新しい文字列を返す。(非破壊的) 
puts "ruby".capitalize     #=> "Ruby"
puts "rUBY oN rAILS".capitalize #=> "Ruby on rails"
capitalize! 先頭の文字を大文字に、残りを小文字に変換する。(破壊的) 変更があれば self を、なければ nil を返す。 
str = "ruby on rails"
str.capitalize!
puts str #=> "Ruby on rails"
result = str.capitalize!
puts result #=> nil
swapcase 大文字と小文字を入れ替えた新しい文字列を返す。(非破壊的) 
puts "Ruby".swapcase #=> "rUBY"
puts "Hello World".swapcase #=> "hELLO wORLD"
swapcase! 大文字と小文字を入れ替える。(破壊的) 変更があれば self を、なければ nil を返す。 
str = "Ruby On Rails"
str.swapcase!
puts str #=> "rUBY oN rAILS"
result = "abc".swapcase! #=> "ABC"
puts result #=> "ABC"
reverse 文字列の文字の順序を逆にした新しい文字列を返す。(非破壊的) 
puts "Ruby".reverse #=> "ybuR"
puts "あいうえお".reverse #=> "おえういあ"
reverse! 文字列の文字の順序を逆にする。(破壊的) 常に self を返す。 
str = "Ruby"
str.reverse!
puts str #=> "ybuR"
tr(from_str, to_str) from_str に含まれる文字を、対応する to_str の文字に置換した新しい文字列を返す。(非破壊的) 範囲指定 (a-z) や否定 (^) も可能。 
puts "abcdef".tr("abc", "123") #=> "123def"
puts "Hello World".tr("a-z", "A-Z") #=> "HELLO WORLD" (upcase相当)
puts "123-456".tr("^-", "*") #=> "***-***" ('-'以外を'*'に)
tr!(from_str, to_str) tr の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "apple"
str.tr!("aeiou", "*")
puts str #=> "*ppl*"
result = str.tr!("p", "P")
puts result #=> "*PPl*"
puts str #=> "*PPl*"
result2 = str.tr!("xyz", "123")
puts result2 #=> nil
tr_s(from_str, to_str) tr と同様に置換後、連続する置換後の文字を一つにまとめる。(非破壊的) 
puts "goooooood".tr_s("o", "O") #=> "gOd"
puts "  a  b  c ".tr_s(" ", "-") #=> "-a-b-c-"
tr_s!(from_str, to_str) tr_s の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "Programming    Ruby"
str.tr_s!(" ", "_")
puts str #=> "Programming_Ruby"
squeeze(other_str = nil) 連続する同じ文字を1文字に圧縮した新しい文字列を返す。(非破壊的) 引数 other_str が指定された場合、その文字セットに含まれる文字のみを対象とする。範囲指定、否定も可能。 
puts "goooooood!!".squeeze      #=> "god!"
puts "Programminggg".squeeze("g") #=> "Programing"
puts "aabbccdd".squeeze("a-c")  #=> "abcd"
squeeze!(other_str = nil) squeeze の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "sssttrrrring"
str.squeeze!
puts str #=> "string"
result = str.squeeze!("t")
puts result #=> nil

文字列のフォーマット 🎨

数値を埋め込んだり、特定のフォーマットに合わせて文字列を整形したりする方法です。

メソッド / 演算子 説明 コード例
% (args) sprintf 形式のフォーマット文字列に従って、args (単一の値または配列) を埋め込んだ新しい文字列を返す。 
puts "ID: %04d, Name: %s" % [12, "Alice"] #=> "ID: 0012, Name: Alice"
puts "Price: %.2f" % 123.456              #=> "Price: 123.46"
sprintf(format, *args)
format(format, *args)		 C言語の printf ライクな書式指定文字列 format に従って、引数 args をフォーマットした文字列を返す。(Kernelメソッド) 
result = sprintf("Hex: %X, Oct: %o", 255, 255)
puts result #=> "Hex: FF, Oct: 377"

result2 = format("Value: %{val}, Type: %{type}", val: 100, type: "Integer")
puts result2 #=> "Value: 100, Type: Integer"

文字列のパディング・トリミング 🧹

文字列の左右に文字を追加して長さを揃えたり、不要な空白文字などを除去したりする方法です。

メソッド 説明 コード例
center(width, padstr = ' ') 文字列が指定した width になるように、左右に padstr を追加して中央揃えにした新しい文字列を返す。元の文字列が width より長い場合はそのまま返す。 
puts "Ruby".center(10)      #=> "   Ruby   "
puts "Ruby".center(10, '*') #=> "***Ruby***"
puts "Ruby".center(2)       #=> "Ruby"
ljust(width, padstr = ' ') 文字列が指定した width になるように、右側に padstr を追加して左揃えにした新しい文字列を返す。 
puts "Ruby".ljust(10)      #=> "Ruby      "
puts "Ruby".ljust(10, '-') #=> "Ruby------"
rjust(width, padstr = ' ') 文字列が指定した width になるように、左側に padstr を追加して右揃えにした新しい文字列を返す。 
puts "Ruby".rjust(10)      #=> "      Ruby"
puts "Ruby".rjust(10, '0') #=> "000000Ruby"
strip 文字列の先頭と末尾にある空白文字 (スペース、タブ、改行など) を取り除いた新しい文字列を返す。 
puts "  Ruby  \n".strip #=> "Ruby"
puts "\t Hello \t".strip #=> "Hello"
strip! strip の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "  Ruby  "
str.strip!
puts str #=> "Ruby"
result = str.strip!
puts result #=> nil
lstrip 文字列の先頭にある空白文字を取り除いた新しい文字列を返す。 
puts "  Ruby  ".lstrip #=> "Ruby  "
lstrip! lstrip の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "  Ruby  "
str.lstrip!
puts str #=> "Ruby  "
rstrip 文字列の末尾にある空白文字を取り除いた新しい文字列を返す。 
puts "  Ruby  \n\t".rstrip #=> "  Ruby"
rstrip! rstrip の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "  Ruby  \n"
str.rstrip!
puts str #=> "  Ruby"
chomp(separator = $/) 文字列の末尾にある区切り文字 (デフォルトは改行) を取り除いた新しい文字列を返す。区切り文字がない場合は何もしない。 
puts "Ruby\n".chomp    #=> "Ruby"
puts "Ruby\r\n".chomp  #=> "Ruby" (CRLFも削除)
puts "Ruby".chomp      #=> "Ruby" (何もしない)
puts "Ruby".chomp("by") #=> "Ru"
chomp!(separator = $/) chomp の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "Ruby\n"
str.chomp!
puts str #=> "Ruby"
result = str.chomp!
puts result #=> nil
chop 文字列の最後の1文字を削除した新しい文字列を返す。末尾が “\r\n” の場合は両方を削除する。空文字列に対しては空文字列を返す。 
puts "Ruby".chop    #=> "Rub"
puts "Ruby\n".chop  #=> "Ruby"
puts "Ruby\r\n".chop #=> "Ruby"
puts "R".chop       #=> ""
puts "".chop        #=> ""
chop! chop の破壊的バージョン。空文字列以外は常に self を返す。空文字列の場合は nil を返す。 
str = "Ruby"
str.chop!
puts str #=> "Rub"
empty_str = ""
result = empty_str.chop!
puts result #=> nil
delete(other_str, ...) 引数で指定された文字セットに含まれる文字を全て削除した新しい文字列を返す。(非破壊的) 範囲指定、否定も可能。 
puts "Ruby on Rails".delete("aeiou") #=> "Rby n Rls"
puts "abc-123-def".delete("a-z", "^-") #=> "--" (英字とハイフン以外を削除)
delete!(other_str, ...) delete の破壊的バージョン。変更があれば self を、なければ nil を返す。 
str = "(123) 456-7890"
str.delete!("()- ")
puts str #=> "1234567890"
clear 文字列を空にする。(破壊的) 
str = "This will be cleared."
str.clear
puts str #=> "" (空文字列)

文字コード・エンコーディング 🔠

文字列のエンコーディングを取得・変換する方法です。

メソッド 説明 コード例
encoding 文字列のエンコーディング (Encoding オブジェクト) を返す。 
puts "Ruby".encoding    #=> UTF-8 (デフォルトの場合)
puts "ルビー".encoding  #=> UTF-8

# encoding: Shift_JIS
# str = "シフトJIS"
# puts str.encoding #=> Shift_JIS
encode(encoding, **options)
encode(dst_encoding, src_encoding, **options)		 指定したエンコーディングに変換した新しい文字列を返す。(非破壊的) オプションで変換エラー時の処理などを指定できる。 
utf8_str = "こんにちは"
sjis_str = utf8_str.encode("Shift_JIS")
puts sjis_str.encoding #=> Shift_JIS

# 不正なバイトシーケンスを置換
euc_str = "テスト\xA1\xA2".force_encoding("EUC-JP") # 不正なバイト列を含む
puts euc_str.encode("UTF-8", invalid: :replace, undef: :replace, replace: '?')
#=> テスト??
encode!(encoding, **options)
encode!(dst_encoding, src_encoding, **options)		 encode の破壊的バージョン。文字列自身のエンコーディングを変換する。 
str = "こんにちは"
str.encode!("EUC-JP")
puts str.encoding #=> EUC-JP
force_encoding(encoding) 文字列のバイト列はそのままで、エンコーディング情報のみを変更する。(破壊的) バイト列とエンコーディングが一致しない場合、後続の操作でエラーになる可能性がある。 
# SJISのバイト列をUTF-8として読み込んでしまった場合など
bytes = "\x82\xB1\x82\xF1\x82\xC9\x82\xBF\x82\xCD".force_encoding("ASCII-8BIT") # バイト列
str = bytes.force_encoding("Shift_JIS")
puts str.encoding #=> Shift_JIS
puts str          #=> こんにちは (正しく解釈される)
valid_encoding? 文字列のバイト列が、自身のエンコーディングとして妥当であれば true を返す。 
puts "Ruby".valid_encoding?      #=> true
puts "ルビー".valid_encoding?  #=> true
puts "\x82\xA0".force_encoding("UTF-8").valid_encoding? #=> false (不正なUTF-8バイト)
Integer#chr(encoding = default) (整数のメソッドだが関連深いため記載) 整数 (コードポイント) に対応する文字を含む文字列を返す。エンコーディングを指定可能。 
puts 65.chr       #=> "A" (デフォルトエンコーディング: UTF-8 or ASCII)
puts 12354.chr("UTF-8") #=> "あ"

その他便利なメソッド ✨

上記カテゴリに含まれない、便利な文字列操作メソッドです。

メソッド 説明 コード例
count(other_str, ...) 引数で指定された文字セットに含まれる文字が、文字列中にいくつ含まれるかを数える。範囲指定、否定も可能。文字セットの共通部分や重複は考慮されない。 
puts "Ruby on Rails".count("R")      #=> 2
puts "Ruby on Rails".count("aeiou")   #=> 4 (a, o, ai)
puts "123-456-789".count("0-9", "^-") #=> 9 (数字かつハイフンでないもの = 数字)
sum(n = 16) 文字列の簡単なチェックサムを計算する。(nビットのチェックサム) 主に簡易的な比較用。 
puts "Ruby".sum     #=> 401 (例)
puts "ruby".sum     #=> 433 (例)
puts "Ruby".sum(8) #=> 145 (例)
ord 文字列の先頭文字のコードポイント (整数) を返す。 
puts "A".ord   #=> 65
puts "あ".ord #=> 12354
intern / to_sym 文字列に対応するシンボル (Symbol オブジェクト) を返す。シンボルが存在しなければ新たに作成する。 
sym1 = "name".intern
sym2 = :name
puts sym1 == sym2     #=> true
puts "status".to_sym #=> :status
succ / next 文字列の「次の」文字列を返す。(非破壊的) アルファベットや数字が繰り上がる。 
puts "a".succ   #=> "b"
puts "z".succ   #=> "aa"
puts "9".succ   #=> "10"
puts "a9".succ  #=> "b0"
puts "az".next  #=> "ba"
succ! / next! succ / next の破壊的バージョン。 
str = "v1"
str.succ!
puts str #=> "v2"
str.next!
puts str #=> "v3"
upto(max, exclusive = false) { |s| ... } self から max まで、succ を呼び出しながらブロックを実行する。exclusive が true なら max は含まない。 
"a".upto("d") { |s| print s } #=> abcd
puts
"07".upto("12") { |s| print s, " " } #=> 07 08 09 10 11 12
dump 文字列リテラルのように、特殊文字や制御文字をエスケープした表現の文字列を返す。デバッグなどに有用。 
puts "Hello\nWorld".dump #=> "\"Hello\\nWorld\""
puts "タブ\t付き".dump   #=> "\"タブ\\t付き\""
undump dump された形式の文字列を元の文字列に戻す。 
dumped_str = "\"Hello\\nWorld\""
original_str = dumped_str.undump
puts original_str
#=> Hello
#   World
unpack(format) バイナリデータを指定したフォーマットに従って配列に変換する。Array#pack の逆操作。ネットワーク通信やバイナリファイル操作で使用。 
# 16進文字列をバイト配列に
hex_str = "48656c6c6f" # "Hello"
bytes = hex_str.unpack("H*")[0].unpack("C*")
puts bytes.inspect #=> [72, 101, 108, 108, 111]

# Base64デコード
require 'base64'
encoded = Base64.encode64("Ruby") #=> "UnVieQ==\n"
decoded = encoded.unpack("m")[0]
puts decoded #=> "Ruby"
hex 文字列を16進数として解釈し、整数に変換する。先頭の 0x や _ は無視される。 
puts "ff".hex   #=> 255
puts "0x1A".hex #=> 26
puts "-FF".hex  #=> -255
puts "12_34".hex #=> 4660
oct 文字列を8進数として解釈し、整数に変換する。先頭の 0 や _ は無視される。 
puts "10".oct   #=> 8
puts "077".oct #=> 63
puts "-10".oct #=> -8
to_i(base = 10) 文字列を整数に変換する。基数 (2〜36) を指定できる。変換できない文字以降は無視される。 
puts "123".to_i      #=> 123
puts "101".to_i(2)   #=> 5 (2進数)
puts "ff".to_i(16)   #=> 255 (16進数)
puts "123ruby".to_i #=> 123
puts "ruby123".to_i #=> 0
to_f 文字列を浮動小数点数 (Float) に変換する。変換できない文字以降は無視される。 
puts "123.45".to_f #=> 123.45
puts "1.2e3".to_f  #=> 1200.0
puts "123ruby".to_f #=> 123.0
puts "ruby123".to_f #=> 0.0
to_r 文字列を有理数 (Rational) に変換する。”1/3″, “0.5” などの形式を解釈。 
puts "1/3".to_r   #=> (1/3)
puts "0.5".to_r   #=> (1/2)
puts "1_2/3_4".to_r #=> (6/17)
to_c 文字列を複素数 (Complex) に変換する。”1+2i”, “3-4j”, “5i” などの形式を解釈。 
puts "1+2i".to_c #=> (1+2i)
puts "5".to_c    #=> (5+0i)
puts "-3i".to_c  #=> (0-3i)

コメント

タイトルとURLをコピーしました