Ruby 1.9.2 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Stringクラス

class String

クラスの継承リスト: String < Comparable < Object < Kernel < BasicObject

要約

文字列のクラスです。 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   #=> "山本山"

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#== は両者のエンコーディングが等しくバイト列表現が等しい場合にのみ 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? は String#== の別名です。なので、ハッシュのキーに非 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

7bit クリーンな文字列

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`	string と同じ内容の新しい文字列を作成して返します。引数を省略した場合は空文字列を生成して返します。
`try_convert(obj) -> String \| nil`	obj を String に変換しようと試みます。変換には Object#to_str メソッドが使われます。変換後の文字列を返すか、何らかの理由により変換できなかった場合は nil が返されます。

インスタンスメソッド

定義	説明
`self % args -> String`	printf と同じ規則に従って args をフォーマットします。
`self * times -> String`	文字列の内容を times 回だけ繰り返した新しい文字列を作成して返します。
`self + other -> String`	文字列と other を連結した新しい文字列を返します。
`self << other -> self concat(other) -> self`	self に文字列 other を破壊的に連結します。 other が 0 から 255 のまでの整数である場合はその 1 バイトを末尾に追加します (つまり、整数が示す ASCII コードの文字が追加されます)。
`self <=> other -> Integer \| nil`	self と other を ASCII コード順で比較して、 self が大きい時には正の整数、等しい時には 0、小さい時には負の整数を返します。このメソッドは Comparable モジュールのメソッドを実装するために使われます。
`self == other -> bool`	文字列の内容が文字列 other の内容と等しいときに true を返します。等しくなければ false を返します。
`self =~ other -> Integer`	正規表現 other とのマッチを行います。マッチが成功すればマッチした位置のインデックスを、そうでなければ nil を返します。
`self[nth] -> Integer slice(nth) -> Integer`	nth 番目の文字を返します。 nth が負の場合は文字列の末尾から数えます。つまり、 self.size + nth 番目の文字を返します。
`self[nth, len] -> String \| nil slice(nth, len) -> String \| nil`	nth 文字目から長さ len 文字の部分文字列を新しく作って返します。 nth が負の場合は文字列の末尾から数えます。
`self[substr] -> String \| nil slice(substr) -> String \| nil`	self が substr を含む場合、一致した文字列を新しく作って返します。 substr を含まなければ nil を返します。
`self[regexp, nth = 0] -> String slice(regexp, nth = 0) -> String`	正規表現 regexp の nth 番目の括弧にマッチする最初の部分文字列を返します。 nth を省略したときや 0 の場合は正規表現がマッチした部分文字列全体を返します。正規表現が self にマッチしなかった場合や nth に対応する括弧がないときは nil を返します。
`self[range] -> String slice(range) -> String`	rangeで指定したインデックスの範囲に含まれる部分文字列を返します。
`self[nth] = val`	nth 番目の文字を文字列 val で置き換えます。
`self[nth, len] = val`	nth 番目の文字から len 文字の部分文字列を文字列 val で置き換えます。
`self[substr] = val`	文字列中の substr に一致する最初の部分文字列を文字列 val で置き換えます。
`self[regexp, nth] = val`	正規表現 regexp の nth 番目の括弧にマッチする最初の部分文字列を文字列 val で置き換えます。
`self[regexp] = val`	正規表現 regexp にマッチした部分文字列全体を val で置き換えます。
`self[range] = val`	rangeで指定したインデックスの範囲に含まれる部分文字列を文字列 val で置き換えます。
`ascii_only? -> bool`	文字列がASCII文字のみで構成されている場合に true を返します。さもなくば false を返します。
`each_byte {\|byte\| ... } -> self bytes {\|byte\| ... } -> self each_byte -> Enumerator bytes -> Enumerator`	文字列の各バイトに対して繰り返します。
`bytesize -> Integer`	文字列のバイト長を整数で返します。
`capitalize -> String`	文字列先頭の文字を大文字に、残りを小文字に変更した文字列を返します。ただし、アルファベット以外の文字は位置に関わらず変更しません。
`capitalize! -> self \| nil`	文字列先頭の文字を大文字に、残りを小文字に変更します。ただし、アルファベット以外の文字は位置に関わらず変更しません。
`casecmp(other) -> Integer \| nil`	String#<=> と同様に文字列の順序を比較しますが、アルファベットの大文字小文字の違いを無視します。
`center(width, padding = ' ') -> String`	長さ width の文字列に self を中央寄せした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。また、第 2 引数 padding を指定したときは空白文字の代わりに padding を詰めます。
`each_char {\|cstr\| block } -> self chars {\|cstr\| block } -> self each_char -> Enumerator chars -> Enumerator`	文字列の各文字に対して繰り返します。
`chomp(rs = $/) -> String`	self の末尾から rs で指定する改行コードを取り除いた文字列を生成し返します。ただし、rs が "\n" ($/ のデフォルト値) のときは、実行環境によらず "\r", "\r\n", "\n" のすべてを改行コードとみなして取り除きます。
`chomp!(rs = $/) -> self \| nil`	self の末尾から rs で指定する改行コードを取り除きます。ただし rs が "\n" ($/ のデフォルト値) のときは、システムによらず "\r", "\r\n", "\n" のすべてを改行コードとみなして取り除きます。
`chop -> String`	文字列の最後の文字を取り除いた新しい文字列を生成して返します。ただし、文字列の終端が "\r\n" であればその 2 文字を取り除きます。
`chop! -> self \| nil`	文字列の最後の文字を取り除きます。ただし、終端が "\r\n" であればその 2 文字を取り除きます。
`chr -> String`	self の最初の文字だけを含む文字列を返します。
`clear -> ()`	文字列の内容を削除して空にします。 self を返します。
`each_codepoint {\|codepoint\| block } -> self codepoints {\|codepoint\| block } -> self each_codepoint -> Enumerator codepoints -> Enumerator`	文字列の各コードポイントに対して繰り返します。
`count(*chars) -> Integer`	chars で指定された文字が文字列 self にいくつあるか数えます。
`crypt(salt) -> String`	self と salt から暗号化された文字列を生成して返します。 salt には英数字、ドット (「.」)、スラッシュ (「/」) から構成される、 2 バイト以上の文字列を指定します。
`delete(*strs) -> String`	self から strs に含まれる文字を取り除いた文字列を生成し返します。
`delete!(*strs) -> self \| nil`	self から strs に含まれる文字を破壊的に取り除きます。
`downcase -> String`	'A' から 'Z' までのアルファベット大文字をすべて小文字に置き換えた新しい文字列を生成し返します。アルファベット大文字以外の文字はすべてそのまま保存されます。
`downcase! -> self \| nil`	文字列中の 'A' から 'Z' までのアルファベット大文字をすべて破壊的に小文字に置き換えます。アルファベット大文字以外の文字はすべてそのまま保存されます。
`dump -> String`	文字列中の非表示文字をバックスラッシュ記法に置き換えた文字列を返します。 str == eval(str.dump) となることが保証されています。
`each_line(rs = $/) {\|line\| ... } -> () lines(rs = $/) {\|line\| ... } -> () each_line(rs = $/) -> Enumerator lines(rs = $/) -> Enumerator`	文字列中の各行に対して繰り返します。行の区切りは rs に指定した文字列で、そのデフォルト値は変数 $/ の値です。各 line には区切りの文字列も含みます。
`empty? -> bool`	文字列が空 (つまり長さ 0) の時、真を返します。
`encode(encoding, options = nil) -> String encode(encoding, from_encoding, options = nil) -> String encode(options = nil) -> String`	self を指定したエンコーディングに変換した文字列を作成して返します。引数を2つ与えた場合、第二引数は変換元のエンコーディングを意味します。さもなくば self のエンコーディングが使われます。無引数の場合は、Encoding.default_internal が nil でなければそれが変換先のエンコーディングになり、かつ :invalid => replace と :undef => replace が指定されたと見なされ、nil ならば変換は行われません。
`encode!(encoding, options = nil) -> self encode!(encoding, from_encoding, options = nil) -> self`	self を指定したエンコーディングに変換し、自身を置き換えます。引数を2つ与えた場合、第二引数は変換元のエンコーディングを意味します。さもなくば self のエンコーディングが使われます。変換後の self を返します。
`encoding -> Encoding`	文字列のエンコーディング情報を表現した Encoding オブジェクトを返します。
`end_with?(str) -> bool`	self の末尾が str であるとき true を返します。
`eql?(other) -> bool`	self == other と同じです。 Hash クラス内での比較に使われます。
`force_encoding(encoding) -> self`	文字列の持つエンコーディング情報を指定された encoding に変えます。
`gsub(pattern, replace) -> String`	文字列中で pattern にマッチする部分全てを文字列 replace で置き換えた文字列を生成し返します。
`gsub(pattern) {\|matched\| .... } -> String gsub(pattern) -> Enumerator`	文字列中で pattern にマッチした部分を順番にブロックに渡し、その実行結果で置き換えます。ブロックなしの場合と違い、ブロックの中からは組み込み変数 $1, $2, $3, ... を問題なく参照できます。
`gsub(pattern, hash) -> String`	文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
`gsub!(pattern, replace) -> self \| nil`	文字列中で pattern にマッチする部分全てを文字列 replace に破壊的に置き換えます。
`gsub!(pattern) {\|matched\| .... } -> self \| nil gsub!(pattern) -> Enumerator`	文字列中で pattern にマッチする部分全てを順番にブロックに渡し、その評価結果に置き換えます。
`gsub!(pattern, hash) -> self \| nil`	文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
`hash -> Integer`	self のハッシュ値を返します。 eql? で等しい文字列は、常にハッシュ値も等しくなります。
`hex -> Integer`	文字列に 16 進数で数値が表現されていると解釈して整数に変換します。接頭辞 "0x", "0X" とアンダースコアは無視されます。文字列が [_0-9a-fA-F] 以外の文字を含むときはその文字以降を無視します。
`include?(substr) -> bool`	文字列中に部分文字列 substr が含まれていれば真を返します。
`index(pattern, pos = 0) -> Integer`	インデックス pos から右に向かって pattern を検索し、最初に見つかった部分文字列の左端のインデックスを返します。見つからなければ nil を返します。
`insert(pos, other) -> ()`	nth 番目の文字の直前に文字列 other を挿入します。 self[pos, 0] = other と同じ操作です。
`inspect -> String`	文字列オブジェクトの内容を、出力したときに人間が読みやすいような適当な形式に変換します。変換された文字列は印字可能な文字のみによって構成されます
`intern -> Symbol to_sym -> Symbol`	文字列に対応するシンボル値 Symbol を返します。
`length -> Integer size -> Integer`	文字列の文字数を返します。バイト数を知りたいときは bytesize メソッドを使ってください。
`ljust(width, padding = ' ') -> String`	長さ width の文字列に self を左詰めした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。また、第 2 引数 padding を指定したときは空白文字の代わりに padding を詰めます。
`lstrip -> String`	文字列の先頭にある空白文字を全て取り除いた新しい文字列を返します。空白文字の定義は " \t\r\n\f\v" です。
`lstrip! -> self \| nil`	文字列の先頭にある空白文字を全て破壊的に取り除きます。空白文字の定義は " \t\r\n\f\v" です。
`match(regexp, pos = 0) -> MatchData`	regexp.match(self, pos) と同じです。 regexp が文字列の場合は、正規表現にコンパイルします。詳しくは Regexp#match を参照してください。
`succ -> String next -> String`	self の「次の」文字列を返します。
`succ! -> String next! -> String`	self を「次の」文字列に置き換えます。「次の」文字列は、アルファベットなら 16 進数、数字なら 10 進数とみなして計算されます。「次の」文字列の計算では "99" → "100" のように繰り上げも行われます。このとき負符号などは考慮されません。
`oct -> Integer`	文字列を 8 進文字列であると解釈して、整数に変換します。
`ord -> Integer`	文字列の最初の文字の文字コードを整数で返します。
`partition(sep) -> [String, String, String]`	セパレータ sep が最初に登場する部分で self を 3 つに分割し、 [最初のセパレータより前の部分, セパレータ, それ以降の部分] の 3 要素の配列を返します。
`replace(other) -> String`	self の内容を other の内容で置き換えます。
`reverse -> String`	文字列をバイト単位で左右逆転した文字列を返します。
`reverse! -> ()`	文字列をバイト単位で左右逆転します。
`rindex(pattern, pos = self.size) -> Integer \| nil`	文字列のインデックス pos から左に向かって pattern を探索します。見つかった部分文字列の左端のインデックスを返します。見つからなければ nil を返します。
`rjust(width, padding = ' ') -> String`	長さ width の文字列に self を右詰めした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。また、第 2 引数 padding を指定したときは空白文字の代わりに padding を詰めます。
`rpartition(sep) -> [String, String, String]`	セパレータ sep が最後に登場する部分で self を 3 つに分割し、 [最後のセパレータより前の部分, セパレータ, それ以降の部分] の 3 要素の配列を返します。
`rstrip -> String`	文字列の末尾にある空白文字を全て取り除いた新しい文字列を返します。空白文字の定義は " \t\r\n\f\v\0" です。
`rstrip! -> self \| nil`	文字列の末尾にある空白文字を全て破壊的に取り除きます。空白文字の定義は " \t\r\n\f\v\0" です。
`scan(re) -> [String] \| [[String]]`	self に対して正規表現 re を繰り返しマッチし、マッチした部分文字列の配列を返します。
`scan(re) {\|s\| ... } -> ()`	正規表現 re がマッチした部分文字列をブロックに渡して実行します。正規表現 re が括弧を含む場合は、括弧で括られたパターンにマッチした文字列の配列を渡します。
`slice!(nth) -> Integer slice!(pos, len) -> String slice!(substr) -> String slice!(regexp, nth = 0) -> String slice!(first..last) -> String slice!(first...last) -> String slice!(regexp, nth = 0) -> String`	指定した範囲 (String#[] 参照) を文字列から取り除いたうえで取り除いた部分文字列を返します。
`split(sep = $;, limit = 0) -> [String] \| [[String]]`	第 1 引数 sep で指定されたセパレータによって文字列を limit 個まで分割し、結果を文字列の配列で返します。
`squeeze(*chars) -> String`	chars に含まれる文字が複数並んでいたら 1 文字にまとめます。
`squeeze!(*chars) -> ()`	chars に含まれる文字が複数並んでいたら 1 文字にまとめます。
`start_with?(str) -> bool`	self の先頭が str であるとき true を返します。
`strip -> String`	文字列先頭と末尾の空白文字を全て取り除いた文字列を生成して返します。空白文字の定義は " \t\r\n\f\v" です。また、文字列右側からは "\0" も取り除きますが、左側の "\0" は取り除きません。
`strip! -> self \| nil`	先頭と末尾の空白文字を全て破壊的に取り除きます。空白文字の定義は " \t\r\n\f\v" です。また、文字列右側からは "\0" も取り除きますが、左側の "\0" は取り除きません。
`sub(pattern, replace) -> String`	文字列中で pattern にマッチした最初の部分を文字列 replace で置き換えた文字列を生成し返します。
`sub(pattern) {\|matched\| .... } -> String`	文字列中で pattern にマッチした最初の部分をブロックに渡し、その評価結果で置き換えた新しい文字列を返します。ブロックなしの sub と違い、ブロックの中からは組み込み変数 $1, $2, $3, ... を問題なく参照できます。
`sub(pattern, hash) -> String`	文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
`sub!(pattern, replace) -> self \| nil`	文字列中で pattern にマッチした最初の部分を文字列 replace へ破壊的に置き換えます。
`sub!(pattern) {\|matched\| .... } -> self \| nil`	文字列中で pattern にマッチした最初の部分をブロックに渡し、その評価結果へ破壊的に置き換えます。
`sub!(pattern, hash) -> String`	文字列中の pattern にマッチした部分をキーにして hash を引いた値で破壊的に置き換えます。
`sum(bits = 16) -> Integer`	文字列の bits ビットのチェックサムを計算します。以下と同じです。
`swapcase -> String`	'A' から 'Z' までのアルファベット大文字を小文字に、 'a' から 'z' までのアルファベット小文字を大文字に変更した文字列を返します。
`swapcase! -> self \| nil`	'A' から 'Z' までのアルファベット大文字を小文字に、 'a' から 'z' までのアルファベット小文字を大文字に、破壊的に変更します。
`to_f -> Float`	文字列を 10 進数表現と解釈して、浮動小数点数 Float に変換します。
`to_i(base = 10) -> Integer`	文字列を 10 進数表現された整数であると解釈して、整数に変換します。
`to_r -> Rational`	自身を有理数(Rational)に変換した結果を返します。
`to_s -> String to_str -> String`	self を返します。
`tr(pattern, replace) -> String`	pattern 文字列に含まれる文字を検索し、それを replace 文字列の対応する文字に置き換えます。
`tr!(pattern, replace) -> self \| nil`	pattern 文字列に含まれる文字を検索し、それを replace 文字列の対応する文字に破壊的に置き換えます。
`tr_s(pattern, replace) -> String`	文字列の中に pattern 文字列に含まれる文字が存在したら、 replace 文字列の対応する文字に置き換えます。さらに、置換した部分内に同一の文字の並びがあったらそれを 1 文字に圧縮します。
`tr_s!(pattern, replace) -> self \| nil`	文字列の中に pattern 文字列に含まれる文字が存在したら、 replace 文字列の対応する文字に置き換えます。さらに、置換した部分内に同一の文字の並びがあったらそれを 1 文字に圧縮します。
`unpack(template) -> Array`	Array#pack で生成された文字列をテンプレート文字列 template にしたがってアンパックし、それらの要素を含む配列を返します。
`upcase -> String`	'a' から 'z' までのアルファベット小文字を大文字に変換した文字列を作成し返します。
`upcase! -> self \| nil`	ASCII 文字列の範囲内で 'a' から 'z' までのアルファベット小文字を全て大文字にします。このメソッドは self を破壊的に変更して返しますが、置換が起こらなかった場合は nil を返します。
`upto(max, exclusive = false) {\|s\| ... } -> self`	self から始めて max まで「次の文字列」を順番にブロックに与えて繰り返します。「次」の定義については String#succ を参照してください。
`valid_encoding? -> bool`	文字列の内容が、現在のエンコーディングに照らしあわせて妥当であれば true を返します。さもなくば false を返します。

継承したメソッド

! != < <= > >= between? === __id__ __send__ _dump class clone dclone display enum_for equal? extend freeze frozen? initialize initialize_copy instance_eval instance_exec instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? marshal_dump marshal_load method method_missing methods must_be must_be_close_to must_be_empty must_be_instance_of must_be_kind_of must_be_nil must_be_same_as must_be_within_epsilon must_equal must_include must_match must_raise must_respond_to must_send must_throw nil? pretty_inspect pretty_print pretty_print_cycle pretty_print_inspect pretty_print_instance_variables private_methods protected_methods public_methods remove_instance_variable respond_to? respond_to_missing? singleton_class singleton_method_added singleton_method_removed singleton_method_undefined singleton_methods taint tainted? tap to_a to_ary to_hash to_int to_io to_proc to_regexp to_yaml to_yaml_properties to_yaml_style trust untaint untrust untrusted? wont_be wont_be_close_to wont_be_empty wont_be_instance_of wont_be_kind_of wont_be_nil wont_be_same_as wont_be_within_epsilon wont_equal wont_include wont_match wont_respond_to

追加されるメソッド

定義	説明	ライブラリ
`ext(newext = '') -> String`	自身の拡張子を与えられた拡張子で置き換えます。	rake
`is_binary_data?`		yaml
`is_complex_yaml?`		yaml
`iseuc -> bool`	self が EUC-JP なバイト列として正当であるかどうかを判定します。	kconv
`isjis -> bool`	self が ISO-2022-JP なバイト列として正当であるかどうかを判定します。	kconv
`issjis -> bool`	self が Shift_JIS なバイト列として正当であるかどうかを判定します。	kconv
`isutf8 -> bool`	self が UTF-8 なバイト列として正当であるかどうかを判定します。	kconv
`kconv(out_code, in_code = Kconv::AUTO) -> String`	self のエンコーディングを out_code に変換した文字列を返します。 out_code in_code は Kconv の定数で指定します。	kconv
`pathmap(spec = nil) { ... } -> String`	与えられた書式指定文字列に応じてパス(自身)を変換します。	rake
`pathmap_explode -> Array`	自身をパスを表す部分ごとに分解して配列にして返します。	rake
`pathmap_partial(n) -> String`	自身から与えられた階層分パスを抜粋します。	rake
`pathmap_replace(patterns) { ... } -> String`	与えられたパスを前もって置き換えます。	rake
`scanf(format) -> Array scanf(format) {\|*ary\| ...} -> Array`	ブロックを指定しない場合、見つかった文字列を format に従って変換し、そのオブジェクトの配列を返します。 format で指定した文字列が見つからない場合は空の配列を生成して返します。	scanf
`shellescape -> String`	文字列を Bourne シェルのコマンドライン中で安全に使えるようにエスケープします。	shellwords
`shellsplit -> [String]`	Bourne シェルの単語分割規則に従った空白区切りの単語分割を行い、単語 (文字列) の配列を返します。	shellwords
`to_d -> BigDecimal`	自身を BigDecimal に変換します。BigDecimal(self) と同じです。	bigdecimal/util
`toeuc -> String`	self のエンコーディングを EUC-JP に変換した文字列を返します。変換元のエンコーディングは文字列の内容から推測します。	kconv
`tojis -> String`	self のエンコーディングを iso-2022-jp に変換した文字列を返します。変換元のエンコーディングは文字列の内容から推測します。	kconv
`tolocale -> String`	self のエンコーディングをロケールエンコーディングに変換した文字列を返します。変換元のエンコーディングは文字列の内容から推測します。	kconv
`tosjis -> String`	self のエンコーディングを shift_jis に変換した文字列を返します。変換元のエンコーディングは文字列の内容から推測します。	kconv
`toutf16 -> String`	self のエンコーディングを UTF-16BE に変換した文字列を返します。変換元のエンコーディングは文字列の内容から推測します。	kconv
`toutf32 -> String`	self のエンコーディングを UTF-32 に変換した文字列を返します。変換元のエンコーディングは文字列の内容から推測します。	kconv
`toutf8 -> String`	self のエンコーディングを UTF-8 に変換した文字列を返します。変換元のエンコーディングは文字列の内容から推測します。	kconv