Ruby 2.0.0 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Stringクラス
クラスの継承リスト: String
< Comparable
< Object
< Kernel
< BasicObject
dynamic include:
JSON::Generator::GeneratorMethods::String (by json)
dynamic extend:
JSON::Generator::GeneratorMethods::String::Extend (by json)
文字列のクラスです。 NUL 文字を含む任意のバイト列を扱うことができます。 文字列の長さにはメモリ容量以外の制限はありません。
文字列は通常、文字列リテラルを使って生成します。 以下に文字列リテラルの例をいくつか示します。
'str\\ing' # シングルクオート文字列 (エスケープシーケンスがほぼ無効) "string\n" # ダブルクオート文字列 (エスケープシーケンスがすべて有効) %q(str\\ing) # 「%q」文字列 (エスケープシーケンスがほぼ無効、デリミタが変えられる) %Q(string\n) # 「%Q」文字列 (エスケープシーケンスがすべて有効、デリミタが変えられる) # ヒアドキュメント <<End この行はヒアドキュメント End # ダブルクオートヒアドキュメント (クオートなしの場合と同じ) <<"End" この行はヒアドキュメント End # シングルクオートヒアドキュメント (一切のエスケープシーケンスが無効) <<'End' この行はヒアドキュメント End # 終端記号がインデントされたヒアドキュメント # シングルクオート、ダブルクオートとの併用も可能 <<-End この行はヒアドキュメント (終端記号をインデントできる) End
Ruby の String クラスは mutable です。 つまり、オブジェクト自体を破壊的に変更できます。
「破壊的な変更」とは、あるオブジェクトの内容自体を変化させることです。 例えば文字列のすべての文字を破壊的に大文字へ変更する String#upcase! メソッドの使用例を以下に示します。
a = "string" b = a a.upcase! p a # => "STRING" p b # => "STRING"
この例では、a に対してメソッドを呼んだにも関わらず b も変更されています。 これは、変数 a と b が一つの文字列オブジェクトを指していて、 upcase! メソッドでそのオブジェクト自体が変更されたからです。
upcase! の非破壊版である String#upcase を使った例を以下に示します。 こちらでは a の変更が b に波及しません。
a = "string" b = a a = a.upcase p a # => "STRING" p b # => "string"
一般には、破壊的「ではない」メソッドを 中心に使っていくほうがバグが出にくくなります。
String クラスのメソッドには破壊的なメソッドも非破壊的なメソッドもあります。 破壊的なメソッドの例としては concat, sub!, upcase! などが挙げられます。 非破壊的なメソッドの例としては index, sub, upcase などが挙げられます。
同じ動作で破壊的なメソッドと非破壊的なメソッドの両方が定義されているときは、 破壊的なバージョンには名前の最後に「!」が付いています。 例えば upcase メソッドは非破壊的で、upcase! メソッドは破壊的です。
ただし、この命名ルールを 「破壊的なメソッドにはすべて『!』が付いている」と解釈しないでください。 例えば concat には「!」が付いていませんが、破壊的です。あくまでも、 「『!』が付いているメソッドと付いていないメソッドの両方があるときは、 『!』が付いているほうが破壊的」というだけです。 「『!』が付いているならば破壊的」は常に成立しますが、逆は必ずしも成立しません。
String オブジェクトは自身のエンコーディング情報を持ちます。 インスタンスメソッドはエンコーディングに従い、1バイトではなく1文字を単位として動作します。 エンコーディングの変換にはメソッド String#encode を使います。
動作例: (注)一行目にmagic commentが必要です。
# vim:set fileencoding=UTF-8:
p "いろは".size #=> 3
p "漢字"[0] #=> "漢"
p "山本山".reverse #=> "山本山" (回文なので分からないですね)
p "ループ".reverse #=> "プール"
s = "ruビー"
s[0..1] = "ル"
p s #=> "ルビー"
e = "言語".encode("EUC-JP")
u = "言語".encode("UTF-8")
p e.encoding #=> Encoding::EUC_JP
p u.encoding #=> Encoding::UTF_8
より詳しく知りたい場合は、多言語化 を参照してください。
文字列同士の比較・結合などでは両者のエンコーディングを意識する必要があります。 例えば String#== や String#eql? は両者のエンコーディングが等しく バイト列表現が等しい場合にのみ true を返します。 このときエンコーディングが UTF-8 であっても正規化せずに比較します。 文字列の結合も同様です。異なるエンコーディング同士の文字列を結合する時は 明示的にエンコーディングを変換する必要があります。
動作例: (注)一行目にmagic commentが必要です。
# vim:set fileencoding=UTF-8:
s = "いろは"
a = s.encode("EUC-JP")
b = s.encode("UTF-8")
p a == b #=> false
s = "合".encode("EUC-JP")
p s + "\u{4f53}".encode("EUC-JP") #=> "合体"
p s + "\u{4f53}" #=> ArgumentError
String#eql? はハッシュのキーの比較に使われますので、 ハッシュのキーに非 ASCII 文字列を使う場合には注意が必要です。
動作例: (注)一行目にmagic commentが必要です。
# encoding: UTF-8
h = {}
s = "いろは"
s.force_encoding("EUC-JP")
h[s] = 1
s.force_encoding("ASCII-8BIT")
p h[s] #=> nil
ASCII 互換エンコーディングをもつ 7bit クリーンな文字列は エンコーディングに関わらず ASCII として扱うことができます。 例えば String#== は両者の文字エンコーディングが異なっていても true を返します。 ASCII 互換エンコーディングをもつ文字列にエンコーディングの変換なしで結合することができます。
例:
s = "abc"
a = s.encode("EUC-JP")
b = s.encode("UTF-8")
p a == b #=> true
p a + b #=> "abcabc"
ここで言う「ASCII互換エンコーディング」とは、コードポイントが同一という意味ではなく バイト列が同じことを意味します。従って UTF-16 はASCII互換ではありません。 また厳密性を追求せず、おおむね互換なら互換と呼びます。よって Shift_JIS は ASCII 互換です。
文字列ではない単なるバイト列も String オブジェクトで表されます。 その時のエンコーディングは ASCII-8BIT です。
new(string = "") -> String[permalink][rdoc]string と同じ内容の新しい文字列を作成して返します。 引数を省略した場合は空文字列を生成して返します。
try_convert(obj) -> String | nil[permalink][rdoc]obj を String に変換しようと試みます。変換には Object#to_str メソッ ドが使われます。変換後の文字列を返すか、何らかの理由により変換できなかっ た場合は nil が返されます。
String.try_convert("str") # => "str"
String.try_convert(/re/) # => nil
self % args -> String[permalink][rdoc]printf と同じ規則に従って args をフォーマットします。
args が配列であれば Kernel.#sprintf(self, *args) と同じです。 それ以外の場合は Kernel.#sprintf(self, args) と同じです。
例:
p "i = %d" % 10 # => "i = 10" p "i = %x" % 10 # => "i = a" p "i = %o" % 10 # => "i = 12" p "i = %#d" % 10 # => "i = 10" p "i = %#x" % 10 # => "i = 0xa" p "i = %#o" % 10 # => "i = 012" p "%d" % 10 # => "10" p "%d,%o" % [10, 10] # => "10,12"
Ruby の sprintf フォーマットは基本的に C 言語の sprintf(3) のものと同じです。ただし、short や long などの C 特有の型に対する修飾子が ないこと、2進数の指示子(%b, %B)が存在すること、sprintf のすべての方言をサ ポートしていないこと(%': 3桁区切り)などの違いがあります。
Ruby には整数の大きさに上限がないので、%b, %B, %o, %x, %X に負の数を与えると (左側に無限に1が続くとみなせるので) ..f のような表示をします。絶対値に符号を付けた形式 で出力するためには %+x、% x のように指定します。
以下は sprintf フォーマットの書式です。[] で囲まれた部分は省略可 能であることを示しています。
%[nth$][フラグ][幅][.精度]指示子 %[<name>][フラグ][幅][.精度]指示子
`%' 自身を出力するには `%%' とします。
以下それぞれの要素に関して説明します。
フラグには #, +, ' '(スペース), -, 0 の5種類があります。
2進、8進、16進の指示子(b, B, o, x, X) ではそれぞれプレフィック スとして "0b", "0B", "0", "0x", "0X" を付加します。 C 言語と同様引数が 0 の場合にはプレフィックスが付加されません。
p sprintf("%#b", 10) #=> "0b1010"
p sprintf("%#B", 10) #=> "0B1010"
p sprintf("%#b", 0) #=> "0"
p sprintf("%#o", 10) #=> "012"
p sprintf("%#x", 10) #=> "0xa"
p sprintf("%#X", 10) #=> "0XA"
浮動小数点数 (f, e, E, g, G) に対しては必ず出力に"."をつけます。
p sprintf("%.0f", 10) #=> "10"
p sprintf("%#.0f", 10) #=> "10."
p sprintf("%.0e", 10) #=> "1e+01"
p sprintf("%#.0e", 10) #=> "1.e+01"
また g, G では上記に加えて末尾の余分な0が残ります。
p sprintf("%.05g", 10) #=> "10"
p sprintf("%#.05g", 10) #=> "10.000"
出力文字列を符号付きにします。特に正の数では`+'が付加されます。 数値の指示子 (d, i, b, B, o, x, X, u, f, e, E, g, G) に対してだけ意味を持ちます。 また、特に b, B, o, x, X, u に対しては、負数に対して "-" を付加することを示します。
p sprintf("%d", 1) #=> "1"
p sprintf("%+d", 1) #=> "+1"
p sprintf("%x", -1) #=> "..f" # ".." は無限に f が続くことを表している
p sprintf("%+x", -1) #=> "-1"
`+' と同じですが正の符号 `+' の代わりに空白を用います。数値の指示子 (d, i, b, B, o, x, X, u, f, e, E, g, G) に対してだけ意味を持ちます。
p sprintf("%d", 1) #=> "1"
p sprintf("%+d", 1) #=> "+1"
p sprintf("% d", 1) #=> " 1"
p sprintf("%x", -1) #=> "..f"
p sprintf("% x", 1) #=> " 1"
p sprintf("% x", -1) #=> "-1"
出力を左詰めにします幅の指定がなければ 意味がありません。
出力が右詰めの場合に余った部分に空白の代わりに "0" を詰めます。
数値の指示子の一部(d, i, b, B, o, x, X, u, f, g, G)に対し てだけ意味を持ちます(e, E には意味がない)
p sprintf("%010d", 10) #=> "0000000010"
`#' と一緒に指定した場合の出力は以下のようになります。
p sprintf("%#010x", 10) #=> "0x0000000a"
p sprintf("%#010o", 10) #=> "0000000012"
p sprintf("%#010b", 10) #=> "0b00001010"
これは、以下と同じです。
p sprintf("%#10.8x", 10) #=> "0x0000000a"
p sprintf("%#10.9o", 10) #=> "0000000012"
p sprintf("%#10.8b", 10) #=> "0b00001010"
通常は、以下のようになります。
p sprintf("%#10x", 10) #=> " 0xa"
p sprintf("%#10o", 10) #=> " 012"
p sprintf("%#10b", 10) #=> " 0b1010"
0以外の数字で始まる数字列は幅指定になります。幅は生成文字列の長さを示 します。後述の精度の値によらずこの幅分だ けの文字列が生成されます。
幅の指定はフラグで付与される " ", "+", "-", "0b", "0B", "0", "0x", "0X" の長さも考慮されます。
p sprintf("%+5d", 11) #=> " +11"
p sprintf("%+-5d", 11) #=> "+11 "
p sprintf("%+05d", 11) #=> "+0011"
幅は「最低限必要な幅」の指定になります。結果の文字列が指定した幅を超 える場合は幅の指定は無効になります。
幅として `*' を指定すると幅の値を引数から得ることになります。
p sprintf("%#05x", 10) #=> "0x00a"
p sprintf("%#0*x", 5, 10) #=> "0x00a"
"." の後に続く数字列は精度を表します("." のみの場合 ".0" と同じです)。精度は 整数の指示子 (d, i, b, B, o, x, X, u) に対しては、数値列部分の長さを意味します。
p sprintf("%10.5d", 1) #=> " 00001"
p sprintf("%#10.5x", 1) #=> " 0x00001"
p sprintf("%+10.5x", 1) #=> " +00001"
浮動小数点数の指示子 (f) に対しては小数部の桁数を意味します。
p sprintf("%10.5f", 1) #=> " 1.00000"
p sprintf("%10.5f", 10) #=> " 10.00000"
浮動小数点数の指示子 (e, E, g, G) に対しては有効桁数を意味します。
p sprintf("%10.5e", 1) #=> "1.00000e+00"
p sprintf("%10.5e", 10) #=> "1.00000e+01"
p sprintf("%10.5g", 10) #=> " 10"
p sprintf("%#10.5G", 10) #=> " 10.000"
文字列の指示子(s, p) に対しては引数の文字列のうち指定した数を超える分を切り捨てます。 幅と精度を同じ値にすれば、どのような引数に対してもその 長さだけの出力を行うことになります。
p sprintf("%10.2s", "foo") #=> " fo"
p sprintf("%5.5s", "foo") #=> " foo"
p sprintf("%5.5s", "foobar") #=> "fooba"
精度として `*' を指定すると精度の値を引数から得ることになります。
p sprintf("%.5s", "foobar") #=> "fooba"
p sprintf("%.*s", 5, "foobar") #=> "fooba"
指示子は引数の型の解釈を示します。指示子を省略することはできません。 指示子には大きく分けて
があります
引数の数値(0〜255)を文字コードとみなして対応する文字を出力します。 引数が数値以外のオブジェクトの場合 to_int メソッドによる変換を試みます。 引数として範囲内の一文字の文字列も受けつけます。文字そのものを出力します。
p sprintf("%c", 97) #=> "a"
p sprintf("%c", 'a') #=> "a"
フラグ `-' と幅 の指定だけが意味を持ちます。
文字列を出力します。
引数が String オブジェクトでなければ to_s メソッドにより文字列化 したものを引数として扱います。
Object#inspect の結果を出力します。
p sprintf("%s", /e+/) #=> "(?-mix:e+)"
p sprintf("%p", /e+/) #=> "/e+/"
引数の数値を10進表現の整数として出力します。
引数が整数でなければ関数 Kernel.#Integer と同じ規則で整数に 変換されます。
p sprintf("%d", -1) #=> "-1"
p sprintf("%d", 3.1) #=> "3"
p sprintf("%d", '0b1010') #=> "10"
引数の数値を符号なし整数とみなして10進表現の整数として出力します。
p sprintf("%u", '0b1010') #=> "10"
p sprintf("%u", -1) #=> "-1"
整数をそれぞれ2進、2進(大文字)、8進、16進、16進(大文字)表現の文字列で出力します。
`#' フラグを指定すれば "0b", "0B", "0", "0x", "0X" を先頭に付加します。
`+', ` ' フラグがない場合、負の数には ".." が先頭(`#' フラグがあれば "0x" などの後)に付加されます。これは最上位桁の文字が無限に続くことを 意味し、2の補数表現で負の数を表しています。
p sprintf("%#b", 10) #=> "0b1010"
p sprintf("%#B", 10) #=> "0B1010"
p sprintf("%#o", 10) #=> "012"
p sprintf("%#x", 10) #=> "0xa"
p sprintf("%#X", 10) #=> "0XA"
# 負の数に対して ".." が付加されます
p sprintf("%#b", -1) #=> "0b..1"
p sprintf("%#o", -1) #=> "0..7"
p sprintf("%#x", -1) #=> "0x..f"
p sprintf("%10x", -1) #=> " ..f"
p sprintf("%-10x", -1) #=> "..f "
# ruby 1.9.1 以降では「精度」を指定した場合も、".." は付加されます
p sprintf("%.10x", -1) #=> "..ffffffff"
f は小数点表現(xxx.xxx)で数値を出力します。
e は指数表現(x.xxxe+xx)で数値を出力します。
g は 指数が -4 より小さいか精度以上の場合に e と同じ出力を、それ以 外では f と同じ出力を行います。ただし、小数部の末尾の0は取り除かれ ます。
a, A は指数表現の16進数("-h.hhh±pd") で数値を出力します。ただし、Float::INFINITY、Float::NAN はそれぞれ 'Inf'、'NaN' になります。詳しくは [ruby-dev:40650] を参照してください。
p sprintf("%a", -0.0) # => "-0x0p+0"
p sprintf("%a", 729.0/10) # => "0x1.239999999999ap+6"
p sprintf("%a", Float::INFINITY) # => "Inf"
大文字の指示子(E, G)は出力のアルファベットを大文字にします。
p sprintf("%f", 1.0) #=> "1.000000"
p sprintf("%e", 1.0) #=> "1.000000e+00"
p sprintf("%g", 1.0) #=> "1"
p sprintf("%f", 10.1) #=> "10.100000"
p sprintf("%e", 10.1) #=> "1.010000e+01"
p sprintf("%g", 10.1) #=> "10.1"
p sprintf("%g", 10 ** 6) #=> "1e+06"
p sprintf("%g", 10 ** -5) #=> "1e-05"
精度の省略値は 6 です。
無限大、NaN(Not a Number) に対する出力は以下のとおりです。
p sprintf("%f", 1.0/0) #=> "inf"
p sprintf("%f", -1.0/0) #=> "-inf"
p sprintf("%f", 0.0/0) #=> "nan"
p sprintf("%E", 1.0/0) #=> "INF"
p sprintf("%E", -1.0/0) #=> "-INF"
p sprintf("%E", 0.0/0) #=> "NAN"
f, e, E, g, G に関しては sprintf(3) の結果を利用しています。従って出力結果は 実際にはシステムに依存することになります。
利用頻度が低いので最後に説明します。
nth 番目の引数のフォーマットを行うことを示します。
p sprintf("%d, %x, %o", 1, 2, 3) #=> "1, 2, 3"
p sprintf("%3$d, %2$x, %1$o", 1, 2, 3) #=> "3, 2, 1"
p sprintf("%1$d, %1$x, %1$o", 10) #=> "10, a, 12"
状況によってフォーマットを変えたいが引数の順序を変えたくない場合に使 用します。
case ENV['LC_TIME']
when /^ja_JP/
fmt = "%1$d年%2$d月%3$d日"
else
fmt = "%2$02d/%03$2d/%1$02d"
end
p sprintf(fmt, 1, 4, 22) #=> "04/22/01"
"*" の後に指定することで幅や 精度を引数で指定することもできます。
p sprintf("%5.2f", 1) #=> " 1.00"
p sprintf("%*.*f", 5, 2, 1) #=> " 1.00"
p sprintf("%1$*2$.*3$f", 1, 5, 2) #=> " 1.00"
Symbol のインスタンス name をキーとする Hash を引数にした場合、 対応する値をフォーマットして参照します。
p sprintf('%<foo>f : %<bar>+d', foo: 1, bar: 2) #=> "1.000000 : +2"
Symbol のインスタンス name をキーとする Hash を引数にした場合、 対応する値をフォーマットせずに参照します。 幅や精度を指定するために使用することができます。
p sprintf('%{foo}f : %{bar}+d', foo: 1, bar: 2) #=> "1f : 2+d"
self * times -> String[permalink][rdoc]文字列の内容を times 回だけ繰り返した新しい文字列を作成して返します。
例:
p "str" * 3 # => "strstrstr" str = "abc" p str * 4 # => "abcabcabcabc" p str * 0 # => "" p str # => "abc" (変化なし)
self + other -> String[permalink][rdoc]文字列と other を連結した新しい文字列を返します。
例:
p "str" + "ing" # => "string" a = "abc" b = "def" p a + b # => "abcdef" p a # => "abc" (変化なし) p b # => "def"
self << other -> self[permalink][rdoc]concat(other) -> selfself に文字列 other を破壊的に連結します。 other が 0 から 255 のまでの整数である場合は その 1 バイトを末尾に追加します (つまり、整数が示す ASCII コードの文字が追加されます)。
self を返します。
例:
str = "string" str.concat "XXX" p str # => "stringXXX" str << "YYY" p str # => "stringXXXYYY" str << 65 # 文字AのASCIIコード p str # => "stringXXXYYYA"
self <=> other -> -1 | 0 | 1 | nil[permalink][rdoc]self と other を ASCII コード順で比較して、 self が大きい時には 1、等しい時には 0、小さい時には -1 を返します。 このメソッドは Comparable モジュールのメソッドを実装するために使われます。
変数 $= の値が真であるときは アルファベットの大文字小文字を無視して比較します。 ただし $= 変数はいずれ廃止されることが決まっているので $= に頼るべきではありません。 代わりに String#casecmp を使ってください。
other が文字列でない場合、 other.to_str と other.<=> が定義されていれば 0 - (other <=> self) の結果を返します。 そうでなければ nil を返します。
例:
p "aaa" <=> "xxx" # => -1 p "aaa" <=> "aaa" # => 0 p "xxx" <=> "aaa" # => 1 p "string" <=> "stringAA" # => -1 p "string" <=> "string" # => 0 p "stringAA" <=> "string" # => 1
self == other -> bool[permalink][rdoc]self === other -> boolother が文字列の場合、String#eql? と同様に文字列の内容を比較します。
other が文字列でない場合、 other.to_str が定義されていれば other == self の結果を返します。(ただし、 other.to_str は実行されません。) そうでなければ false を返します。
例:
stringlike = Object.new def stringlike.==(other) "string" == other end p "string".eql?(stringlike) #=> false p "string" == stringlike #=> false def stringlike.to_str raise end p "string".eql?(stringlike) #=> false p "string" == stringlike #=> true
[SEE_ALSO] String#eql?
self =~ other -> Integer[permalink][rdoc]正規表現 other とのマッチを行います。 マッチが成功すればマッチした位置のインデックスを、そうでなければ nil を返します。
other が正規表現でも文字列でもない場合は other =~ self を行います。
このメソッドが実行されると、組み込み変数 $~, $1, ... にマッチに関する情報が設定されます。
例:
p "string" =~ /str/ # => 0 p "string" =~ /not/ # => nil p "abcfoo" =~ /foo/ # => 3
self[nth] -> String | nil[permalink][rdoc]slice(nth) -> String | nilnth 番目の文字を返します。 nth が負の場合は文字列の末尾から数えます。 つまり、 self.size + nth 番目の文字を返します。
nth が範囲外を指す場合は nil を返します。
例:
p 'bar'[2] # => "r" p 'bar'[2] == ?r # => true p 'bar'[-1] # => "r" p 'bar'[3] # => nil p 'bar'[-4] # => nil
このメソッドの仕様は 1.8.x 以前から大きく変更されていますので注意が必要 です。
self[nth, len] -> String | nil[permalink][rdoc]slice(nth, len) -> String | nilnth 文字目から長さ len 文字の部分文字列を新しく作って返します。 nth が負の場合は文字列の末尾から数えます。
例:
str0 = "bar" str0[2, 1] #=> "r" str0[2, 0] #=> "" str0[2, 100] #=> "r" (右側を超えても平気) str0[-1, 1] #=> "r" str0[-1, 2] #=> "r" (あくまでも「右に向かって len 文字」) str0[3, 1] #=> "" str0[4, 1] #=> nil str0[-4, 1] #=> nil str1 = str0[0, 2] # (str0 の「一部」を str1 とする) str1 #=> "ba" str1[0] = "XYZ" str1 #=> "XYZa" (str1 の内容が破壊的に変更された) str0 #=> "bar" (str0 は無傷、 str1 は str0 と内容を共有していない)
self[substr] -> String | nil[permalink][rdoc]slice(substr) -> String | nilself が substr を含む場合、一致した文字列を新しく作って返します。 substr を含まなければ nil を返します。
例:
substr = "bar" result = "foobar"[substr] p result # => "bar" p substr.equal?(result) # => false
self[regexp, nth = 0] -> String[permalink][rdoc]slice(regexp, nth = 0) -> String正規表現 regexp の nth 番目の括弧にマッチする最初の部分文字列を返します。 nth を省略したときや 0 の場合は正規表現がマッチした部分文字列全体を返します。 正規表現が self にマッチしなかった場合や nth に対応する括弧がないときは nil を返します。
このメソッドを実行すると、 マッチ結果に関する情報が組み込み変数 $~ に設定されます。
p "foobar"[/bar/] # => "bar" p $~.begin(0) # => 3 p "def getcnt(line)"[ /def\s+(\w+)/, 1 ] # => "getcnt"
self[regexp, name] -> String[permalink][rdoc]slice(regexp, name) -> String正規表現 regexp の name で指定した名前付きキャプチャにマッチする最初の 部分文字列を返します。正規表現が self にマッチしなかった場合は nil を返 します。
例:
s = "FooBar" s[/(?<foo>[A-Z]..)(?<bar>[A-Z]..)/] # => "FooBar" s[/(?<foo>[A-Z]..)(?<bar>[A-Z]..)/, "foo"] # => "Foo" s[/(?<foo>[A-Z]..)(?<bar>[A-Z]..)/, "bar"] # => "Bar" s[/(?<foo>[A-Z]..)(?<bar>[A-Z]..)/, "baz"] # => IndexError
self[range] -> String[permalink][rdoc]slice(range) -> Stringrangeで指定したインデックスの範囲に含まれる部分文字列を返します。
インデックスと文字列の対応については以下の対照図も参照してください。
0 1 2 3 4 5 (インデックス)
-6 -5 -4 -3 -2 -1 (負のインデックス)
| a | b | c | d | e | f |
|<--------->| 'abcdef'[0..2] # => 'abc'
|<----->| 'abcdef'[4..5] # => 'ef'
|<--------->| 'abcdef'[2..4] # => 'cde'
range.last が文字列の長さ以上のときは (文字列の長さ - 1) を指定したものとみなされます。
range.first が 0 より小さいか文字列の長さより大きいときは nil を 返します。ただし range.first および range.last のどちらか または両方が負の数のときは一度だけ文字列の長さを足して 再試行します。
例:
'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
文字列と「隙間」の関係については以下の模式図を参照してください。
0 1 2 3 4 5 6 (隙間番号)
-6 -5 -4 -3 -2 -1 (負の隙間番号)
| a | b | c | d | e | f |
|<--------->| 'abcdef'[0...3] # => 'abc'
|<----->| 'abcdef'[4...6] # => 'ef'
|<--------->| 'abcdef'[2...5] # => 'cde'
range.last が文字列の長さよりも大きいときは文字列の長さを 指定したものとみなされます。
range.first が 0 より小さいか文字列の長さより大きいときは nil を返します。 ただし range.first と range.last のどちらかまたは両方が負の数 であるときは一度だけ文字列の長さを足して再試行します。
例:
'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
self[nth] = val[permalink][rdoc]nth 番目の文字を文字列 val で置き換えます。
例:
buf = "string" buf[1] = "!!" p buf # => "s!!ring"
self[nth, len] = val[permalink][rdoc]nth 番目の文字から len 文字の部分文字列を文字列 val で置き換えます。
len が0 の場合は、単にnthの位置から文字列の追加が行われます。 nth が負の場合は文字列の末尾から数えます。
例:
buf = "string" buf[1, 4] = "!!" p buf # => "s!!g" buf = "string" buf[1, 0] = "!!" p buf # => "s!!tring"
self[substr] = val[permalink][rdoc]文字列中の substr に一致する最初の部分文字列を文字列 val で置き換えます。
例:
buf = "string" buf["trin"] = "!!" p buf # => "s!!g" buf = "string" buf["nosuchstring"] = "!!" # IndexError
self[regexp, nth] = val[permalink][rdoc]正規表現 regexp の nth 番目の括弧にマッチする 最初の部分文字列を文字列 val で置き換えます。
nth が 0 の場合は、マッチした部分文字列全体を val で置き換えます。
例:
buf = "def exec(cmd)" buf[/def\s+(\w+)/, 1] = "preprocess" p buf # => "def preprocess(cmd)"
self[regexp, name] = val[permalink][rdoc]正規表現 regexp の name で指定した名前付きキャプチャにマッチする最初の 部分文字列を文字列 val で置き換えます。
例:
s = "FooBar" s[/(?<foo>[A-Z]..)(?<bar>[A-Z]..)/, "foo"] = "Baz" p s # => "BazBar"
self[regexp] = val[permalink][rdoc]正規表現 regexp にマッチした部分文字列全体を val で置き換えます。
例:
buf = "string" buf[/tr../] = "!!" p buf # => "s!!g"
self[range] = val[permalink][rdoc]rangeで指定したインデックスの範囲に含まれる部分文字列を文字列 val で置き換えます。
ascii_only? -> bool[permalink][rdoc]文字列がASCII文字のみで構成されている場合に true を返します。さもなくば false を返します。
b -> String[permalink][rdoc]self の文字エンコーディングを ASCII-8BIT にした文字列を返します。
bytes -> [Integer][permalink][rdoc]bytes {|byte| ... } -> self文字列の各バイトを数値の配列で返します。(self.each_byte.to_a と同じです)
"str".bytes # => [115, 116, 114]
ブロックが指定された場合は String#each_byte と同じように動作しま す。ただし obsolete のため、ブロックを指定する場合は String#each_byte を使用してください。
[SEE_ALSO] String#each_byte
bytesize -> Integer[permalink][rdoc]文字列のバイト長を整数で返します。
例:
#coding:UTF-8 # 実行結果は文字コードによって異なります。 p "いろは".size #=> 3 p "いろは".bytesize #=> 9
[SEE_ALSO] String#size
byteslice(nth) -> String | nil[permalink][rdoc]nth バイト目の文字を返します。nth が負の場合は文字列の末尾から数えます。 引数が範囲外を指定した場合は nil を返します。
"hello".byteslice(1) # => "e" "hello".byteslice(-1) # => "o" "\u3042".byteslice(0) # => "\xE3" "\u3042".byteslice(1) # => "\x81"
[SEE_ALSO] String#slice
byteslice(nth, len) -> String | nil[permalink][rdoc]nth バイト目から長さ len バイトの部分文字列を新しく作って返します。 nth が負の場合は文字列の末尾から数えます。引数が範囲外を指定した場合は nil を返します。
"hello".byteslice(1, 2) # => "el" "\u3042\u3044\u3046".byteslice(0, 3) # => "\u3042"
[SEE_ALSO] String#slice
byteslice(range) -> String | nil[permalink][rdoc]range で指定したバイトの範囲に含まれる部分文字列を返します。引数が範囲 外を指定した場合は nil を返します。
"hello".byteslice(1..2) # => "el" "\x03\u3042\xff".byteslice(1..3) # => "\u3042"
[SEE_ALSO] String#slice
capitalize -> String[permalink][rdoc]文字列先頭の文字を大文字に、残りを小文字に変更した文字列を返します。 ただし、アルファベット以外の文字は位置に関わらず変更しません。
例:
p "foobar--".capitalize # => "Foobar--" p "fooBAR--".capitalize # => "Foobar--" p "FOOBAR--".capitalize # => "Foobar--"
[SEE_ALSO] String#capitalize!, String#upcase, String#downcase, String#swapcase
capitalize! -> self | nil[permalink][rdoc]文字列先頭の文字を大文字に、残りを小文字に変更します。 ただし、アルファベット以外の文字は位置に関わらず変更しません。
例:
str = "foobar" str.capitalize! p str # => "Foobar" str = "fooBAR" str.capitalize! p str # => "Foobar"
[SEE_ALSO] String#capitalize, String#upcase!, String#downcase!, String#swapcase!
casecmp(other) -> Integer | nil[permalink][rdoc]String#<=> と同様に文字列の順序を比較しますが、 アルファベットの大文字小文字の違いを無視します。
このメソッドの動作は組み込み変数 $= には影響されません。
例:
p 'a' <=> 'A' # => 1
p 'a'.casecmp('A') # => 0
[SEE_ALSO] String#<=>
center(width, padding = ' ') -> String[permalink][rdoc]長さ width の文字列に self を中央寄せした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。 また、第 2 引数 padding を指定したときは 空白文字の代わりに padding を詰めます。
例:
p "foo".center(10) # => " foo " p "foo".center(9) # => " foo " p "foo".center(8) # => " foo " p "foo".center(7) # => " foo " p "foo".center(3) # => "foo" p "foo".center(2) # => "foo" p "foo".center(1) # => "foo" p "foo".center(10, "*") # => "***foo****"
[SEE_ALSO] String#ljust, String#rjust
chars -> [String][permalink][rdoc]chars {|cstr| block } -> self文字列の各文字を文字列の配列で返します。(self.each_char.to_a と同じです)
"hello世界".chars # => ["h", "e", "l", "l", "o", "世", "界"]
ブロックが指定された場合は String#each_char と同じように動作しま す。ただし obsolete のため、ブロックを指定する場合は String#each_char を使用してください。
[SEE_ALSO] String#each_char
chomp(rs = $/) -> String[permalink][rdoc]self の末尾から rs で指定する改行コードを取り除いた文字列を生成して返します。 ただし、rs が "\n" ($/ のデフォルト値) のときは、 実行環境によらず "\r", "\r\n", "\n" のすべてを改行コードとみなして取り除きます。
rs に nil を指定した場合、このメソッドは何もしません。
rs に空文字列 ("") を指定した場合は「パラグラフモード」になり、 末尾の連続する改行コードをすべて取り除きます。
例:
p "foo\n".chomp # => "foo"
p "foo\n".chomp("\n") # => "foo"
p "foo\r\n".chomp("\r\n") # => "foo"
$/ = "\n" # デフォルト値と同じ
p "foo\r".chomp # => "foo"
p "foo\r\n".chomp # => "foo"
p "foo\n".chomp # => "foo"
p "foo\n\r".chomp # => "foo\n"
chomp!(rs = $/) -> self | nil[permalink][rdoc]self の末尾から rs で指定する改行コードを取り除きます。 ただし rs が "\n" ($/ のデフォルト値) のときは、 システムによらず "\r", "\r\n", "\n" のすべてを改行コードとみなして取り除きます。
rs に nil を指定した場合、このメソッドは何もしません。
rs に空文字列 ("") を指定した場合は「パラグラフモード」になり、 末尾の連続する改行コードをすべて取り除きます。
例:
buf = "string\n" buf.chomp! p buf # => "string" $/ = "\n" # デフォルトと同じ p "foo\r".chomp! # => "foo" p "foo\r\n".chomp! # => "foo" p "foo\n".chomp! # => "foo" p "foo\n\r".chomp! # => "foo\n"
chop -> String[permalink][rdoc]文字列の最後の文字を取り除いた新しい文字列を生成して返します。 ただし、文字列の終端が "\r\n" であればその 2 文字を取り除きます。
例:
p "string\n".chop # => "string" p "string\r\n".chop # => "string" p "string".chop # => "strin" p "strin".chop # => "stri" p "".chop # => ""
chop! -> self | nil[permalink][rdoc]文字列の最後の文字を取り除きます。 ただし、終端が "\r\n" であればその 2 文字を取り除きます。
chr -> String[permalink][rdoc]self の最初の文字だけを含む文字列を返します。
[SEE_ALSO] String#ord, Integer#chr
clear -> self[permalink][rdoc]文字列の内容を削除して空にします。 self を返します。
例:
str = "abc" str.clear p str # => "" str = "" str.clear p str # => ""
codepoints -> [Integer][permalink][rdoc]codepoints {|codepoint| block } -> self文字列の各コードポイントの配列を返します。(self.each_codepoint.to_a と同じです)
#coding:UTF-8 "hello わーるど".codepoints # => [104, 101, 108, 108, 111, 32, 12431, 12540, 12427, 12393]
ブロックが指定された場合は String#each_codepoint と同じように動作 します。ただし obsolete のため、ブロックを指定する場合は String#each_codepoint を使用してください。
[SEE_ALSO] String#each_codepoint
count(*chars) -> Integer[permalink][rdoc]chars で指定された文字が文字列 self にいくつあるか数えます。
検索する文字を示す引数 chars の形式は tr(1) と同じです。 つまり、「"a-c"」は文字 a から c を意味し、 「"^0-9"」のように文字列の先頭が「^」の場合は 指定文字以外を意味します。
文字「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、「^」も文字列の先頭にあるときだけ否定の効果を発揮します。 また、「-」「^」「\」は バックスラッシュ (「\」) によりエスケープできます。
引数を複数指定した場合は、 すべての引数にマッチした文字だけを数えます。
例:
p 'abcdefg'.count('c') # => 1
p '123456789'.count('2378') # => 4
p '123456789'.count('2-8', '^4-6') # => 4
# ファイルの行数を数える
n_lines = File.open("foo").read.count("\n")
# ファイルの末尾に改行コードがない場合にも対処する
buf = File.open("foo").read
n_lines = buf.count("\n")
n_lines += 1 if /[^\n]\z/ =~ buf
# if /\n\z/ !~ buf だと空ファイルを 1 行として数えてしまうのでダメ
crypt(salt) -> String[permalink][rdoc]self と salt から暗号化された文字列を生成して返します。 salt には英数字、ドット (「.」)、スラッシュ (「/」) から構成される、 2 バイト以上の文字列を指定します。
暗号化された文字列から暗号化前の文字列 (self) を求めることは一般に困難で、 self を知っている者のみが同じ暗号化された文字列を生成できます。 このことから self を知っているかどうかの認証に使うことが出来ます。
salt には、以下の様になるべくランダムな文字列を選ぶべきです。 他にも [ruby-list:29297] などがあります。
注意:
例:
# パスワードの暗号化
salt = [rand(64),rand(64)].pack("C*").tr("\x00-\x3f","A-Za-z0-9./")
passwd.crypt(salt)
# UNIX のログイン認証
require 'etc'
def valid_login?(user, password)
ent = Etc.getpwnam(user)
password.crypt(ent.passwd) == ent.passwd
end
p valid_login?("taro", "password") # => 真偽値が得られる
delete(*strs) -> String[permalink][rdoc]self から strs に含まれる文字を取り除いた文字列を生成して返します。
str の形式は tr(1) と同じです。 つまり、`a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外を意味します。
「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 「^」も文字列の先頭にあるときだけ効果を発揮します。 また、「-」「^」「\」はバックスラッシュ (「\」) によってエスケープできます。
なお、引数を複数指定した場合は、 すべての引数にマッチする文字だけが削除されます。
例:
p "123456789".delete("2378") #=> "14569"
p "123456789".delete("2-8", "^4-6") #=> "14569"
delete!(*strs) -> self | nil[permalink][rdoc]self から strs に含まれる文字を破壊的に取り除きます。
str の形式は tr(1) と同じです。 つまり、「a-c」は a から c を意味し、"^0-9" のように 文字列の先頭が「^」の場合は指定文字以外を意味します。
「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 「^」も文字列先頭にあるときだけ否定の効果を発揮します。 また、「-」「^」「\」はバックスラッシュ (「\」) によってエスケープできます。
なお、引数を複数指定した場合は、 すべての引数にマッチする文字だけが削除されます。
例:
p "123456789".delete("2-8", "^4-6") #=> "14569"
p "123456789".delete("2378") #=> "14569"
downcase -> String[permalink][rdoc]'A' から 'Z' までの アルファベット大文字をすべて小文字に置き換えた新しい文字列を生成して返します。 アルファベット大文字以外の文字はすべてそのまま保存されます。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
例:
p "STRing?".downcase # => "string?"
[SEE_ALSO] String#downcase!, String#upcase, String#swapcase, String#capitalize
downcase! -> self | nil[permalink][rdoc]文字列中の 'A' から 'Z' までの アルファベット大文字をすべて破壊的に小文字に置き換えます。 アルファベット大文字以外の文字はすべてそのまま保存されます。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
例:
str = "STRing?" str.downcase! p str # => "string?"
[SEE_ALSO] String#downcase, String#upcase!, String#swapcase!, String#capitalize!
dump -> String[permalink][rdoc]文字列中の非表示文字をバックスラッシュ記法に置き換えた文字列を返します。 str == eval(str.dump) となることが保証されています。
例:
# p だとさらにバックスラッシュが増えて見にくいので puts している puts "abc\r\n\f\x00\b10\\\"".dump # => "abc\r\n\f\000\01010\\\""
each_byte {|byte| ... } -> self[permalink][rdoc]each_byte -> Enumerator文字列の各バイトに対して繰り返します。
例:
"str".each_byte do |byte|
p byte
end
# => 115
# => 116
# => 114
[SEE_ALSO] String#bytes
each_char {|cstr| block } -> self[permalink][rdoc]each_char -> Enumerator文字列の各文字に対して繰り返します。
たとえば、
"hello世界".each_char {|c| print c, ' ' }
は次のように出力されます。
h e l l o 世 界
[SEE_ALSO] String#chars
each_codepoint {|codepoint| block } -> self[permalink][rdoc]each_codepoint -> Enumerator文字列の各コードポイントに対して繰り返します。
#coding:UTF-8 "hello わーるど".each_codepoint.to_a # => [104, 101, 108, 108, 111, 32, 12431, 12540, 12427, 12393]
[SEE_ALSO] String#codepoints
each_line(rs = $/) {|line| ... } -> self[permalink][rdoc]each_line(rs = $/) -> Enumerator文字列中の各行に対して繰り返します。 行の区切りは rs に指定した文字列で、 そのデフォルト値は変数 $/ の値です。 各 line には区切りの文字列も含みます。
rs に nil を指定すると行区切りなしとみなします。 rs に空文字列 "" を指定すると「パラグラフモード」になり、 改行コードが 2 つ以上連続するところで文字列を分割します (つまり空行で分割します)。
例:
"aa\nbb\ncc\n".each_line do |line|
p line
end
# => "aa\n"
# => "bb\n"
# => "cc\n"
p "aa\nbb\ncc\n".lines.to_a # => ["aa\n", "bb\n", "cc\n"]
p "aa\n".lines.to_a # => ["aa\n"]
p "".lines.to_a # => []
s = "aa\nbb\ncc\n"
p s.lines("\n").to_a #=> ["aa\n", "bb\n", "cc\n"]
p s.lines("bb").to_a #=> ["aa\nbb", "\ncc\n"]
[SEE_ALSO] String#lines
empty? -> bool[permalink][rdoc]文字列が空 (つまり長さ 0) の時、真を返します。
encode(encoding, options = nil) -> String[permalink][rdoc]encode(encoding, from_encoding, options = nil) -> Stringencode(options = nil) -> Stringself を指定したエンコーディングに変換した文字列を作成して返します。引数 を2つ与えた場合、第二引数は変換元のエンコーディングを意味します。さもな くば self のエンコーディングが使われます。 無引数の場合は、Encoding.default_internal が nil でなければそれが変換先のエンコーディングになり、かつ :invalid => replace と :undef => replace が指定されたと見なされ、nil ならば変換は行われません。
変換オプション
変換元のエンコーディングにおいて不正なバイトがあった場合に、例外 Encoding::InvalidByteSequenceError を投げます。(デフォルト)
変換元のエンコーディングにおいて不正なバイトがあった場合に、不正なバイトを置換文字で置き換えます。
変換先のエンコーディングにおいて文字が定義されていない場合に、例外 Encoding::UndefinedConversionError を投げます。(デフォルト)
変換先のエンコーディングにおいて文字が定義されていない場合に、未定義文字を置換文字で置き換えます。
前述の :invalid => :replace や :undef => :replace で用いられる置換文字を指定します。デフォルトは Unicode 系のエンコーディングならば U+FFFD、それ以外では "?" です。
文字列を XML の CharData として適するように処理します。具体的には、'&'、'<'、'>'、をそれぞれ '&'、'<'、'>' に変換し、未定義文字を文字参照 (大文字16進数) に置き換えます。この出力は HTML の #PCDATA として利用することもできます。
文字列を XML の AttValue として適するように処理します。具体的には、'&'、'<'、'>'、'"'、をそれぞれ '&'、'<'、'>'、'"' に変換し、未定義文字を文字参照 (大文字16進数) に置き換えます。この出力は HTML の属性値として利用することもできます。
CR 改行および CRLF 改行を LF 改行に置き換えます。
LF 改行を CR 改行に置き換えます。(CRLF は CRCR になります)
LF 改行を CRLF 改行に置き換えます。(CRLF は CRCRLF になります)
これ以上細かい指定を行いたい場合は、Encoding::Converter#convert を用いましょう。
例:
#coding:UTF-8
s = "いろは"
s.encode("EUC-JP")
s.encode(Encoding::UTF_8)
[SEE_ALSO] String#encode!
encode!(encoding, options = nil) -> self[permalink][rdoc]encode!(encoding, from_encoding, options = nil) -> selfself を指定したエンコーディングに変換し、自身を置き換えます。引数を2つ 与えた場合、第二引数は変換元のエンコーディングを意味します。さもなくば self のエンコーディングが使われます。変換後の self を返します。
(gsub!などと異なり)変換が行なわれなくても self を返します。
例:
#coding:UTF-8
s = "いろは"
s.encode!("EUC-JP")
s.encode!(Encoding::UTF_8)
[SEE_ALSO] String#encode
encoding -> Encoding[permalink][rdoc]文字列のエンコーディング情報を表現した Encoding オブジェクトを返します。
[SEE_ALSO] Encoding
end_with?(*strs) -> bool[permalink][rdoc]self の末尾が strs のいずれかであるとき true を返します。
例:
"string".end_with?("ing") # => true
"string".end_with?("str") # => false
"string".end_with?("str", "ing") # => true
[SEE_ALSO] String#start_with?
eql?(other) -> bool[permalink][rdoc]文字列の内容が文字列 other の内容と等しいときに true を返します。 等しくなければ false を返します。
このメソッドは文字列の内容を比較します。 同一のオブジェクトかどうかを比較するわけではありません。 つまり、"string".eql?(str) という式を実行した場合には、 str が "string" という内容の文字列でありさえすれば常に true を返します。 同一のオブジェクトであるかどうかを判定したいときは Object#equal? を使ってください。
アルファベットの大文字小文字を無視して比較したい場合は、String#upcase, String#downcase で大文字小文字を揃えてから比較してください。
Hash クラス内での比較に使われます。
例:
p "string".eql?("string") # => true
p "string".eql?("STRING") # => false
p "string".eql?("") # => false
p "".eql?("string") # => false
p "string".eql?("str" + "ing") # => true (内容が同じなら true)
p "string".eql?("stringX".chop) # => true (内容が同じなら true)
p "string".upcase.eql?("String".upcase) # => true
p "string".downcase.eql?("String".downcase) # => true
[SEE_ALSO] Hash, String#<=>, String#casecmp, String#==
force_encoding(encoding) -> self[permalink][rdoc]文字列の持つエンコーディング情報を指定された encoding に変えます。
このとき実際のエンコーディングは変換されず、検査もされません。 Array#pack などで得られたバイト列のエンコーディングを指定する時に使います。
例:
s = [164, 164, 164, 237, 164, 207].pack("C*")
p s.encoding #=> ASCII-8BIT
p s.force_encoding("EUC-JP") #=> "いろは"
u = [12411, 12408, 12392].pack("U*")
u.force_encoding("UTF-8") #=> "ほへと"
getbyte(index) -> Integer | nil[permalink][rdoc]index バイト目のバイトを整数で返します。
index に負を指定すると末尾から数えた位置のバイト を取り出します。 範囲外を指定した場合は nil を返します。
gsub(pattern, replace) -> String[permalink][rdoc]文字列中で pattern にマッチする部分全てを 文字列 replace で置き換えた文字列を生成して返します。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
例:
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"
注意:
第 2 引数 replace に $1 を埋め込んでも意図した結果にはなりません。 この文字列が評価される時点ではまだ正規表現マッチが行われておらず、 $1 がセットされていないからです。
また、gsub では「\」が部分文字列との置き換えという特別な意味を持つため、 replace に「\」自身を入れたいときは 「\」を二重にエスケープしなければなりません。
# ひとつめの括弧の内容に置き換えるときによくある間違い
p 'xbbb-xbbb'.gsub(/x(b+)/, "#{$1}") # => "-" # NG
p 'xbbb-xbbb'.gsub(/x(b+)/, "\1") # => "1-1" # NG
p 'xbbb-xbbb'.gsub(/x(b+)/, "\\1") # => "bbb-bbb" # OK
p 'xbbb-xbbb'.gsub(/x(b+)/, '\1') # => "bbb-bbb" # OK
p 'xbbb-xbbb'.gsub(/x(b+)/, '\\1') # => "bbb-bbb" # OK
# バックスラッシュを倍にするときによくある間違い
puts '\n'.gsub(/\\/, "\\\\") # => \n # NG
puts '\n'.gsub(/\\/, '\\\\') # => \n # NG
puts '\n'.gsub(/\\/, "\\\\\\\\") # => \\n # OK
puts '\n'.gsub(/\\/, '\\\\\\\\') # => \\n # OK
このような間違いを確実に防止し、コードの可読性を上げるには、 \& や \1 よりも下記のようにブロック付き形式の gsub を使うべきです。
p 'xbbb-xbbb'.gsub(/x(b+)/) { $1 } # => "bbb-bbb" # OK
puts '\n'.gsub(/\\/) { '\\\\' } # => \\n # OK
[SEE_ALSO] String#sub
gsub(pattern) {|matched| .... } -> String[permalink][rdoc]gsub(pattern) -> Enumerator文字列中で pattern にマッチした部分を順番にブロックに渡し、 その実行結果で置き換えた文字列を生成して返します。 ブロックなしの場合と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
なお、ブロック付きの gsub で文字列を置き換えない場合は[[String#scan]] と同じ動作になります。
例:
p 'abcabc'.gsub(/[bc]/) {|s| s.upcase } #=> "aBCaBC"
p 'abcabc'.gsub(/[bc]/) { $&.upcase } #=> "aBCaBC"
[SEE_ALSO] String#sub, String#scan
gsub(pattern, hash) -> String[permalink][rdoc]文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
hash = {'b'=>'B', 'c'=>'C'}
p "abcabc".gsub(/[bc]/){hash[$&]} #=> "aBCaBC"
p "abcabc".gsub(/[bc]/, hash) #=> "aBCaBC"
gsub!(pattern, replace) -> self | nil[permalink][rdoc]文字列中で pattern にマッチする部分全てを文字列 replace に破壊的に置き換えます。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
gsub! は通常 self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
例:
buf = "String-String" buf.gsub!(/in./, "!!") p buf # => "Str!!-Str!!" buf = "String.String" buf.gsub!(/in./, '<<\&>>') p buf # => "Str<<ing>>-Str<<ing>>"
注意:
引数 replace の中で $1 を使うことはできません。 replace は gsub メソッドの呼び出しより先に評価されるので、 まだ gsub の正規表現マッチが行われておらず、 $1 がセットされていないからです。
また、gsub では「\」が部分文字列との置き換えという特別な意味を持つため、 replace に「\」自身を入れたいときは 「\」を二重にエスケープしなければなりません。
例:
# ひとつめの括弧にマッチした部分に置き換えるときによくやる間違い
'abbbcd'.gsub!(/a(b+)/, "#{$1}") # NG
'abbbcd'.gsub!(/a(b+)/, "\1") # NG
'abbbcd'.gsub!(/a(b+)/, "\\1") # OK
'abbbcd'.gsub!(/a(b+)/, '\\1') # OK
'abbbcd'.gsub!(/a(b+)/, '\1') # OK
'abbbcd'.gsub!(/a(b+)/) { $1 } # OK これがもっとも安全
[SEE_ALSO] String#sub
gsub!(pattern) {|matched| .... } -> self | nil[permalink][rdoc]gsub!(pattern) -> Enumerator文字列中で pattern にマッチする部分全てを順番にブロックに渡し、 その評価結果に置き換えます。
また、ブロックなしの場合と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
例:
str = 'abcabc'
str.gsub!(/b/) {|s| s.upcase }
p str #=> "aBcaBc"
str = 'abcabc'
str.gsub!(/b/) { $&.upcase }
p str #=> "aBcaBc"
[SEE_ALSO] String#sub
gsub!(pattern, hash) -> self | nil[permalink][rdoc]文字列中の pattern にマッチした部分をキーにして hash を引いた値へ破壊的に置き換えます。
hash = {'b'=>'B', 'c'=>'C'}
str = "abcabc"
str.gsub!(/[bc]/){hash[$&]}
p str #=> "aBCaBC"
str = "abcabc"
str.gsub!(/[bc]/, hash)
p str #=> "aBCaBC"
hash -> Integer[permalink][rdoc]self のハッシュ値を返します。 eql? で等しい文字列は、常にハッシュ値も等しくなります。
[SEE_ALSO] Hash
hex -> Integer[permalink][rdoc]文字列に 16 進数で数値が表現されていると解釈して整数に変換します。 接頭辞 "0x", "0X" とアンダースコアは無視されます。 文字列が [_0-9a-fA-F] 以外の文字を含むときはその文字以降を無視します。
self が空文字列のときは 0 を返します。
例:
p "10".hex # => 16 p "ff".hex # => 255 p "0x10".hex # => 16 p "-0x10".hex # => -16 p "xyz".hex # => 0 p "10z".hex # => 16 p "1_0".hex # => 16 p "".hex # => 0
[SEE_ALSO] String#oct, String#to_i, String#to_f, Kernel.#Integer, Kernel.#Float
このメソッドの逆に数値を文字列に変換するには Kernel.#sprintf, String#%, Integer#to_s などを使ってください。
include?(substr) -> bool[permalink][rdoc]文字列中に部分文字列 substr が含まれていれば真を返します。
index(pattern, pos = 0) -> Integer[permalink][rdoc]文字列のインデックス pos から右に向かって pattern を検索し、 最初に見つかった部分文字列の左端のインデックスを返します。 見つからなければ nil を返します。
引数 pattern は探索する部分文字列または正規表現で指定します。
pos が負の場合、文字列の末尾から数えた位置から探索します。
例:
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
[SEE_ALSO] String#rindex
insert(pos, other) -> self[permalink][rdoc]pos 番目の文字の直前に文字列 other を挿入します。 self[pos, 0] = other と同じ操作です。
例:
str = "foobaz" str.insert(3, "bar") p str # => "foobarbaz"
[SEE_ALSO] String#[]=
inspect -> String[permalink][rdoc]文字列オブジェクトの内容を、出力したときに人間が読みやすいような適当な形式に変換します。 変換された文字列は印字可能な文字のみによって構成されます
現在の実装では、Ruby のリテラル形式を使って、 文字列中の不可視文字をエスケープシーケンスに変換します。
このメソッドは主にデバッグのために用意されています。 永続化などの目的で文字列をダンプしたいときは、 String#dump を使うべきです。
例：
# p ではないことに注意 puts "string".inspect # => "string" puts "\t\r\n".inspect # => "\t\r\n"
[SEE_ALSO] String#dump
intern -> Symbol[permalink][rdoc]to_sym -> Symbol文字列に対応するシンボル値 Symbol を返します。
なお、このメソッドの逆にシンボルに対応する文字列を得るには Symbol#to_s または Symbol#id2name を使います。
Ruby 1.9 以降では、シンボル文字列にナルキャラクタ("\0")、空の文字列が使用可能になりました。
例:
p "foo".intern # => :foo p "foo".intern.to_s == "foo" # => true
length -> Integer[permalink][rdoc]size -> Integer文字列の文字数を返します。バイト数を知りたいときは bytesize メソッドを使ってください。
[SEE_ALSO] String#bytesize
lines(rs = $/) -> [String][permalink][rdoc]lines(rs = $/) {|line| ... } -> self文字列中の各行を文字列の配列で返します。(self.each_line.to_a と同じです)
"aa\nbb\ncc\n".lines # => ["aa\n", "bb\n", "cc\n"]
行の区切りは rs に指定した文字列で、 そのデフォルト値は変数 $/ の値です。 各 line には区切りの文字列も含みます。
rs に nil を指定すると行区切りなしとみなします。 rs に空文字列 "" を指 定すると「パラグラフモード」になり、 改行コードが 2 つ以上連続するとこ ろで文字列を分割します (つまり空行で分割します)。
ブロックが指定された場合は String#each_line と同じように動作しま す。ただし obsolete のため、ブロックを指定する場合は String#each_line を使用してください。
[SEE_ALSO] String#each_line
ljust(width, padding = ' ') -> String[permalink][rdoc]長さ width の文字列に self を左詰めした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。 また、第 2 引数 padding を指定したときは 空白文字の代わりに padding を詰めます。
例:
p "foo".ljust(10) # => "foo " p "foo".ljust(9) # => "foo " p "foo".ljust(8) # => "foo " p "foo".ljust(2) # => "foo" p "foo".ljust(1) # => "foo" p "foo".ljust(10, "*") # => "foo*******"
[SEE_ALSO] String#center, String#rjust
lstrip -> String[permalink][rdoc]文字列の先頭にある空白文字を全て取り除いた新しい文字列を返します。 空白文字の定義は " \t\r\n\f\v" です。
例:
p " abc\n".lstrip #=> "abc\n" p "\t abc\n".lstrip #=> "abc\n" p "abc\n".lstrip #=> "abc\n"
[SEE_ALSO] String#strip, String#rstrip
lstrip! -> self | nil[permalink][rdoc]文字列の先頭にある空白文字を全て破壊的に取り除きます。 空白文字の定義は " \t\r\n\f\v" です。
lstrip! は self を変更して返します。 ただし取り除く空白がなかったときは nil を返します。
例:
str = " abc" p str.lstrip! # => "abc" p str # => "abc" str = "abc" p str.lstrip! # => nil p str # => "abc"
match(regexp, pos = 0) -> MatchData | nil[permalink][rdoc]match(regexp, pos = 0) {|m| ... } -> objectregexp.match(self, pos) と同じです。 regexp が文字列の場合は、正規表現にコンパイルします。 詳しくは Regexp#match を参照してください。
succ -> String[permalink][rdoc]next -> Stringself の「次の」文字列を返します。
「次の」文字列は、対象の文字列の右端から アルファベットなら アルファベット順(aの次はb, zの次はa, 大文字も同様)に、 数字なら 10 進数(9 の次は 0)とみなして計算されます。
p "aa".succ # => "ab" p "88".succ.succ # => "90"
"99" → "100", "AZZ" → "BAA" のような繰り上げも行われます。 このとき負符号などは考慮されません。
p "99".succ # => "100" p "ZZ".succ # => "AAA" p "a9".succ # => "b0" p "-9".succ # => "-10"
self にアルファベットや数字とそれ以外の文字が混在している場合、 アルファベットと数字だけが「次の」文字になり、残りは保存されます。
p "1.9.9".succ # => # "2.0.0"
逆に self がアルファベットや数字をまったく含まない場合は、 単純に文字コードを 1 増やします。
p ".".succ # => "/"
さらに、self が空文字列の場合は "" を返します。 このメソッドはマルチバイト文字を意識せず、 単に文字列をバイト列として扱います。
なお、succ と逆の動作をするメソッドはありません。 また、succ という名前の由来は successor です。
例:
p "aa".succ # => "ab" # 繰り上がり p "99".succ # => "100" p "a9".succ # => "b0" p "Az".succ # => "Ba" p "zz".succ # => "aaa" p "-9".succ # => "-10" p "9".succ # => "10" p "09".succ # => "10" # アルファベット・数字とそれ以外の混在 p "1.9.9".succ # => # "2.0.0" # アルファベット・数字以外のみ p ".".succ # => "/" p "\0".succ # => "\001" p "\377".succ # => "\001\000"
このメソッドは文字列の Range の内部で使用されます。
succ! -> String[permalink][rdoc]next! -> Stringself を「次の」文字列に置き換えます。 「次の」文字列は、アルファベットなら 16 進数、 数字なら 10 進数とみなして計算されます。 「次の」文字列の計算では "99" → "100" のように繰り上げも行われます。 このとき負符号などは考慮されません。
self にアルファベットや数字とそれ以外の文字が混在している場合、 アルファベットと数字だけが「次の」文字になり、残りは保存されます。 逆に self がアルファベットや数字をまったく含まない場合は、 単純に文字コードを 1 増やします。
さらに、self が空文字列の場合は "" を返します。
このメソッドはマルチバイト文字を意識せず、 単に文字列をバイト列として扱います。
なお、succ! と逆の動作をするメソッドはありません。
例:
p "aa".succ # => "ab" # 繰り上がり p "99".succ # => "100" p "a9".succ # => "b0" p "Az".succ # => "Ba" p "zz".succ # => "aaa" p "-9".succ # => "-10" p "9".succ # => "10" p "09".succ # => "10" # アルファベット・数字とそれ以外の混在 p "1.9.9".succ # => # "2.0.0" # アルファベット・数字以外のみ p ".".succ # => "/" p "\0".succ # => "\001" p "\377".succ # => "\001\000"
[SEE_ALSO] String#succ
oct -> Integer[permalink][rdoc]文字列を 8 進文字列であると解釈して、整数に変換します。
例:
p "10".oct # => 8 p "010".oct # => 8 p "8".oct # => 0
oct は文字列の接頭辞 ("0", "0b", "0B", "0x", "0X") に応じて 8 進以外の変換も行います。
例:
p "0b10".oct # => 2 p "10".oct # => 8 p "010".oct # => 8 p "0x10".oct # => 16
整数とみなせない文字があればそこまでを変換対象とします。 変換対象が空文字列であれば 0 を返します。
符号や _ が含まれる場合も変換対象になります。
例:
p "-010".oct # => -8 p "-0x10".oct # => 0 p "-0b10".oct # => 0 p "1_0_1x".oct # => 65
[SEE_ALSO] String#hex, String#to_i, String#to_f, Kernel.#Integer, Kernel.#Float
逆に、数値を文字列に変換するにはKernel.#sprintf, String#%, Integer#to_s を使用します。
ord -> Integer[permalink][rdoc]文字列の最初の文字の文字コードを整数で返します。
self が空文字列のときは例外を発生します。
例:
p "a".ord # => 97
[SEE_ALSO] Integer#chr, String#chr
partition(sep) -> [String, String, String][permalink][rdoc]セパレータ sep が最初に登場する部分で self を 3 つに分割し、 [最初のセパレータより前の部分, セパレータ, それ以降の部分] の 3 要素の配列を返します。
self がセパレータを含まないときは、 返り値の第 2 要素と第 3 要素が空文字列になります。
例：
p "axaxa".partition("x") # => ["a", "x", "axa"]
p "aaaaa".partition("x") # => ["aaaaa", "", ""]
p "aaaaa".partition("") # => ["", "", "aaaaa"]
[SEE_ALSO] String#rpartition, String#split
prepend(other_str) -> String[permalink][rdoc]文字列 other_str を先頭に破壊的に追加します。
例:
a = "world"
a.prepend("hello ") # => "hello world"
a # => "hello world"
replace(other) -> String[permalink][rdoc]self の内容を other の内容で置き換えます。
例:
str = "foo" str.replace "bar" p str # => "bar"
reverse -> String[permalink][rdoc]文字列を文字単位で左右逆転した文字列を返します。
例:
p "foobar".reverse # => "raboof" p "".reverse # => ""
reverse! -> self[permalink][rdoc]文字列を文字単位で左右逆転します。
例:
str = "foobar" str.reverse! p str # => "raboof"
rindex(pattern, pos = self.size) -> Integer | nil[permalink][rdoc]文字列のインデックス pos から左に向かって pattern を探索します。 最初に見つかった部分文字列の左端のインデックスを返します。 見つからなければ nil を返します。
引数 pattern は探索する部分文字列または正規表現で指定します。
pos が負の場合は、文字列の末尾から数えた位置から探索します。
rindex と String#index とでは、探索方向だけが逆になります。 完全に左右が反転した動作をするわけではありません。 探索はその開始位置を右から左にずらしながら行いますが、 部分文字列の照合はどちらのメソッドも左から右に向かって行います。 以下の例を参照してください。
# String#index の場合
p "stringstring".index("ing", 1) # => 3
# ing # ここから探索を始める
# ing
# ing # 右にずらしていってここで見つかる
# String#rindex の場合
p "stringstring".rindex("ing", -1) # => 9
# ing # インデックス -1 の文字から探索を始める
# ing
# ing # 左にずらしていってここで見つかる
例:
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
[SEE_ALSO] String#index
rjust(width, padding = ' ') -> String[permalink][rdoc]長さ width の文字列に self を右詰めした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。 また、第 2 引数 padding を指定したときは 空白文字の代わりに padding を詰めます。
例:
p "foo".rjust(10) # => " foo" p "foo".rjust(9) # => " foo" p "foo".rjust(8) # => " foo" p "foo".rjust(2) # => "foo" p "foo".rjust(1) # => "foo" p "foo".rjust(10, "*") # => "*******foo"
[SEE_ALSO] String#center, String#ljust
rpartition(sep) -> [String, String, String][permalink][rdoc]セパレータ sep が最後に登場する部分で self を 3 つに分割し、 [最後のセパレータより前の部分, セパレータ, それ以降の部分] の 3 要素の配列を返します。
self がセパレータを含まないときは、 返り値の第 1 要素と第 2 要素が空文字列になります。
例：
p "axaxa".rpartition("x") # => ["axa", "x", "a"]
p "aaaaa".rpartition("x") # => ["", "", "aaaaa"]
[SEE_ALSO] String#partition, String#split
rstrip -> String[permalink][rdoc]文字列の末尾にある空白文字を全て取り除いた新しい文字列を返します。 空白文字の定義は " \t\r\n\f\v\0" です。
例:
p " abc\n".rstrip #=> " abc" p " abc \t\r\n\0".rstrip #=> " abc" p " abc".rstrip #=> " abc" p " abc\0 ".rstrip #=> " abc" str = "abc\n" p str.rstrip #=> "abc" p str #=> "abc\n" (元の文字列は変化しない)
[SEE_ALSO] String#lstrip,String#strip
rstrip! -> self | nil[permalink][rdoc]文字列の末尾にある空白文字を全て破壊的に取り除きます。 空白文字の定義は " \t\r\n\f\v\0" です。
例:
str = " abc\n" p str.rstrip! # => " abc" p str # => " abc" str = " abc \r\n\t\v\0" p str.rstrip! # => " abc" p str # => " abc"
[SEE_ALSO] String#rstrip, String#lstrip
scan(pattern) -> [String] | [[String]][permalink][rdoc]self に対して pattern を繰り返しマッチし、 マッチした部分文字列の配列を返します。
pattern が正規表現で括弧を含む場合は、 括弧で括られたパターンにマッチした部分文字列の配列の配列を返します。
例:
p "foobar".scan(/../) # => ["fo", "ob", "ar"]
p "foobar".scan("o") # => ["o", "o"]
p "foobarbazfoobarbaz".scan(/ba./) # => ["bar", "baz", "bar", "baz"]
p "foobar".scan(/(.)/)
# => [["f"], ["o"], ["o"], ["b"], ["a"], ["r"]]
p "foobarbazfoobarbaz".scan(/(ba)(.)/)
# => [["ba", "r"], ["ba", "z"], ["ba", "r"], ["ba", "z"]]
scan(pattern) {|s| ... } -> self[permalink][rdoc]pattern がマッチした部分文字列をブロックに渡して実行します。 pattern が正規表現で括弧を含む場合は、 括弧で括られたパターンにマッチした文字列の配列を渡します。
例:
"foobarbazfoobarbaz".scan(/ba./) {|s| p s }
# => "bar"
# "baz"
# "baz"
# "baz"
"foobarbazfoobarbaz".scan("ba") {|s| p s }
# => "ba"
# "ba"
# "ba"
# "ba"
"foobarbazfoobarbaz".scan(/(ba)(.)/) {|s| p s }
# => ["ba", "r"]
# ["ba", "z"]
# ["ba", "r"]
# ["ba", "z"]
setbyte(index, b) -> Integer[permalink][rdoc]index バイト目のバイトを b に変更します。
index に負を指定すると末尾から数えた位置を変更します。
セットした値を返します。
slice!(nth) -> Integer[permalink][rdoc]slice!(pos, len) -> Stringslice!(substr) -> Stringslice!(regexp, nth = 0) -> Stringslice!(first..last) -> Stringslice!(first...last) -> Stringslice!(regexp, nth = 0) -> String指定した範囲 (String#[] 参照) を 文字列から取り除いたうえで取り除いた部分文字列を返します。
引数が範囲外を指す場合は nil を返します。
split(sep = $;, limit = 0) -> [String] | [[String]][permalink][rdoc]第 1 引数 sep で指定されたセパレータによって文字列を limit 個まで分割し、 結果を文字列の配列で返します。
第 1 引数 sep は以下のいずれかです。
正規表現にマッチする部分で分割する。 特に、括弧によるグルーピングがあればそのグループにマッチした 文字列も結果の配列に含まれる (後述)。
その文字列自体にマッチする部分で分割する。
先頭と末尾の空白を除いたうえで、空白文字列で分割する。
常に $; で分割する。 $; も nil の場合は、先頭と末尾の空白を除いたうえで、空白文字列で分割する。
文字列を 1 文字ずつに分割する。マルチバイト文字を認識する。
sep が正規表現で、かつその正規表現に括弧が含まれている場合には、 各括弧のパターンにマッチした文字列も配列に含まれます。 括弧が複数ある場合は、マッチしたものだけが配列に含まれます。
第 2 引数 limit は以下のいずれかです。
最大 limit 個の文字列に分割する
分割個数制限はなしで、配列末尾の空文字列を取り除く
分割個数の制限はなし
例:
p " a \t b \n c".split(/\s+/) # => ["", "a", "b", "c"]
p " a \t b \n c".split(nil) # => ["a", "b", "c"]
p " a \t b \n c".split(' ') # => ["a", "b", "c"] # split(nil) と同じ
p " a \t b \n c".split # => ["a", "b", "c"] # split(nil) と同じ
# 括弧を含む正規表現
p '1-10,20'.split(/([-,])/) # => ["1", "-", "10", ",", "20"]
# 正規表現が空文字列にマッチする場合は 1 文字に分割
p 'hi there'.split(/\s*/).join(':') # => "h:i:t:h:e:r:e"
# 文字列全体を 1 文字ずつに分割する例
p 'hi there'.split(//).join(':') # => "h:i: :t:h:e:r:e"
# limit == 0 だと制限なく分割、配列末尾の空文字列は取り除かれる
p "a,b,c,,,".split(/,/, 0) # => ["a", "b", "c"]
# limit 省略時は 0 と同じ (最もよく使われるパターン)
p "a,b,c,,,".split(/,/) # => ["a", "b", "c"]
# 正の limit 使用例
p "a,b,c,d,e".split(/,/, 1) # => ["a,b,c,d,e"]
p "a,b,c,d,e".split(/,/, 2) # => ["a", "b,c,d,e"]
p "a,b,c,d,e".split(/,/, 3) # => ["a", "b", "c,d,e"]
p "a,b,c,d,e".split(/,/, 4) # => ["a", "b", "c", "d,e"]
p "a,b,c,d,e".split(/,/, 5) # => ["a", "b", "c", "d", "e"]
p "a,b,c,d,e".split(/,/, 6) # => ["a", "b", "c", "d", "e"]
p "a,b,c,d,e".split(/,/, 7) # => ["a", "b", "c", "d", "e"]
# limit が負の数の場合は制限なく分割
p "a,b,c,,,".split(/,/, -1) # => ["a", "b", "c", "", "", ""]
[SEE_ALSO] String#partition, String#rpartition
squeeze(*chars) -> String[permalink][rdoc]chars に含まれる文字が複数並んでいたら 1 文字にまとめます。
chars の形式は tr(1) と同じです。つまり、 `a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外を意味します。
`-' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`^' もその効果は文字列の先頭にあるときだけです。また、 `-', `^', `\' はバックスラッシュ(`\')によ りエスケープすることができます。
引数を 1 つも指定しない場合は、すべての連続した文字を 1 文字にまとめます。
引数を複数指定した場合は、すべての引数にマッチする文字を 1 文字にまとめます。
例:
p "112233445566778899".squeeze # =>"123456789"
p "112233445566778899".squeeze("2-8") # =>"11234567899"
# 以下の 2 つは同じ意味
p "112233445566778899".squeeze("2378") # =>"11234455667899"
p "112233445566778899".squeeze("2-8", "^4-6") # =>"11234455667899"
squeeze!(*chars) -> self | nil[permalink][rdoc]chars に含まれる文字が複数並んでいたら 1 文字にまとめます。
chars の形式は tr(1) と同じです。つまり、 `a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外を意味します。
`-' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`^' もその効果は文字列の先頭にあるときだけです。また、 `-', `^', `\' はバックスラッシュ(`\')によ りエスケープすることができます。
引数を 1 つも指定しない場合は、すべての連続した文字を 1 文字にまとめます。
引数を複数指定した場合は、すべての引数にマッチする文字を 1 文字にまとめます。
1 文字もまとめられなかった場合は nil を返します。
例:
str = "112233445566778899"
str.squeeze!
p str # =>"123456789"
str = "112233445566778899"
str.squeeze!("2-8")
p str # =>"11234567899"
str = "123456789"
str.squeeze! # => nil
p str # =>"123456789"
start_with?(*strs) -> bool[permalink][rdoc]self の先頭が strs のいずれかであるとき true を返します。
例:
"string".start_with?("str") # => true
"string".start_with?("ing") # => false
"string".start_with?("ing", "str") # => true
[SEE_ALSO] String#end_with?
strip -> String[permalink][rdoc]文字列先頭と末尾の空白文字を全て取り除いた文字列を生成して返します。 空白文字の定義は " \t\r\n\f\v" です。 また、文字列右側からは "\0" も取り除きますが、 左側の "\0" は取り除きません。
例:
p " abc \r\n".strip #=> "abc" p "abc\n".strip #=> "abc" p " abc".strip #=> "abc" p "abc".strip #=> "abc" p " \0 abc \0".strip # => "\000 abc" # 右側のみ "\0" も取り除く str = "\tabc\n" p str.strip #=> "abc" p str #=> "\tabc\n" (元の文字列は変化しない)
[SEE_ALSO] String#lstrip, String#rstrip
strip! -> self | nil[permalink][rdoc]先頭と末尾の空白文字を全て破壊的に取り除きます。 空白文字の定義は " \t\r\n\f\v" です。 また、文字列右側からは "\0" も取り除きますが、 左側の "\0" は取り除きません。
strip! は、内容を変更した self を返します。 ただし取り除く空白がなかったときは nil を返します。
例:
str = " abc\r\n" p str.strip! #=> "abc" p str #=> "abc" str = "abc" p str.strip! #=> nil p str #=> "abc" str = " \0 abc \0" str.strip! p str # => "\000 abc" # 右側の "\0" のみ取り除かれる
[SEE_ALSO] String#strip, String#lstrip
sub(pattern, replace) -> String[permalink][rdoc]文字列中で pattern にマッチした最初の部分を 文字列 replace で置き換えた文字列を生成して返します。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
例:
p 'abcdefg'.sub(/def/, '!!') # => "abc!!g" p 'abcabc'.sub(/b/, '<<\&>>') # => "a<<b>>cabc" p 'xxbbxbb'.sub(/x+(b+)/, 'X<<\1>>') # => "X<<bb>>xbb"
注意:
第 2 引数 replace に $1 を埋め込んでも意図した結果にはなりません。 この文字列が評価される時点ではまだ正規表現マッチが行われておらず、 $1 がセットされていないからです。
また、sub では「\」が部分文字列との置き換えという特別な意味を持つため、 replace に「\」自身を入れたいときは 「\」を二重にエスケープしなければなりません。
# ひとつめの括弧の内容に置き換えるときによくある間違い
p 'xbbb-xbbb'.sub(/x(b+)/, "#{$1}") # => "-xbbb" # NG
p 'xbbb-xbbb'.sub(/x(b+)/, "\1") # => "1-xbbb" # NG
p 'xbbb-xbbb'.sub(/x(b+)/, "\\1") # => "bbb-xbbb" # OK
p 'xbbb-xbbb'.sub(/x(b+)/, '\1') # => "bbb-xbbb" # OK
p 'xbbb-xbbb'.sub(/x(b+)/, '\\1') # => "bbb-xbbb" # OK
# バックスラッシュを倍にするときによくある間違い
puts '\n'.sub(/\\/, "\\\\") # => \n # NG
puts '\n'.sub(/\\/, '\\\\') # => \n # NG
puts '\n'.sub(/\\/, "\\\\\\\\") # => \\n # OK
puts '\n'.sub(/\\/, '\\\\\\\\') # => \\n # OK
このような間違いを確実に防止し、コードの可読性を上げるには、 \& や \1 よりも下記のようにブロック付き形式の sub を使うべきです。
p 'xbbb-xbbb'.sub(/x(b+)/) { $1 } # => "bbb-xbbb" # OK
puts '\n'.sub(/\\/) { '\\\\' } # => \\n # OK
[SEE_ALSO] String#gsub
sub(pattern) {|matched| .... } -> String[permalink][rdoc]文字列中で pattern にマッチした最初の部分をブロックに渡し、 その評価結果で置き換えた新しい文字列を返します。 ブロックなしの sub と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
例:
p 'abcabc'.sub(/b/) {|s| s.upcase } #=> "aBcabc"
p 'abcabc'.sub(/b/) { $&.upcase } #=> "aBcabc"
[SEE_ALSO] String#gsub
sub(pattern, hash) -> String[permalink][rdoc]文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
hash = {'b'=>'B', 'c'=>'C'}
p "abcabc".sub(/[bc]/){hash[$&]} #=> "aBCabc"
p "abcabc".sub(/[bc]/, hash) #=> "aBCabc"
sub!(pattern, replace) -> self | nil[permalink][rdoc]文字列中で pattern にマッチした最初の部分を文字列 replace へ破壊的に置き換えます。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
sub! は通常 self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
例:
buf = "String-String" buf.sub!(/in./, "!!") p buf # => "Str!!-String" buf = "String.String" buf.sub!(/in./, '<<\&>>') p buf # => "Str<<ing>>-String"
注意:
引数 replace の中で $1 を使うことはできません。 replace は sub メソッドの呼び出しより先に評価されるので、 まだ sub の正規表現マッチが行われておらず、 $1 がセットされていないからです。
また、sub では「\」が部分文字列との置き換えという特別な意味を持つため、 replace に「\」自身を入れたいときは 「\」を二重にエスケープしなければなりません。
例:
# ひとつめの括弧にマッチした部分に置き換えるときによくやる間違い
'abbbcd'.sub!(/a(b+)/, "#{$1}") # NG
'abbbcd'.sub!(/a(b+)/, "\1") # NG
'abbbcd'.sub!(/a(b+)/, "\\1") # OK
'abbbcd'.sub!(/a(b+)/, '\\1') # OK
'abbbcd'.sub!(/a(b+)/, '\1') # OK
'abbbcd'.sub!(/a(b+)/) { $1 } # OK これがもっとも安全
[SEE_ALSO] String#gsub
sub!(pattern) {|matched| .... } -> self | nil[permalink][rdoc]文字列中で pattern にマッチした最初の部分をブロックに渡し、 その評価結果へ破壊的に置き換えます。
また、ブロックなしの sub と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
例:
str = 'abcabc'
str.sub!(/b/) {|s| s.upcase }
p str #=> "aBcabc"
str = 'abcabc'
str.sub!(/b/) { $&.upcase }
p str #=> "aBcabc"
[SEE_ALSO] String#gsub
sub!(pattern, hash) -> String[permalink][rdoc]文字列中の pattern にマッチした部分をキーにして hash を引いた値で破壊的に置き換えます。
sum(bits = 16) -> Integer[permalink][rdoc]文字列の bits ビットのチェックサムを計算します。
以下と同じです。
def sum(bits)
sum = 0
each_byte {|c| sum += c }
return 0 if sum == 0
sum & ((1 << bits) - 1)
end
例えば以下のコードで UNIX System V の sum(1) コマンドと同じ値が得られます。
例:
sum = 0 ARGF.each_line do |line| sum += line.sum end sum %= 65536
swapcase -> String[permalink][rdoc]'A' から 'Z' までのアルファベット大文字を小文字に、 'a' から 'z' までのアルファベット小文字を大文字に変更した文字列を返します。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
例:
p "ABCxyz".swapcase # => "abcXYZ" p "Access".swapcase # => "aCCESS"
[SEE_ALSO] String#swapcase!, String#upcase, String#downcase, String#capitalize
swapcase! -> self | nil[permalink][rdoc]'A' から 'Z' までのアルファベット大文字を小文字に、 'a' から 'z' までのアルファベット小文字を大文字に、破壊的に変更します。
swapcase! は self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
このメソッドはマルチバイト文字を認識しません。
例:
str = "ABCxyz" str.swapcase! p str # => "abcXYZ"
[SEE_ALSO] String#swapcase, String#upcase!, String#downcase!, String#capitalize!
to_c -> Complex[permalink][rdoc]自身を複素数 (Complex) に変換した結果を返します。
以下の形式を解析できます。i、j は大文字、小文字のどちらでも解析できます。
それぞれの数値は以下のいずれかの形式で指定します。先頭の空白文字や複素 数値の後にある文字列は無視されます。また、数値オブジェクトと同様に各桁 の間に「_」を入れる事ができます。
自身が解析できない値であった場合は 0+0i を返します。
例:
'9'.to_c # => (9+0i) '2.5'.to_c # => (2.5+0i) '2.5/1'.to_c # => ((5/2)+0i) '-3/2'.to_c # => ((-3/2)+0i) '-i'.to_c # => (0-1i) '45i'.to_c # => (0+45i) '3-4i'.to_c # => (3-4i) '-4e2-4e-2i'.to_c # => (-400.0-0.04i) '-0.0-0.0i'.to_c # => (-0.0-0.0i) '1/2+3/4i'.to_c # => ((1/2)+(3/4)*i) '10@10'.to_c # => (-8.390715290764524-5.440211108893697i) '-0.3_3'.to_c # => (-0.33+0i) " \t\r\n5+3i".to_c # => (5+3i) '5+3ix'.to_c # => (5+3i) 'ruby'.to_c # => (0+0i)
to_f -> Float[permalink][rdoc]文字列を 10 進数表現と解釈して、浮動小数点数 Float に変換します。
浮動小数点数とみなせなくなるところまでを変換対象とします。 変換対象が空文字列であれば 0.0 を返します。
例:
p "10".to_f # => 10.0
p "10e2".to_f # => 1000.0
p "1e-2".to_f # => 0.01
p ".1".to_f # => 0.1
p "nan".to_f # => 0.0
p "INF".to_f # => 0.0
p "-Inf".to_f # => -0.0
p(("10" * 1000).to_f) # => Infinity (with warning)
p "".to_f # => 0.0
p "1_0_0".to_f # => 100.0
p " \n10".to_f # => 10.0 # 先頭の空白は無視される
p "0xa.a".to_f # => 0.0
なお、このメソッドの逆に、数値を文字列に変換するには Kernel.#sprintf,String#%,Integer#to_s を使用します。
[SEE_ALSO] String#hex, String#oct, String#to_i, Kernel.#Integer, Kernel.#Float
to_i(base = 10) -> Integer[permalink][rdoc]文字列を 10 進数表現された整数であると解釈して、整数に変換します。
p " 10".to_i # => 10 p "+10".to_i # => 10 p "-10".to_i # => -10 p "010".to_i # => 10 p "-010".to_i # => -10
整数とみなせない文字があればそこまでを変換対象とします。 変換対象が空文字列であれば 0 を返します。
p "0x11".to_i # => 0 p "".to_i # => 0
基数を指定することでデフォルトの 10 進以外に 2 〜 36 進数表現へ変換できます。 それぞれ Ruby の整数リテラルで使用可能なプリフィクスは無視されます。 また、base に 0 を指定するとプリフィクスから基数を判断します。 認識できるプリフィクスは、 0b (2 進数)、0 (8 進数)、0o (8 進数)、0d (10 進数)、0x (16 進数) です。
0, 2 〜 36 以外の引数を指定した場合は 例外 ArgumentError が発生します。
p "01".to_i(2) # => 1 p "0b1".to_i(2) # => 1 p "07".to_i(8) # => 7 p "0o7".to_i(8) # => 7 p "1f".to_i(16) # => 31 p "0x1f".to_i(16) # => 31 p "0b10".to_i(0) # => 2 p "0o10".to_i(0) # => 8 p "010".to_i(0) # => 8 p "0d10".to_i(0) # => 10 p "0x10".to_i(0) # => 16
このメソッドの逆に数値を文字列に変換するには、 Kernel.#sprintf, String#%, Integer#to_s を使用します。
String#hex, String#oct, String#to_f, Kernel.#Integer, Kernel.#Float も参照してください。
to_r -> Rational[permalink][rdoc]自身を有理数(Rational)に変換した結果を返します。
Kernel.#Rational に文字列を指定した時のように、以下のいずれかの形 式で指定します。
例:
' 2 '.to_r # => (2/1) '1/3'.to_r # => (1/3) '-9.2'.to_r # => (-46/5) '-9.2E2'.to_r # => (-920/1) '1_234_567'.to_r # => (1234567/1) '1_234/5_678'.to_r # => (617/2839)
Kernel.#Rational に文字列を指定した時とは異なる点もあります。
途中に変換できないような文字列が入っていた場合は、それより先の文字列は 無視されます。
'21 june 09'.to_r # => (21/1) '21/06/09'.to_r # => (7/2) # 21/6 を約分して 7/2。
変換できないような文字列を指定した場合は 0/1 を返します。
'foo'.to_r # => (0/1) ''.to_r # => (0/1) 'bwv 1079'.to_r # => (0/1)
[SEE_ALSO] Kernel.#Rational
to_s -> String[permalink][rdoc]to_str -> Stringself を返します。
例:
p "str".to_s # => "str" p "str".to_str # => "str"
このメソッドは、文字列を他のクラスのインスタンスと混ぜて処理したいときに有効です。 例えば返り値が文字列か nil であるメソッド some_method があるとき、 to_s メソッドを使うと以下のように統一的に処理できます。
# some_method(5).downcase だと返り値が nil のときに # エラーになるので to_s をはさむ p some_method(5).to_s.downcase
tr(pattern, replace) -> String[permalink][rdoc]pattern 文字列に含まれる文字を検索し、 それを replace 文字列の対応する文字に置き換えます。
pattern の形式は tr(1) と同じです。つまり、 `a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外が置換の対象になります。
replace に対しても `-' による範囲指定が可能です。 例えば String#upcase は tr を使って "foo".tr('a-z', 'A-Z') と書けます。
`-' は文字列の両端にない場合にだけ範囲指定の意味になります。 `^' も文字列の先頭にあるときにだけ否定の効果を発揮します。 また、`-', `^', `\' はバックスラッシュ (`\') によりエスケープできます。
replace の範囲が pattern の範囲よりも小さい場合は、 replace の最後の文字が無限に続くものとして扱われます。
例:
p "foo".tr("f", "X") # => "Xoo"
p "foo".tr('a-z', 'A-Z') # => "FOO"
p "FOO".tr('A-Z', 'a-z') # => "foo"
[SEE_ALSO] String#tr_s
tr!(pattern, replace) -> self | nil[permalink][rdoc]pattern 文字列に含まれる文字を検索し、 それを replace 文字列の対応する文字に破壊的に置き換えます。
pattern の形式は tr(1) と同じです。 つまり、`a-c' は a から c を意味し、 "^0-9" のように文字列の先頭が `^' の場合は 指定文字以外が置換の対象になります。
replace に対しても `-' による範囲指定が可能です。 例えば、String#upcase を tr で書くと、
p "foo".tr('a-z', 'A-Z')
=> "FOO"
となります。
`-' は文字列の両端にない場合にだけ範囲指定の意味になります。 `^' も文字列の先頭にあるときにだけ否定の効果を発揮します。 また、`-', `^', `\' はバックスラッシュ (`\') によりエスケープできます。
replace の範囲が pattern の範囲よりも小さい場合は、 replace の最後の文字が無限に続くものと扱われます。
tr! は self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
[SEE_ALSO] String#tr, String#tr_s
tr_s(pattern, replace) -> String[permalink][rdoc]文字列の中に pattern 文字列に含まれる文字が存在したら、 replace 文字列の対応する文字に置き換えます。さらに、 置換した部分内に同一の文字の並びがあったらそれを 1 文字に圧縮します。
pattern の形式は tr(1) と同じです。 つまり「a-c」は a から c を意味し、 "^0-9" のように文字列の先頭が「^」の場合は指定した文字以外が置換の対象になります。
replace でも「-」を使って範囲を指定できます。
「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、「^」もその効果は文字列の先頭にあるときだけです。 また、「-」、「^」、「\」はバックスラッシュ (「\」) でエスケープできます。
replace の範囲が pattern の範囲よりも小さい場合、 replace の最後の文字が無限に続くものとして扱われます。
例:
p "gooooogle".tr_s("o", "X") # => "gXgle"
p "gooooogle".tr_s("a-z", "A-Z") # => "GOGLE"
注意: 一般に、tr_s を tr と squeeze で置き換えることはできません。 tr と squeeze の組みあわせでは tr の置換後の文字列全体を squeeze しますが、 tr_s は置換された部分だけを squeeze します。 以下のコードを参照してください。
p "foo".tr_s("o", "f") # => "ff"
p "foo".tr("o", "f").squeeze("f") # => "f"
[SEE_ALSO] String#tr
tr_s!(pattern, replace) -> self | nil[permalink][rdoc]文字列の中に pattern 文字列に含まれる文字が存在したら、 replace 文字列の対応する文字に置き換えます。さらに、 置換した部分内に同一の文字の並びがあったらそれを 1 文字に圧縮します。
pattern の形式は tr(1) と同じです。 つまり「a-c」は a から c を意味し、 "^0-9" のように文字列の先頭が「^」の場合は指定した文字以外が置換の対象になります。
replace でも「-」を使って範囲を指定できます。
p "gooooogle".tr_s("a-z", "A-Z") # => "GOGLE"
「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、「^」もその効果は文字列の先頭にあるときだけです。 また、「-」、「^」、「\」はバックスラッシュ (「\」) でエスケープできます。
replace の範囲が search の範囲よりも小さい場合、 replace の最後の文字が無限に続くものとして扱われます。
tr_s は置換後の文字列を生成して返します。 tr_s! は self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
注意: 一般に、tr_s! を tr! と squeeze! で置き換えることはできません。 tr! と squeeze! の組みあわせでは tr! の置換後の文字列全体を squeeze! しますが、 tr_s! は置換された部分だけを squeeze! します。 以下のコードを参照してください。
str = "foo"
str.tr_s!("o", "f")
p str # => "ff"
str = "foo"
str.tr!("o", "f")
str.squeeze!("f")
p str # => "f"
[SEE_ALSO] String#tr, String#tr_s
unpack(template) -> Array[permalink][rdoc]Array#pack で生成された文字列を テンプレート文字列 template にしたがってアンパックし、 それらの要素を含む配列を返します。
以下にあげるものは、Array#pack、String#unpack のテンプレート文字の一覧です。テンプレート文字は後に「長さ」を表す数字 を続けることができます。「長さ」の代わりに`*'とすることで「残り全て」 を表すこともできます。
長さの意味はテンプレート文字により異なりますが大抵、
"iiii"
のように連続するテンプレート文字は
"i4"
と書き換えることができます。
テンプレート文字列中の空白類は無視されます。 また、`#' から改行あるいはテンプレート文字列の最後まではコメントとみな され無視されます。
各テンプレート文字の説明の中で、 short や long はシステムによらずそれぞれ 2, 4バイトサ イズの数値(32ビットマシンで一般的なshort, longのサイズ)を意味していま す。s, S, l, L に対しては直後に _ または ! を "s_" あるいは "s!" のように 続けることでシステム依存の short, long のサイズにすることもできます。
i, I (int)のサイズは常にシステム依存であり、n, N, v, V のサイズは常にシステム依存ではない(!をつけられない)ことに注意してください。
つまり、IO#ioctl などで C の構造体を渡すときのように、 システム依存のサイズとエンディアンに合わせる必要があるときには s!, S!, i!, I!, l!, L!, q!, Q! を用います。 また、ネットワークプロトコルやファイルフォーマットのように、 システムに依存しないデータを扱うときには n, N, v, V を用います。
強制的にエンディアンを指定したいときは、 リトルエンディアンなら< ビッグエンディアンなら> を後ろにつけます。!と組み合わせることも可能です。
まとめると以下のようになります。
n: big endian unsigned 16bit N: big endian unsigned 32bit v: little endian unsigned 16bit V: little endian unsigned 32bit
s!: signed short S!: unsigned short i!: signed int I!: unsigned int l!: signed long L!: unsigned long q!: signed long long Q!: unsigned long long
s: int16_t S: uint16_t l: int32_t L: uint32_t
S>: big endian unsigned 16bit(nと同じ) s>: big endian int16_t s!>: big endian signed short l<: little endian int32_t l!<: little endian signed long
説明中、Array#pack と String#unpack で違いのあるものは `/' で区切って 「Array#pack の説明 / String#unpack の説明」としています。
ASCII文字列(null文字を詰める/後続するnull文字やスペースを残す)
["abc"].pack("a") # => "a"
["abc"].pack("a*") # => "abc"
["abc"].pack("a4") # => "abc\0"
"abc\0".unpack("a4") # => ["abc\0"]
"abc ".unpack("a4") # => ["abc "]
ASCII文字列(スペースを詰める/後続するnull文字やスペースを削除)
["abc"].pack("A") # => "a"
["abc"].pack("A*") # => "abc"
["abc"].pack("A4") # => "abc "
"abc ".unpack("A4") # => ["abc"]
"abc\0".unpack("A4") # => ["abc"]
null終端文字列(長さが`*'の場合も含め、null文字を詰める/後続するnull文字を削除)
["abc"].pack("Z") # => "a"
["abc"].pack("Z*") # => "abc\0"
["abc"].pack("Z4") # => "abc\0"
"abc\0".unpack("Z4") # => ["abc"]
"abc ".unpack("Z4") # => ["abc "]
ビットストリング(各バイトごとに下位ビットから上位ビット)
"\377\000".unpack("b*") # => ["1111111100000000"]
"\001\002".unpack("b*") # => ["1000000001000000"]
"\001\002".unpack("b3") # => ["100"]
["1000000001000000"].pack("b*") # => "\001\002"
ビットストリング(各バイトごとに上位ビットから下位ビット)
"\377\000".unpack("B*") # => ["1111111100000000"]
"\001\002".unpack("B*") # => ["0000000100000010"]
"\001\002".unpack("B9") # => ["000000010"]
"\001\002".unpack("B15") # => ["000000010000001"]
["0000000100000010"].pack("B*") # => "\001\002"
["0000000100000010"].pack("B0") # => ""
["0000000100000010"].pack("B1") # => "\000"
["0000000100000010"].pack("B7") # => "\000"
["0000000100000010"].pack("B8") # => "\001"
["0000000100000010"].pack("B9") # => "\001\000"
["0000000100000010"].pack("B14") # => "\001\000"
["0000000100000010"].pack("B15") # => "\001\002"
["0000000100000010"].pack("B16") # => "\001\002"
16進文字列(下位ニブルが先)
"\x01\xfe".unpack("h*") # => ["10ef"]
"\x01\xfe".unpack("h3") # => ["10e"]
["10ef"].pack("h*") # => "\001\376"
16進文字列(上位ニブルが先)
"\x01\xfe".unpack("H*") # => ["01fe"]
"\x01\xfe".unpack("H3") # => ["01f"]
"~".unpack("H2") # => ["7e"]
["01fe"].pack("H*") # => "\001\376"
["7e"].pack("H2") # => "~"
char (8bit 符号つき整数)
"\001\376".unpack("c*") # => [1, -2]
[1, -2].pack("c*") # => "\001\376"
[1, 254].pack("c*") # => "\001\376"
unsigned char (8bit 符号なし整数)
"\001\376".unpack("C*") # => [1, 254]
[1, -2].pack("C*") # => "\001\376"
[1, 254].pack("C*") # => "\001\376"
short (16bit 符号つき整数, エンディアンに依存) (s! は 16bit でなく、short のサイズに依存)
リトルエンディアン:
"\001\002\376\375".unpack("s*") # => [513, -514]
[513, 65022].pack("s*") # => "\001\002\376\375"
[513, -514].pack("s*") # => "\001\002\376\375"
ビッグエンディアン:
"\001\002\376\375".unpack("s*") # => [258, -259]
[258, 65277].pack("s*") # => "\001\002\376\375"
[258, -259].pack("s*") # => "\001\002\376\375"
unsigned short (16bit 符号なし整数, エンディアンに依存) (S! は 16bit でなく、short のサイズに依存)
リトルエンディアン:
"\001\002\376\375".unpack("S*") # => [513, 65022]
[513, 65022].pack("s*") # => "\001\002\376\375"
[513, -514].pack("s*") # => "\001\002\376\375"
ビッグエンディアン:
"\001\002\376\375".unpack("S*") # => [258, 65277]
[258, 65277].pack("S*") # => "\001\002\376\375"
[258, -259].pack("S*") # => "\001\002\376\375"
int (符号つき整数, エンディアンと int のサイズに依存)
リトルエンディアン, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("i*") # => [67305985, -50462977]
[67305985, 4244504319].pack("i*") # => RangeError
[67305985, -50462977].pack("i*") # => "\001\002\003\004\377\376\375\374"
ビッグエンディアン, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("i*") # => [16909060, -66052]
[16909060, 4294901244].pack("i*") # => RangeError
[16909060, -66052].pack("i*") # => "\001\002\003\004\377\376\375\374"
unsigned int (符号なし整数, エンディアンと int のサイズに依存)
リトルエンディアン, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("I*") # => [67305985, 4244504319]
[67305985, 4244504319].pack("I*") # => "\001\002\003\004\377\376\375\374"
[67305985, -50462977].pack("I*") # => "\001\002\003\004\377\376\375\374"
ビッグエンディアン, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("I*") # => [16909060, 4294901244]
[16909060, 4294901244].pack("I*") # => "\001\002\003\004\377\376\375\374"
[16909060, -66052].pack("I*") # => "\001\002\003\004\377\376\375\374"
long (32bit 符号つき整数, エンディアンに依存) (l! は 32bit でなく、long のサイズに依存)
リトルエンディアン, 32bit long:
"\001\002\003\004\377\376\375\374".unpack("l*") # => [67305985, -50462977]
[67305985, 4244504319].pack("l*") # => RangeError
[67305985, -50462977].pack("l*") # => "\001\002\003\004\377\376\375\374"
unsigned long (32bit 符号なし整数, エンディアンに依存) (L! は 32bit でなく、long のサイズに依存)
リトルエンディアン, 32bit long:
"\001\002\003\004\377\376\375\374".unpack("L*") # => [67305985, 4244504319]
[67305985, 4244504319].pack("L*") # => "\001\002\003\004\377\376\375\374"
[67305985, -50462977].pack("L*") # => "\001\002\003\004\377\376\375\374"
long long (符号付き整数, エンディアンと long long のサイズに依存) (C で long long が扱えない場合には 64bit)
リトルエンディアン, 64bit long long:
"\001\002\003\004\005\006\007\010\377\376\375\374\373\372\371\370".unpack("q*")
# => [578437695752307201, -506097522914230529]
[578437695752307201, -506097522914230529].pack("q*")
# => "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
[578437695752307201, 17940646550795321087].pack("q*")
# => "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
unsigned long long (符号なし整数, エンディアンと long long のサイズに依存) (C で long long が扱えない場合には 64bit)
リトルエンディアン, 64bit long long:
"\001\002\003\004\005\006\007\010\377\376\375\374\373\372\371\370".unpack("Q*")
# => [578437695752307201, 17940646550795321087]
[578437695752307201, 17940646550795321087].pack("Q*")
# => "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
[578437695752307201, -506097522914230529].pack("Q*")
# => "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
base64された文字列。60 オクテットごと(と最後)に改行コードが付加されます。
Base64は、3オクテット(8bits * 3 = 24bits)のバイナリコードをASCII文字の うちの65文字 ([A-Za-z0-9+/]の64文字とpaddingのための'=')だけを使用して 4オクテット(6bits * 4 = 24bits)の印字可能文字列に変換するエンコーディ ング法です。[RFC2045], [RFC4648] で定義されています。
[""].pack("m") # => ""
["\0"].pack("m") # => "AA==\n"
["\0\0"].pack("m") # => "AAA=\n"
["\0\0\0"].pack("m") # => "AAAA\n"
["\377"].pack("m") # => "/w==\n"
["\377\377"].pack("m") # => "//8=\n"
["\377\377\377"].pack("m") # => "////\n"
["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"].pack("m")
# => "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n"
["abcdefghijklmnopqrstuvwxyz"].pack("m3")
# => "YWJj\nZGVm\nZ2hp\namts\nbW5v\ncHFy\nc3R1\ndnd4\neXo=\n"
"".unpack("m") # => [""]
"AA==\n".unpack("m") # => ["\000"]
"AA==".unpack("m") # => ["\000"]
"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n".unpack("m")
# => ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==\n".unpack("m")
# => ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
m0 は [RFC4648] 対応
[""].pack("m0") # => ""
["\0"].pack("m0") # => "AA=="
["\0\0"].pack("m0") # => "AAA="
["\0\0\0"].pack("m0") # => "AAAA"
["\377"].pack("m0") # => "/w=="
["\377\377"].pack("m0") # => "//8="
["\377\377\377"].pack("m0") # => "////"
["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"].pack("m0")
# => "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg=="
"".unpack("m0") # => [""]
"AA==\n".unpack("m0") # => ArgumentError
"AA==".unpack("m0") # => ["\x00"]
"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==".unpack("m0")
# => ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
[SEE_ALSO] base64
quoted-printable encoding された文字列
["a b c\td \ne"].pack("M") # => "a b c\td =\n\ne=\n"
"a b c\td =\n\ne=\n".unpack("M") # => ["a b c\td \ne"]
ネットワークバイトオーダー(ビッグエンディアン)のunsigned short (16bit 符号なし整数)
[0,1,-1,32767,-32768,65535].pack("n*")
# => "\000\000\000\001\377\377\177\377\200\000\377\377"
"\000\000\000\001\377\377\177\377\200\000\377\377".unpack("n*")
# => [0, 1, 65535, 32767, 32768, 65535]
ネットワークバイトオーダー(ビッグエンディアン)のunsigned long (32bit 符号なし整数)
[0,1,-1].pack("N*") # => "\000\000\000\000\000\000\000\001\377\377\377\377"
"\000\000\000\000\000\000\000\001\377\377\377\377".unpack("N*") # => [0, 1, 4294967295]
"VAX"バイトオーダー(リトルエンディアン)のunsigned short (16bit 符号なし整数)
[0,1,-1,32767,-32768,65535].pack("v*")
# => "\000\000\001\000\377\377\377\177\000\200\377\377"
"\000\000\001\000\377\377\377\177\000\200\377\377".unpack("v*")
# => [0, 1, 65535, 32767, 32768, 65535]
"VAX"バイトオーダー(リトルエンディアン)のunsigned long (32bit 符号なし整数)
[0,1,-1].pack("V*") # => "\000\000\000\000\001\000\000\000\377\377\377\377"
"\000\000\000\000\001\000\000\000\377\377\377\377".unpack("V*") # => [0, 1, 4294967295]
単精度浮動小数点数(機種依存)
IA-32 (x86) (IEEE754 単精度 リトルエンディアン):
[1.0].pack("f") # => "\000\000\200?"
[0.0/0.0].pack("f") # => "\000\000\300\377" # NaN
[1.0/0.0].pack("f") # => "\000\000\200\177" # +Inf
[-1.0/0.0].pack("f") # => "\000\000\200\377" # -Inf
SPARC (IEEE754 単精度 ビッグエンディアン):
[1.0].pack("f") # => "?\200\000\000"
[0.0/0.0].pack("f") # => "\177\377\377\377" # NaN
[1.0/0.0].pack("f") # => "\177\200\000\000" # +Inf
[-1.0/0.0].pack("f") # => "\377\200\000\000" # -Inf
VAX (NetBSD 3.0) (非IEEE754):
[1.0].pack("f") # => "\200@\000\000"
倍精度浮動小数点数(機種依存)
IA-32 (IEEE754 倍精度 リトルエンディアン):
[1.0].pack("d") # => "\000\000\000\000\000\000\360?"
[0.0/0.0].pack("d") # => "\000\000\000\000\000\000\370\377" # NaN
[1.0/0.0].pack("d") # => "\000\000\000\000\000\000\360\177" # +Inf
[-1.0/0.0].pack("d") # => "\000\000\000\000\000\000\360\377" # -Inf
SPARC (IEEE754 倍精度 ビッグエンディアン):
[1.0].pack("d") # => "?\360\000\000\000\000\000\000"
[0.0/0.0].pack("d") # => "\177\377\377\377\377\377\377\377" # NaN
[1.0/0.0].pack("d") # => "\177\360\000\000\000\000\000\000" # +Inf
[-1.0/0.0].pack("d") # => "\377\360\000\000\000\000\000\000" # -Inf
VAX (NetBSD 3.0) (非IEEE754):
[1.0].pack("d") # => "\200@\000\000\000\000\000\000"
リトルエンディアンの単精度浮動小数点数(機種依存)
IA-32 (IEEE754):
[1.0].pack("e") # => "\000\000\200?"
SPARC (IEEE754):
[1.0].pack("e") # => "\000\000\200?"
リトルエンディアンの倍精度浮動小数点数(機種依存)
IA-32 (IEEE754):
[1.0].pack("E") # => "\000\000\000\000\000\000\360?"
SPARC (IEEE754):
[1.0].pack("E") # => "\000\000\000\000\000\000\360?"
ビッグエンディアンの単精度浮動小数点数(機種依存)
IA-32 (IEEE754):
[1.0].pack("g") # => "?\200\000\000"
SPARC (IEEE754):
[1.0].pack("g") # => "?\200\000\000"
IEEE754準拠な環境の場合、以下のようにして符号、指数部、仮数部を取り出せます。
s = [v].pack("g").unpack("B*")[0][0,1] # 符号
e = [v].pack("g").unpack("B*")[0][1,8] # 指数部
f = [v].pack("g").unpack("B*")[0][9,23] # 仮数部
そして、s, e, f の意味は以下の通りです。
sgn = s == "0" ? +1.0 : -1.0
exp = Integer("0b" + e)
fra = Integer("0b" + f)
if exp == 0
if fra == 0
sgn * 0 # ±0 (positive/negative zero)
else
sgn * fra * 2**(-126-23) # 非正規化数 (denormalized number)
end
elsif exp == 255
if fra == 0
sgn * Inf # ±∞ (positive/negative infinity)
else
NaN # 非数 (not a number)
end
else
fra += 1 << 23 # ゲタ
sgn * fra * 2**(exp-127-23) # 正規化数 (normalized number)
end
ビッグエンディアンの倍精度浮動小数点数(機種依存)
IA-32:
[1.0].pack("G") # => "?\360\000\000\000\000\000\000"
SPARC:
[1.0].pack("G") # => "?\360\000\000\000\000\000\000"
IEEE754準拠な環境の場合、以下のようにして符号、指数部、仮数部を取り出せます。
s = [v].pack("G").unpack("B*")[0][0,1] # 符号
e = [v].pack("G").unpack("B*")[0][1,11] # 指数部
f = [v].pack("G").unpack("B*")[0][12,52] # 仮数部
そして、s, e, f の意味は以下の通りです。
sgn = s == "0" ? +1.0 : -1.0
exp = Integer("0b" + e)
fra = Integer("0b" + f)
if exp == 0
if fra == 0
sgn * 0 # ±0 (positive/negative zero)
else
sgn * fra * 2**(-1022-52) # 非正規化数 (denormalized number)
end
elsif exp == 2047
if fra == 0
sgn * Inf # ±∞ (positive/negative infinity)
else
NaN # 非数 (not a number)
end
else
fra += 1 << 52 # ゲタ
sgn * fra * 2**(exp-1023-52) # 正規化数 (normalized number)
end
ナル終端の文字列へのポインタ
[""].pack("p") # => "\310\037\034\010"
["a", "b", "c"].pack("p3") # => " =\030\010\340^\030\010\360^\030\010"
[nil].pack("p") # => "\000\000\000\000"
構造体(固定長文字列)へのポインタ
[nil].pack("P") # => "\000\000\000\000"
["abc"].pack("P3") # => "x*\024\010"
["abc"].pack("P4") # => ArgumentError: too short buffer for P(3 for 4)
[""].pack("P") # => ArgumentError: too short buffer for P(0 for 1)
uuencodeされた文字列
[""].pack("u") # => ""
["a"].pack("u") # => "!80``\n"
["abc"].pack("u") # => "#86)C\n"
["abcd"].pack("u") # => "$86)C9```\n"
["a"*45].pack("u") # => "M86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A\n"
["a"*46].pack("u") # => "M86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A\n!80``\n"
["abcdefghi"].pack("u6") # => "&86)C9&5F\n#9VAI\n"
UTF-8
[0].pack("U") # => "\000"
[1].pack("U") # => "\001"
[0x7f].pack("U") # => "\177"
[0x80].pack("U") # => "\302\200"
[0x7fffffff].pack("U") # => "\375\277\277\277\277\277"
[0x80000000].pack("U") # => RangeError
[0,256,65536].pack("U3") # => "\000\304\200\360\220\200\200"
"\000\304\200\360\220\200\200".unpack("U3") # => [0, 256, 65536]
"\000\304\200\360\220\200\200".unpack("U") # => [0]
"\000\304\200\360\220\200\200".unpack("U*") # => [0, 256, 65536]
BER圧縮整数
1バイトあたり7ビットを使用して必要最小限のバイト数で任意サイズの 0以上の整数を表す数値表現。各バイトの最上位ビットはデータの最後 を除いて必ず1が立っている(つまり最上位ビットはどこまでデータがあ るかを示している)。
ISO/IEC 8825-1:1995 : Information technology−ASN.1 encoding rules : Specification of Basic Encoding Rules(BER) に定められる整数の符号化方法。
[0].pack("w") # => "\000"
[1].pack("w") # => "\001"
[127].pack("w") # => "\177"
[128].pack("w") # => "\201\000"
[0x3fff].pack("w") # => "\377\177"
[0x4000].pack("w") # => "\201\200\000"
[0x3fffffff].pack("w") # => "\203\377\377\377\177"
[0x40000000].pack("w") # => "\204\200\200\200\000"
[0xffffffff].pack("w") # => "\217\377\377\377\177"
[0x100000000].pack("w") # => "\220\200\200\200\000"
"\0".unpack("w") # => [0]
"\0\201\0\1".unpack("w*") # => [0, 128, 1]
なお、BER圧縮整数でエンコードした結果は大小関係を保存しない。 たとえば、[0x3fff].pack("w") > [0x4000].pack("w") である。
ナルバイト/1バイト読み飛ばす
[?a, ?b].pack("CxC") # => "a\000b"
[?a, ?b].pack("Cx3C") # => "a\000\000\000b"
"a\000b".unpack("CxC") # => [97, 98]
"a\377b".unpack("CxC") # => [97, 98]
"a\377b".unpack("Cx3C") # => ArgumentError: x outside of string
1バイト後退
[?a, ?b, ?c].pack("CCXC") # => "ac"
"abcdef".unpack("x*XC") # => [102]
絶対位置への移動
[?a, ?b].pack("C @3 C") # => "a\000\000b"
"a\000\000b".unpack("C @3 C") # => [97, 98]
以下、pack/unpack の使用例の一部です。
pack を使用しなくても同じことができる場合はその例も載せています。 pack は暗号になりやすい面があることを考慮し、pack を使いたくない人 に別解を示すためです。
[82, 117, 98, 121].pack("cccc") # => "Ruby"
[82, 117, 98, 121].pack("c4") # => "Ruby"
[82, 117, 98, 121].pack("c*") # => "Ruby"
s = ""
[82, 117, 98, 121].each {|c| s << c}
s # => "Ruby"
[82, 117, 98, 121].collect {|c| sprintf "%c", c}.join # => "Ruby"
[82, 117, 98, 121].inject("") {|s, c| s << c} # => "Ruby"
"Ruby".unpack('C*') # => [82, 117, 98, 121]
a = []
"Ruby".each_byte {|c| a << c}
a # => [82, 117, 98, 121]
[82, 117, 98, 121].pack("ccxxcc") # => "Ru\000\000by"
"Ru\0\0by".unpack('ccxxcc') # => [82, 117, 98, 121]
"61 62 63 64 65 66".delete(' ').to_a.pack('H*').unpack('C*')
# => [97, 98, 99, 100, 101, 102]
"61 62 63 64 65 66".split.collect {|c| c.hex}
# => [97, 98, 99, 100, 101, 102]
[0b01010010, 0b01110101, 0b01100010, 0b01111001].pack("C4")
# => "Ruby"
["01010010011101010110001001111001"].pack("B32") # 8 bits * 4
# => "Ruby"
[0x52, 0x75, 0x62, 0x79].pack("C4")
# => "Ruby"
["52756279"].pack("H8") # 2 nybbles * 4
# => "Ruby"
["RUBY", "u", "b", "y"].pack("a4")
# => "RUBY"
["RUBY", "u", "b", "y"].pack("aaaa")
# => "Ruby"
["RUBY", "u", "b", "y"].pack("a*aaa")
# => "RUBYuby"
["Ruby"].pack("a8")
# => "Ruby\000\000\000\000"
[1,2].pack("s2")
# => "\000\001\000\002" # ビッグエンディアンのシステムでの出力
# => "\001\000\002\000" # リトルエンディアンのシステムでの出力
[1,2].pack("n2")
# => "\000\001\000\002" # システムによらずビッグエンディアン
[1,2].pack("v2")
# => "\001\000\002\000" # システムによらずリトルエンディアン
s = "\xff\xff\xff\xfe"
n = s.unpack("N")[0]
if n[31] == 1
n = -((n ^ 0xffff_ffff) + 1)
end
n # => -2
s = "\xff\xff\xff\xfe"
n = s.unpack("N").pack("l").unpack("l")[0]
n # => -2
require 'socket'
Socket.gethostbyname("localhost")[3].unpack("C4").join(".")
# => "127.0.0.1"
"127.0.0.1".split(".").collect {|c| c.to_i}.pack("C4")
# => "\177\000\000\001"
require 'socket'
[Socket::AF_INET,
Socket.getservbyname('echo'),
127, 0, 0, 1].pack("s n C4 x8")
# => "\002\000\000\a\177\000\000\001\000\000\000\000\000\000\000\000"
pack/unpack を使う代わりに Socket.pack_sockaddr_in, Socket.unpack_sockaddr_in メソッドがあります。
テンプレート文字 "p" や "P" は、C 言語レベルのインタフェースのた めにあります(例えば IO#ioctl)。
["foo"].pack("p") # => "8\266\021\010"
結果の文字列はゴミに見えますが、実際は文字列"foo\0"を指すアドレ ス(のバイナリ表現)です。以下のようにすれば見慣れた表記で見ること が出来ます
printf "%#010x\n", "8\266\021\010".unpack("L")[0] # => 0x0811b638
アドレスが指す先のオブジェクト(この例で "foo\0") は、pack の結 果が GC されるまではGCされないことが保証されています。
unpack("p"), unpack("P") は、pack の結果からしか unpack できません。
["foo"].pack("p").unpack("p") # => ["foo"]
"8\266\021\010".unpack("p")
# => -:1:in `unpack': no associated pointer (ArgumentError)
# from -:1
"p" や "P" は、nil を特別に扱い NULL ポインタとして解釈します。(以下は、32bitマシンで一般的な結果)
[nil].pack("p") # => "\000\000\000\000"
"\0\0\0\0".unpack("p") # => [nil]
例えば、
struct {
int a;
short b;
long c;
} v = {1,2,3};
を表す文字列は
v = [1,2,3].pack("i!s!l!")
です。(byte alignment の問題から実際は適当な padding が必要に なるかもしれません)
この構造体を指すアドレスは
[v].pack("P") # => "\300\265\021\010"
で得られます。
Little endian:
("Comments").unpack("U*").pack("v*") # => "C\000o\000m\000m\000e\000n\000t\000s\000"
Big endian:
("Comments").unpack("U*").pack("n*") # => "\000C\000o\000m\000m\000e\000n\000t\000s"
upcase -> String[permalink][rdoc]'a' から 'z' までのアルファベット小文字を大文字に変換した文字列を作成して返します。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
例:
p "stRIng? STring.".upcase # => "STRING? STRING."
[SEE_ALSO] String#upcase!, String#downcase, String#swapcase, String#capitalize
upcase! -> self | nil[permalink][rdoc]ASCII 文字列の範囲内で 'a' から 'z' までの アルファベット小文字を全て大文字にします。 このメソッドは self を破壊的に変更して返しますが、 置換が起こらなかった場合は nil を返します。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
例:
buf = "stRIng? STring." buf.upcase! p buf # => "STRING? STRING."
[SEE_ALSO] String#upcase, String#downcase!, String#swapcase!, String#capitalize!
upto(max, exclusive = false) {|s| ... } -> self[permalink][rdoc]self から始めて max まで 「次の文字列」を順番にブロックに与えて繰り返します。 「次」の定義については String#succ を参照してください。
たとえば以下のコードは a, b, c, ... z, aa, ... az, ..., za を 出力します。
("a" .. "za").each do |str|
puts str
end
'a'.upto('za') do |str|
puts str
end
valid_encoding? -> bool[permalink][rdoc]文字列の内容が、現在のエンコーディングに照らしあわせて妥当であれば true を返します。さもなくば false を返します。