class Tk::BinaryString + Tk::EncodedString + String + Comparable + Object
クラスの継承リスト: Tk::BinaryString < Tk::EncodedString < String < Comparable < Object < Kernel < BasicObject
要約
特異メソッド
new(str, enc = nil)
-
[TODO]
new(string = "") -> String
-
string と同じ内容の新しい文字列を作成して返します。 引数を省略した場合は空文字列を生成して返します。
- [PARAM] string:
- 文字列
- [RETURN]
- 引数 string と同じ内容の文字列オブジェクト
new -> Object
-
Objectクラスのインスタンスを生成して返します。
some = Object.new p some #=> #<Object:0x2b696d8>
new_with_utf_backslash(str, enc = nil)
-
[TODO]
new_without_utf_backslash(str, enc = nil)
-
[TODO]
subst_tk_backslash(str)
-
[TODO]
subst_utf_backslash(str)
-
[TODO]
to_backslash_sequence(str)
-
[TODO]
try_convert(obj) -> String | nil
-
obj を String に変換しようと試みます。変換には Object#to_str メソッ ドが使われます。変換後の文字列を返すか、何らかの理由により変換できなかっ た場合は nil が返されます。
- [PARAM] obj:
- 変換する任意のオブジェクト
- [RETURN]
- 変換後の文字列または nil
String.try_convert("str") # => str String.try_convert(/re/) # => nil
utf_backslash(str)
-
[TODO]
utf_to_backslash(str)
-
[TODO]
utf_to_backslash_sequence(str)
-
[TODO]
インスタンスメソッド
self !~ other -> bool
-
自身が other とマッチしない事を判定します。
self#=~(obj) を反転した結果と同じ結果を返します。
- [PARAM] other:
- 判定するオブジェクトを指定します。
[SEE_ALSO] Object#=~
self % args -> String
-
printf と同じ規則に従って args をフォーマットします。
args が配列であれば Kernel.#sprintf(self, *args) と同じです。 それ以外の場合は Kernel.#sprintf(self, args) と同じです。
- [PARAM] args:
- フォーマットする値、もしくはその配列
- [RETURN]
- フォーマットされた文字列
例:
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"
sprintf フォーマット
Ruby の sprintf フォーマットは基本的に C 言語の sprintf(3) のものと同じです。ただし、short や long などの C 特有の型に対する修飾子が ないこと、2進数の指示子(%b)が存在すること、sprintf のすべての方言をサ ポートしていないこと(%': 3桁区切り)などの違いがあります。
Ruby には整数の大きさに上限がないので、%b, %o, %x に負の数を与えると (左側に無限に1が続くとみなせるので) ..f のような表示をします。絶対値に符号を付けた形式 で出力するためには %+x、% x のように指定します。
以下は sprintf フォーマットの書式です。[] で囲まれた部分は省略可 能であることを示しています。
%[引数指定$][フラグ][幅][.精度]指示子
`%' 自身を出力するには `%%' とします。
以下それぞれの要素に関して説明します。
フラグ
フラグには #, +, ' '(スペース), -, 0 の5種類があります。
- #
-
2進、8進、16進の指示子(b, o, x, X) ではそれぞれプレフィック スとして "0b", "0", "0x", "0X" を付加します。 C 言語とは異なり引数が 0 の場合にもプレフィックスが付加されます。
p sprintf("%#b", 10) #=> "0b1010" 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, o, x, X, u, f, e, E, g, G) に対してだけ意味を持ちます。 また、特に 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, 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
-
出力が右詰めの場合に余った部分に空白の代わりに "0" を詰めます。
数値の指示子の一部(d, i, 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", "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, 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"
指示子
指示子は引数の型の解釈を示します。指示子を省略することはできません。 指示子には大きく分けて
- 文字列を表す指示子: c, s, p
- 整数を表す指示子: d, i, u, b, o, x, X,
- 浮動小数点数を表す指示子: f, g, e, E, G
があります
- c
-
引数の数値(0〜255)を文字コードとみなして対応する文字を出力します。 引数が数値以外のオブジェクトの場合 to_int メソッドによる変換を試みます。 引数として範囲内の一文字の文字列も受けつけます。文字そのものを出力します。
p sprintf("%c", 97) #=> "a" p sprintf("%c", 'a') #=> "a"
フラグ `-' と幅 の指定だけが意味を持ちます。
- s
-
文字列を出力します。
引数が String オブジェクトでなければ to_s メソッドにより文字列化 したものを引数として扱います。
- p
-
Object#inspect の結果を出力します。
p sprintf("%s", /e+/) #=> "(?-mix:e+)" p sprintf("%p", /e+/) #=> "/e+/"
- d
- i
-
引数の数値を10進表現の整数として出力します。
引数が整数でなければ関数 Kernel.#Integer と同じ規則で整数に 変換されます。
p sprintf("%d", -1) #=> "-1" p sprintf("%d", 3.1) #=> "3" p sprintf("%d", '0b1010') #=> "10"
- u
-
引数の数値を符号なし整数とみなして10進表現の整数として出力します。
p sprintf("%u", '0b1010') #=> "10" p sprintf("%u", -1) #=> "-1"
- b
- o
- x
- X
-
整数をそれぞれ2進、8進、16進、16進(大文字)表現の文字列で出力します。
`#' フラグを指定すれば "0b", "0", "0x", "0X" を先頭に付加します。
`+', ` ' フラグがない場合、負の数には ".." が先頭(`#' フラグがあれば "0x" などの後)に付加されます。これは最上位桁の文字が無限に続くことを 意味し、2の補数表現で負の数を表しています。
p sprintf("%#b", 10) #=> "0b1010" p sprintf("%#o", 10) #=> "012" 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
- e
- E
- g
- G
- a
- A
-
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$
-
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"
self * times -> String
-
文字列の内容を times 回だけ繰り返した新しい文字列を作成して返します。
- [PARAM] times:
- 整数
- [RETURN]
- self を times 回繰り返した新しい文字列
- [EXCEPTION] ArgumentError:
- 引数に負数を指定したときに発生します。
例:
p "str" * 3 # => "strstrstr" str = "abc" p str * 4 # => "abcabcabcabc" p str * 0 # => "" p str # => "abc" (変化なし)
self + other -> String
-
文字列と other を連結した新しい文字列を返します。
- [PARAM] other:
- 文字列
- [RETURN]
- self と other を連結した文字列
例:
p "str" + "ing" # => "string" a = "abc" b = "def" p a + b # => "abcdef" p a # => "abc" (変化なし) p b # => "def"
self < other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が負の整数を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
self << other -> self
concat(other) -> self
-
self に文字列 other を破壊的に連結します。 other が 0 から 255 のまでの整数である場合は その 1 バイトを末尾に追加します (つまり、整数が示す ASCII コードの文字が追加されます)。
self を返します。
- [PARAM] other:
- 文字列もしくは 0 から 255 までの範囲の整数
例:
str = "string" str.concat "XXX" p str # => "stringXXX" str << "YYY" p str # => "stringXXXYYY" str << 65 # 文字AのASCIIコード p str # => "stringXXXYYYA"
self <= other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が負の整数か 0 を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
self <=> other -> -1 | 0 | 1 | nil
-
self と other を ASCII コード順で比較して、 self が大きい時には 1、等しい時には 0、小さい時には -1 を返します。 このメソッドは Comparable モジュールのメソッドを実装するために使われます。
変数 $= の値が真であるときは アルファベットの大文字小文字を無視して比較します。 ただし $= 変数はいずれ廃止されることが決まっているので $= に頼るべきではありません。 代わりに String#casecmp を使ってください。
other が文字列でない場合、 other.to_str と other.<=> が定義されていれば 0 - (other <=> self) の結果を返します。 そうでなければ nil を返します。
- [PARAM] other:
- 文字列
- [RETURN]
- 比較結果の整数か 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
self === other -> bool
-
文字列の内容が文字列 other の内容と等しいときに true を返します。 等しくなければ false を返します。
このメソッドは文字列の内容を比較します。 同一のオブジェクトかどうかを比較するわけではありません。 つまり、"string" == str という式を実行した場合には、 str が "string" という内容の文字列でありさえすれば常に true を返します。 同一のオブジェクトであるかどうかを判定したいときは Object#equal? を使ってください。
- [PARAM] other:
- 任意のオブジェクト
- [RETURN]
- true か false
例:
p "string" == "string" # => true p "string" == "STRING" # => false p "string" == "" # => false p "" == "string" # => false p "string" == "str" + "ing" # => true (内容が同じなら true) p "string" == "stringX".chop # => true (内容が同じなら true) p "string".upcase == "String".upcase # => true p "string".downcase == "String".downcase # => true
[SEE_ALSO] String#<=>, String#casecmp
self == other -> bool | nil
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が 0 を返した時に、true を返します。 それ以外を返した場合は、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
self == other -> bool
-
オブジェクトと other が等しければ真を返します。
このメソッドは各クラスの性質に合わせて再定義すべきです。 多くの場合、オブジェクトの内容が等しければ真を返すように (同値性を判定するように)再定義されることが期待されています。
デフォルトでは equal? と同じオブジェクト の同一性判定になっています。
- [PARAM] other:
- 比較するオブジェクトです。
p("foo" == "bar") #=> false p("foo" == "foo") #=> true p(4 == 4) #=> true p(4 == 4.0) #=> true
[SEE_ALSO] Object#equal?,Object#eql?
self === other -> bool
-
メソッド Object#== の別名です。 case 式で使用されます。このメソッドは case 式での振る舞いを考慮して、 各クラスの性質に合わせて再定義すべきです。
一般的に所属性のチェックを実現するため適宜再定義されます。
when 節の式をレシーバーとして === を呼び出すことに注意してください。
また Enumerable#grep でも使用されます。
- [PARAM] other:
- 比較するオブジェクトです。
age = 12 result = case age when 0 .. 2 "baby" when 3 .. 6 "little child" when 7 .. 12 "child" when 13 .. 18 "youth" else "adult" end puts result #=> "child" def check arg case arg when /ruby(?!\s*on\s*rails)/i "hit! #{arg}" when String "Instance of String class. But don't hit." else "unknown" end end puts check([]) #=> unknown puts check("mash-up in Ruby on Rails") #=> instance of String class. But not hit... puts check("<Ruby's world>") #=> hit! <Ruby's world>
[SEE_ALSO] Object#==, Range#===, Module#===, Enumerable#grep
self =~ other -> Integer
-
正規表現 other とのマッチを行います。 マッチが成功すればマッチした位置のインデックスを、そうでなければ nil を返します。
other が正規表現でも文字列でもない場合は other =~ self を行います。
このメソッドが実行されると、組み込み変数 $~, $1, ... にマッチに関する情報が設定されます。
- [PARAM] other:
- 正規表現もしくは =~ メソッドを持つオブジェクト
- [EXCEPTION] TypeError:
- other が文字列であった
例:
p "string" =~ /str/ # => 0 p "string" =~ /not/ # => nil p "abcfoo" =~ /foo/ # => 3
self =~ other -> nil
-
右辺に正規表現オブジェクトを置いた正規表現マッチ obj =~ /RE/ をサポートするためのメソッドです。 常に nil を返します。
この定義により、=~ が再定義されたオブジェクトでは正常にマッチを行い、 それ以外のものは nil を返すようになります。
- [PARAM] other:
- 任意のオブジェクトです。結果に影響しません。
obj = 'regexp' p(obj =~ /re/) #=> 0 obj = nil p(obj =~ /re/) #=> nil
[SEE_ALSO] String#=~
self > other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が正の整数を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
self >= other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が正の整数か 0 を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
self[nth] -> String | nil
slice(nth) -> String | nil
-
nth 番目の文字を返します。 nth が負の場合は文字列の末尾から数えます。 つまり、 self.size + nth 番目の文字を返します。
nth が範囲外を指す場合は nil を返します。
- [PARAM] nth:
- 文字の位置を表す整数
- [RETURN]
- 文字コードを表す整数
例:
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
slice(nth, len) -> String | nil
-
nth 文字目から長さ len 文字の部分文字列を新しく作って返します。 nth が負の場合は文字列の末尾から数えます。
- [PARAM] nth:
- 取得したい文字列の開始インデックスを整数で指定します。
- [PARAM] len:
- 取得したい文字列の長さを正の整数で指定します。
- [RETURN]
- nth が範囲外を指す場合は nil を返します。
例:
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
slice(substr) -> String | nil
-
self が substr を含む場合、一致した文字列を新しく作って返します。 substr を含まなければ nil を返します。
- [PARAM] substr:
- 取得したい文字列のパターン。文字列
例:
substr = "bar" result = "foobar"[substr] p result # => "bar" p substr.equal?(result) # => false
self[regexp, nth = 0] -> String
slice(regexp, nth = 0) -> String
-
正規表現 regexp の nth 番目の括弧にマッチする最初の部分文字列を返します。 nth を省略したときや 0 の場合は正規表現がマッチした部分文字列全体を返します。 正規表現が self にマッチしなかった場合や nth に対応する括弧がないときは nil を返します。
このメソッドを実行すると、 マッチ結果に関する情報が組み込み変数 $~ に設定されます。
- [PARAM] regexp:
- 取得したい文字列のパターンを示す正規表現
- [PARAM] nth:
- 取得したい正規表現レジスタのインデックス。整数
p "foobar"[/bar/] # => "bar" p $~.begin(0) # => 3 p "def getcnt(line)"[ /def\s+(\w+)/, 1 ] # => "getcnt"
self[regexp, name] -> String
slice(regexp, name) -> String
-
正規表現 regexp の name で指定した名前付きキャプチャにマッチする最初の 部分文字列を返します。正規表現が self にマッチしなかった場合は nil を返 します。
- [PARAM] regexp:
- 正規表現を指定します。
- [PARAM] name:
- 取得したい部分文字列のパターンを示す正規表現レジスタを示す名前
- [EXCEPTION] IndexError:
- name に対応する括弧がない場合に発生します。
例:
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
slice(range) -> String
-
rangeで指定したインデックスの範囲に含まれる部分文字列を返します。
- [PARAM] range:
- 取得したい文字列の範囲を示す Range オブジェクト
rangeオブジェクトが終端を含む場合
インデックスと文字列の対応については以下の対照図も参照してください。
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
rangeオブジェクトが終端を含まない場合
文字列と「隙間」の関係については以下の模式図を参照してください。
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
-
nth 番目の文字を文字列 val で置き換えます。
- [PARAM] nth:
- 置き換えたい文字の位置を指定します。
- [PARAM] val:
- 置き換える文字列を指定します。
- [RETURN]
- val を返します。
例:
buf = "string" buf[1] = "!!" p buf # => "s!!ring"
self[nth, len] = val
-
nth 番目の文字から len 文字の部分文字列を文字列 val で置き換えます。
len が0 の場合は、単にnthの位置から文字列の追加が行われます。 nth が負の場合は文字列の末尾から数えます。
- [PARAM] nth:
- 置き換えたい部分文字列の開始インデックス
- [PARAM] len:
- 置き換えたい部分文字列の長さ
- [PARAM] val:
- 指定範囲の部分文字列と置き換える文字列
- [RETURN]
- val を返します。
例:
buf = "string" buf[1, 4] = "!!" p buf # => "s!!g" buf = "string" buf[1, 0] = "!!" p buf # => "s!!tring"
self[substr] = val
-
文字列中の substr に一致する最初の部分文字列を文字列 val で置き換えます。
- [PARAM] substr:
- 置き換えたい部分文字列のパターンを示す文字列
- [PARAM] val:
- 指定範囲の部分文字列と置き換える文字列
- [RETURN]
- val を返します。
- [EXCEPTION] IndexError:
- self が部分文字列 substr を含まない場合に発生します。
例:
buf = "string" buf["trin"] = "!!" p buf # => "s!!g" buf = "string" buf["nosuchstring"] = "!!" # IndexError
self[regexp, nth] = val
-
正規表現 regexp の nth 番目の括弧にマッチする 最初の部分文字列を文字列 val で置き換えます。
nth が 0 の場合は、マッチした部分文字列全体を val で置き換えます。
- [PARAM] regexp:
- 置き換えたい部分文字列のパターンを示す正規表現
- [PARAM] nth:
- 置き換えたい部分文字列のパターンを示す正規表現レジスタの番号
- [PARAM] val:
- 指定範囲の部分文字列と置き換えたい文字列
- [RETURN]
- val を返します。
- [EXCEPTION] IndexError:
- 正規表現がマッチしなかった場合に発生します。
例:
buf = "def exec(cmd)" buf[/def\s+(\w+)/, 1] = "preprocess" p buf # => "def preprocess(cmd)"
self[regexp, name] = val
-
正規表現 regexp の name で指定した名前付きキャプチャにマッチする最初の 部分文字列を文字列 val で置き換えます。
- [PARAM] regexp:
- 置き換えたい部分文字列のパターンを示す正規表現
- [PARAM] name:
- 置き換えたい部分文字列のパターンを示す正規表現レジスタを示す名前
- [PARAM] val:
- 指定範囲の部分文字列と置き換えたい文字列
- [RETURN]
- val を返します。
- [EXCEPTION] IndexError:
- name で指定した名前付きキャプチャが存在しない場合に発 生します。
例:
s = "FooBar" s[/(?<foo>[A-Z]..)(?<bar>[A-Z]..)/, "foo"] = "Baz" p s # => "BazBar"
self[regexp] = val
-
正規表現 regexp にマッチした部分文字列全体を val で置き換えます。
- [PARAM] regexp:
- 置き換えたい部分文字列のパターンを示す正規表現
- [PARAM] val:
- 置き換えたい文字列
- [RETURN]
- val を返します。
- [EXCEPTION] IndexError:
- 正規表現がマッチしなかった場合に発生します。
例:
buf = "string" buf[/tr../] = "!!" p buf # => "s!!g"
self[range] = val
-
rangeで指定したインデックスの範囲に含まれる部分文字列を文字列 val で置き換えます。
- [PARAM] range:
- 置き換えたい範囲を示す Range オブジェクト
- [RETURN]
- val を返します。
send(name, *args) -> object
send(name, *args) { .... } -> object
__send__(name, *args) -> object
__send__(name, *args) { .... } -> object
-
オブジェクトのメソッド name を args を引数に して呼び出し、メソッドの実行結果を返します。
ブロック付きで呼ばれたときはブロックもそのまま引き渡します。
send が再定義された場合に備えて別名 __send__ も 用意されており、ライブラリではこちらを使うべきです。また __send__ は再定義すべきではありません。
send, __send__ は、メソッドの呼び出し制限 にかかわらず任意のメソッドを呼び出せます。 クラス/メソッドの定義/呼び出し制限 も参照してください。
- [PARAM] name:
- 文字列かSymbol で指定するメソッド名です。
- [PARAM] args:
- 呼び出すメソッドに渡す引数です。
p -365.send(:abs) #=> 365 p "ruby".send(:sub,/./,"R") #=> "Ruby" class Foo def foo() "foo" end def bar() "bar" end def baz() "baz" end end # 任意のキーとメソッド(の名前)の関係をハッシュに保持しておく # レシーバの情報がここにはないことに注意 methods = {1 => :foo, 2 => :bar, 3 => :baz} # キーを使って関連するメソッドを呼び出す # レシーバは任意(Foo クラスのインスタンスである必要もない) p Foo.new.send(methods[1]) # => "foo" p Foo.new.send(methods[2]) # => "bar" p Foo.new.send(methods[3]) # => "baz"
[SEE_ALSO] Object#method, Kernel.#eval, Proc, Method
_dump(limit) -> String
-
Marshal.#dump において出力するオブジェクトがメソッド _dump を定義している場合には、そのメソッドの結果が書き出されます。
バージョン1.8.0以降ではObject#marshal_dump, Object#marshal_loadの使用 が推奨されます。 Marshal.dump するオブジェクトが _dump と marshal_dump の両方の メソッドを持つ場合は marshal_dump が優先されます。
メソッド _dump は引数として再帰を制限するレベル limit を受 け取り、オブジェクトを文字列化したものを返します。
インスタンスがメソッド _dump を持つクラスは必ず同じフォー マットを読み戻すクラスメソッド _load を定義する必要があり ます。_load はオブジェクトを表現した文字列を受け取り、それ をオブジェクトに戻したものを返す必要があります。
- [PARAM] limit:
- 再帰の制限レベルを表す整数です。
- [RETURN]
- オブジェクトを文字列化したものを返すように定義すべきです。
class Foo def initialize(arg) @foo = arg end def _dump(limit) Marshal.dump(@foo, limit) end def self._load(obj) p obj Foo.new(Marshal.load(obj)) end end foo = Foo.new(['foo', 'bar']) p foo #=> #<Foo:0xbaf234 @foo=["foo", "bar"]> dms = Marshal.dump(foo) p dms #=> "\004\bu:\bFoo\023\004\b[\a\"\bfoo\"\bbar" result = Marshal.load(dms) #=> "\004\b[\a\"\bfoo\"\bbar" # self._load の引数 p result #=> #<Foo:0xbaf07c @foo=["foo", "bar"]>
インスタンス変数の情報は普通マーシャルデータに含まれるので、上例 のように _dump を定義する必要はありません(ただし _dump を定義すると インスタンス変数の情報は dump されなくなります)。 _dump/_load はより高度な制御を行いたい場合や拡張ライブラリで定義し たクラスのインスタンスがインスタンス変数以外に情報を保持する場合に 利用します。(例えば、クラス Time は、_dump/_load を定義して います)
[SEE_ALSO] Object#marshal_dump,Object#marshal_load
ascii_only? -> bool
-
文字列がASCII文字のみで構成されている場合に true を返します。さもなくば false を返します。
between?(min, max) -> bool
-
比較演算子 <=> をもとに self が min と max の範囲内(min, max を含みます)にあるかを判断します。
以下のコードと同じです。
self >= min and self <= max
- [PARAM] min:
- 範囲の下端を表すオブジェクトを指定します。
- [PARAM] max:
- 範囲の上端を表すオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- self <=> min か、self <=> max が nil を返 したときに発生します。
3.between?(1, 5) #=> true 6.between?(1, 5) #=> false 'cat'.between?('ant', 'dog') #=> true 'gnu'.between?('ant', 'dog') #=> false
each_byte {|byte| ... } -> self
bytes {|byte| ... } -> self
each_byte -> Enumerator
bytes -> Enumerator
-
文字列の各バイトに対して繰り返します。
例:
"str".each_byte do |byte| p byte end # => 115 # => 116 # => 114
[SEE_ALSO] String#unpack
bytesize -> Integer
-
文字列のバイト長を整数で返します。
例:
#coding:UTF-8 # 実行結果は文字コードによって異なります。 p "いろは".size #=> 3 p "いろは".bytesize #=> 9
[SEE_ALSO] String#size
byteslice(nth) -> String | nil
-
nth バイト目の文字を返します。nth が負の場合は文字列の末尾から数えます。 引数が範囲外を指定した場合は nil を返します。
- [PARAM] nth:
- 文字の位置を表す整数を指定します。
- [RETURN]
- 切り出した文字列を返します。戻り値の文字エンコーディングは自身 と同じです。
"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
-
nth バイト目から長さ len バイトの部分文字列を新しく作って返します。 nth が負の場合は文字列の末尾から数えます。引数が範囲外を指定した場合は nil を返します。
- [PARAM] nth:
- 取得したい文字列の開始バイトを整数で指定します。
- [PARAM] len:
- 取得したい文字列の長さを正の整数で指定します。
- [RETURN]
- 切り出した文字列を返します。戻り値の文字エンコーディングは自身 と同じです。
"hello".byteslice(1, 2) # => "el" "\u3042\u3044\u3046".byteslice(0, 3) # => "\u3042"
[SEE_ALSO] String#slice
byteslice(range) -> String | nil
-
range で指定したバイトの範囲に含まれる部分文字列を返します。引数が範囲 外を指定した場合は nil を返します。
- [PARAM] range:
- 取得したい文字列の範囲を示す Range オブジェクト
- [RETURN]
- 切り出した文字列を返します。戻り値の文字エンコーディングは自身 と同じです。
"hello".byteslice(1..2) # => "el" "\x03\u3042\xff".byteslice(1..3) # => "\u3042"
[SEE_ALSO] String#slice
capitalize -> String
-
文字列先頭の文字を大文字に、残りを小文字に変更した文字列を返します。 ただし、アルファベット以外の文字は位置に関わらず変更しません。
例:
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
-
文字列先頭の文字を大文字に、残りを小文字に変更します。 ただし、アルファベット以外の文字は位置に関わらず変更しません。
- [RETURN]
- capitalize! は self を変更して返しますが、 変更が起こらなかった場合は nil を返します。
例:
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
-
String#<=> と同様に文字列の順序を比較しますが、 アルファベットの大文字小文字の違いを無視します。
このメソッドの動作は組み込み変数 $= には影響されません。
- [PARAM] other:
- self と比較する文字列
例:
p 'a' <=> 'A' # => 1 p 'a'.casecmp('A') # => 0
[SEE_ALSO] String#<=>
center(width, padding = ' ') -> String
-
長さ width の文字列に self を中央寄せした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。 また、第 2 引数 padding を指定したときは 空白文字の代わりに padding を詰めます。
- [PARAM] width:
- 返り値の文字列の最小の長さ
- [PARAM] padding:
- 長さが width になるまで self の両側に詰める文字
例:
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
each_char {|cstr| block } -> self
chars {|cstr| block } -> self
each_char -> Enumerator
chars -> Enumerator
-
文字列の各文字に対して繰り返します。
たとえば、
"hello世界".each_char {|c| print c, ' ' }
は次のように出力されます。
h e l l o 世 界
chomp(rs = $/) -> String
-
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
-
self の末尾から rs で指定する改行コードを取り除きます。 ただし rs が "\n" ($/ のデフォルト値) のときは、 システムによらず "\r", "\r\n", "\n" のすべてを改行コードとみなして取り除きます。
rs に nil を指定した場合、このメソッドは何もしません。
rs に空文字列 ("") を指定した場合は「パラグラフモード」になり、 末尾の連続する改行コードをすべて取り除きます。
- [RETURN]
- chomp! は通常 self を返しますが、取り除く改行がなかった場合は nil を返します。
例:
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
-
文字列の最後の文字を取り除いた新しい文字列を生成して返します。 ただし、文字列の終端が "\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
-
文字列の最後の文字を取り除きます。 ただし、終端が "\r\n" であればその 2 文字を取り除きます。
- [RETURN]
- chop! は self を変更して返しますが、取り除く文字がなかった場合は nil を返します。
chr -> String
-
self の最初の文字だけを含む文字列を返します。
[SEE_ALSO] String#ord, Integer#chr
class -> Class
-
レシーバのクラスを返します。
p "ruby".class #=> String p 999999999999999.class #=> Bignum p ARGV.class #=> Array p self.class #=> Object p Class.class #=> Class p Kernel.class #=> Module
[SEE_ALSO] Class#superclass,Object#kind_of?,Object#instance_of?
clear -> ()
-
文字列の内容を削除して空にします。 self を返します。
例:
str = "abc" str.clear p str # => "" str = "" str.clear p str # => ""
clone -> object
dup -> object
-
オブジェクトの複製を作成して返します。
dup はオブジェクトの内容, taint 情報をコピーし、 clone はそれに加えて freeze, 特異メソッドなどの情報も含めた完全な複製を作成します。
clone や dup は浅い(shallow)コピーであることに注意してください。後述。
- [EXCEPTION] TypeError:
- TrueClass, FalseClass, NilClass, Symbol, そして Numeric クラスのインスタンスなど一部の オブジェクトを複製しようとすると発生します。
obj = "string" obj.taint def obj.fuga end obj.freeze p(obj.equal?(obj)) #=> true p(obj == obj) #=> true p(obj.tainted?) #=> true p(obj.frozen?) #=> true p(obj.respond_to?(:fuga)) #=> true obj_c = obj.clone p(obj.equal?(obj_c)) #=> false p(obj == obj_c) #=> true p(obj_c.tainted?) #=> true p(obj_c.frozen?) #=> true p(obj_c.respond_to?(:fuga)) #=> true obj_d = obj.dup p(obj.equal?(obj_d)) #=> false p(obj == obj_d) #=> true p(obj_d.tainted?) #=> true p(obj_d.frozen?) #=> false p(obj_d.respond_to?(:fuga)) #=> false
[SEE_ALSO] Object#initialize_copy
深いコピーと浅いコピー
clone や dup はオブジェクト自身を複製するだけで、オブジェクトの指し ている先(たとえば配列の要素など)までは複製しません。これを浅いコピー(shallow copy)といいます。
深い(deep)コピーが必要な場合には、 Marshalモジュールを利用して
Marshal.load(Marshal.dump(obj))
このように複製を作成する方法があります。ただしMarshal出来ないオブジェクトが 含まれている場合には使えません。
obj = ["a","b","c"] obj_d = obj.dup obj_d[0] << "PLUS" p obj #=> ["aPLUS", "b", "c"] p obj_d #=> ["aPLUS", "b", "c"] obj_m = Marshal.load(Marshal.dump(obj)) obj_m[1] << "PLUS" p obj #=> ["aPLUS", "b", "c"] p obj_m #=> ["aPLUS", "bPLUS", "c"]
each_codepoint {|codepoint| block } -> self
codepoints {|codepoint| block } -> self
each_codepoint -> Enumerator
codepoints -> Enumerator
-
文字列の各コードポイントに対して繰り返します。
#coding:UTF-8 "hello わーるど".codepoints.to_a # => [104, 101, 108, 108, 111, 32, 12431, 12540, 12427, 12393]
count(*chars) -> Integer
-
chars で指定された文字が文字列 self にいくつあるか数えます。
検索する文字を示す引数 chars の形式は tr(1) と同じです。 つまり、「"a-c"」は文字 a から c を意味し、 「"^0-9"」のように文字列の先頭が「^」の場合は 指定文字以外を意味します。
文字「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、「^」も文字列の先頭にあるときだけ否定の効果を発揮します。 また、「-」「^」「\」は バックスラッシュ (「\」) によりエスケープできます。
引数を複数指定した場合は、 すべての引数にマッチした文字だけを数えます。
- [PARAM] chars:
- 出現回数を数える文字のパターン
例:
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
-
self と salt から暗号化された文字列を生成して返します。 salt には英数字、ドット (「.」)、スラッシュ (「/」) から構成される、 2 バイト以上の文字列を指定します。
暗号化された文字列から暗号化前の文字列 (self) を求めることは一般に困難で、 self を知っている者のみが同じ暗号化された文字列を生成できます。 このことから self を知っているかどうかの認証に使うことが出来ます。
salt には、以下の様になるべくランダムな文字列を選ぶべきです。 他にも [ruby-list:29297] などがあります。
注意:
- crypt の処理は crypt(3) の実装に依存しています。 従って、crypt で処理される内容の詳細や salt の与え方については、 利用環境の crypt(3) 等を見て確認してください。
- crypt の結果は利用環境が異なると変わる場合があります。 crypt の結果を、異なる利用環境間で使用する場合には注意して下さい。
- 典型的な DES を使用した crypt(3) の場合、 self の最初の 8 バイト、salt の最初の 2 バイトだけが使用されます。
- [PARAM] salt:
- 文字列を暗号化するための鍵となる文字列。 英数字・「.」・「/」のいずれかで構成される 2 バイト以上の文字列
例:
# パスワードの暗号化 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
-
self から strs に含まれる文字を取り除いた文字列を生成し返します。
str の形式は tr(1) と同じです。 つまり、`a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外を意味します。
「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 「^」も文字列の先頭にあるときだけ効果を発揮します。 また、「-」「^」「\」はバックスラッシュ (「\」) によってエスケープできます。
なお、引数を複数指定した場合は、 すべての引数にマッチする文字だけが削除されます。
- [PARAM] strs:
- 削除する文字列を示す文字列 (のリスト)
例:
p "123456789".delete("2378") #=> "14569" p "123456789".delete("2-8", "^4-6") #=> "14569"
delete!(*strs) -> self | nil
-
self から strs に含まれる文字を破壊的に取り除きます。
str の形式は tr(1) と同じです。 つまり、「a-c」は a から c を意味し、"^0-9" のように 文字列の先頭が「^」の場合は指定文字以外を意味します。
「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 「^」も文字列先頭にあるときだけ否定の効果を発揮します。 また、「-」「^」「\」はバックスラッシュ (「\」) によってエスケープできます。
なお、引数を複数指定した場合は、 すべての引数にマッチする文字だけが削除されます。
- [RETURN]
- 通常は self を返しますが、何も変更が起こらなかった場合は nil を返します。
- [PARAM] strs:
- 削除する文字列を示す文字列 (のリスト)
例:
p "123456789".delete("2-8", "^4-6") #=> "14569" p "123456789".delete("2378") #=> "14569"
display(out = $stdout) -> nil
-
オブジェクトを out に出力します。
以下のように定義されています。
class Object def display(out = $stdout) out.print self.to_s nil end end
- [PARAM] out:
- 出力先のIOオブジェクトです。指定しない場合は標準出力に出力されます。
- [RETURN]
- nil を返します。
Object.new.display #=> #<Object:0xbb0210>
[SEE_ALSO] $stdout
downcase -> String
-
'A' から 'Z' までの アルファベット大文字をすべて小文字に置き換えた新しい文字列を生成し返します。 アルファベット大文字以外の文字はすべてそのまま保存されます。
このメソッドはマルチバイト文字を認識しません。 例:
p "STRing?".downcase # => "string?"
[SEE_ALSO] String#upcase, String#swapcase, String#capitalize
downcase! -> self | nil
-
文字列中の 'A' から 'Z' までの アルファベット大文字をすべて破壊的に小文字に置き換えます。 アルファベット大文字以外の文字はすべてそのまま保存されます。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
- [RETURN]
- self を変更して返します。変更が無かった場合は nil を返します。
例:
p "STRing?".downcase # => "string?"
[SEE_ALSO] String#upcase, String#swapcase, String#capitalize
dump -> String
-
文字列中の非表示文字をバックスラッシュ記法に置き換えた文字列を返します。 str == eval(str.dump) となることが保証されています。
例:
# p だとさらにバックスラッシュが増えて見にくいので puts している puts "abc\r\n\f\x00\b10\\\"".dump # => "abc\r\n\f\000\01010\\\""
each_line(rs = $/) {|line| ... } -> ()
lines(rs = $/) {|line| ... } -> ()
each_line(rs = $/) -> Enumerator
lines(rs = $/) -> Enumerator
-
文字列中の各行に対して繰り返します。 行の区切りは rs に指定した文字列で、 そのデフォルト値は変数 $/ の値です。 各 line には区切りの文字列も含みます。
rs に nil を指定すると行区切りなしとみなします。 rs に空文字列 "" を指定すると「パラグラフモード」になり、 改行コードが 2 つ以上連続するところで文字列を分割します (つまり空行で分割します)。
- [PARAM] rs:
- 行末を示す文字列
例:
"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"]
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 ならば変換は行われません。
- [PARAM] encoding:
- 変換先のエンコーディングを表す文字列か Encoding オブジェクトを指定します。
- [PARAM] from_encoding:
- 変換元のエンコーディングを表す文字列か Encoding オブジェクトを指定します。
- [PARAM] option:
- 変換オプションをハッシュで与えます。
- [RETURN]
- 変換された文字列
変換オプション
- :invalid => nil
-
変換元のエンコーディングにおいて不正なバイトがあった場合に、例外 Encoding::InvalidByteSequenceError を投げます。(デフォルト)
- :invalid => :replace
-
変換元のエンコーディングにおいて不正なバイトがあった場合に、不正なバイトを置換文字で置き換えます。
- :undef => nil
-
変換先のエンコーディングにおいて文字が定義されていない場合に、例外 Encoding::UndefinedConversionError を投げます。(デフォルト)
- :undef => :replace
-
変換先のエンコーディングにおいて文字が定義されていない場合に、未定義文字を置換文字で置き換えます。
- :replace => string
-
前述の :invalid => :replace や :undef => :replace で用いられる置換文字を指定します。デフォルトは Unicode 系のエンコーディングならば U+FFFD、それ以外では "?" です。
- :xml => :text
-
文字列を XML の CharData として適するように処理します。具体的には、'&'、'<'、'>'、をそれぞれ '&'、'<'、'>' に変換し、未定義文字を文字参照 (大文字16進数) に置き換えます。この出力は HTML の #PCDATA として利用することもできます。
- :xml => :attr
-
文字列を XML の AttValue として適するように処理します。具体的には、'&'、'<'、'>'、'"'、をそれぞれ '&'、'<'、'>'、'"' に変換し、未定義文字を文字参照 (大文字16進数) に置き換えます。この出力は HTML の属性値として利用することもできます。
- :universal_newline => true
-
CR 改行および CRLF 改行を LF 改行に置き換えます。
- :cr_newline => true
-
LF 改行を CR 改行に置き換えます。(CRLF は CRCR になります)
- :crlf_newline => true
-
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
encode!(encoding, from_encoding, options = nil) -> self
-
self を指定したエンコーディングに変換し、自身を置き換えます。引数を2つ 与えた場合、第二引数は変換元のエンコーディングを意味します。さもなくば self のエンコーディングが使われます。変換後の self を返します。
(gsub!などと異なり)変換が行なわれなくても self を返します。
- [PARAM] encoding:
- 変換先のエンコーディングを表す文字列か Encoding オブジェクトを指定します。
- [PARAM] from_encoding:
- 変換元のエンコーディングを表す文字列か Encoding オブジェクトを指定します。
- [RETURN]
- 変換後のself
例:
#coding:UTF-8 s = "いろは" s.encode!("EUC-JP") s.encode!(Encoding::UTF_8)
[SEE_ALSO] String#encode
encoding
-
[TODO]
encoding -> Encoding
-
文字列のエンコーディング情報を表現した Encoding オブジェクトを返します。
[SEE_ALSO] Encoding
end_with?(str) -> bool
-
self の末尾が str であるとき true を返します。
- [PARAM] str:
- パターンを表す文字列
例:
"string".end_with?("ing") # => true "string".end_with?("str") # => false
[SEE_ALSO] String#start_with?
to_enum(method = :each, *args) -> Enumerator
enum_for(method = :each, *args) -> Enumerator
-
Enumerator.new(self, method, *args) を返します。
- [PARAM] method:
- メソッド名の文字列かシンボルです。
- [PARAM] args:
- 呼び出すメソッドに渡される引数です。
- [EXCEPTION] NameError:
- 存在しないメソッド名を指定すると発生します。
str = "xyz" enum = str.enum_for(:each_byte) p(a = enum.map{|b| '%02x' % b }) #=> ["78", "79", "7a"] # protects an array from being modified a = [1, 2, 3] p(a.to_enum) #=> #<Enumerator: [1, 2, 3]:each>
[SEE_ALSO] Enumerator
eql?(other) -> bool
-
self == other と同じです。 Hash クラス内での比較に使われます。
[SEE_ALSO] Hash
eql?(other) -> bool
-
オブジェクトと other が等しければ真を返します。Hash で二つのキー が等しいかどうかを判定するのに使われます。
このメソッドは各クラスの性質に合わせて再定義すべきです。 多くの場合、 == と同様に同値性の判定をするように再定義されていますが、 適切にキー判定ができるようにより厳しくなっている場合もあります。
デフォルトでは equal? と同じオブジェクト の同一性判定になっています。
このメソッドを再定義した時には Object#hash メソッ ドも再定義しなければなりません。
- [PARAM] other:
- 比較するオブジェクトです。
p("foo".eql?("bar")) #=> false p("foo".eql?("foo")) #=> true p(4.eql?(4)) #=> true p(4.eql?(4.0)) #=> false
[SEE_ALSO] Object#hash,Object#equal?,Object#==
equal?(other) -> bool
-
other が self 自身の時、真を返します。
二つのオブジェクトが同一のものかどうか調べる時に使用します。 このメソッドを再定義してはいけません。
お互いのObject#object_idが一致する かどうかを調べます。
- [PARAM] other:
- 比較するオブジェクトです。
p("foo".equal?("bar")) #=> false p("foo".equal?("foo")) #=> false p(4.equal?(4)) #=> true p(4.equal?(4.0)) #=> false p(:foo.equal? :foo) #=> true
[SEE_ALSO] Object#object_id,Object#==,Object#eql?,Symbol
extend(*modules) -> self
-
引数で指定したモジュールのインスタンスメソッドを self の特異 メソッドとして追加します。
Module#include は、クラス(のインスタンス)に機能を追加します が、extend は、ある特定のオブジェクトだけにモジュールの機能を追加 したいときに使用します。
引数に複数のモジュールを指定した場合、最後 の引数から逆順に extend を行います。
- [PARAM] modules:
- モジュールを任意個指定します(クラスは不可)。
- [RETURN]
- self を返します。
module Foo def a 'ok Foo' end end module Bar def b 'ok Bar' end end obj = Object.new obj.extend Foo, Bar p obj.a #=> "ok Foo" p obj.b #=> "ok Bar" class Klass include Foo extend Bar end p Klass.new.a #=> "ok Foo" p Klass.b #=> "ok Bar"
extend の機能は、「特異クラスに対する Module#include」 と言い替えることもできます。 ただしその場合、フック用のメソッド が Module#extended ではなく Module#included になるという違いがあります。
# obj.extend Foo, Bar とほぼ同じ class << obj include Foo, Bar end
[SEE_ALSO] Module#extend_object,Module#include,Module#extended
force_encoding(encoding) -> self
-
文字列の持つエンコーディング情報を指定された encoding に変えます。
このとき実際のエンコーディングは変換されず、検査もされません。 Array#pack などで得られたバイト列のエンコーディングを指定する時に使います。
- [PARAM] encoding:
- 変更するエンコーディング情報を表す文字列か Encoding オブジェクトを指定します。
例:
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") #=> "ほへと"
freeze -> self
-
オブジェクトを凍結(内容の変更を禁止)します。
凍結されたオブジェクトの変更は 例外 RuntimeError を発生させます。 いったん凍結されたオブジェクトを元に戻す方法はありません。
凍結されるのはオブジェクトであり、変数ではありません。代入などで変数の指す オブジェクトが変化してしまうことは freeze では防げません。 freeze が防ぐのは、 `破壊的な操作' と呼ばれるもの一般です。変数への参照自体を凍結したい 場合は、グローバル変数なら Kernel.#trace_var が使えます。
- [RETURN]
- self を返します。
a1 = "foo".freeze a1 = "bar" p a1 #=> "bar" a2 = "foo".freeze a2.replace("bar")# can't modify frozen string (RuntimeError)
凍結を解除することはできませんが、Object#dup を使えばほぼ同じ内容の凍結されていない オブジェクトを得ることはできます。
a = [1].freeze p a.frozen? #=> true a[0] = "foo" p a # can't modify frozen array (RuntimeError) b = a.dup p b #=> [1] p b.frozen? #=> false b[0] = "foo" p b #=> ["foo"]
[SEE_ALSO] Object#frozen?,Object#dup,Kernel.#trace_var
frozen? -> bool
-
オブジェクトが凍結(内容の変更を禁止)されているときに真を返します。
obj = "someone" p obj.frozen? #=> false obj.freeze p obj.frozen? #=> true
[SEE_ALSO] Object#freeze
getbyte(index) -> Integer | nil
-
index バイト目のバイトを整数で返します。
index に負を指定すると末尾から数えた位置のバイト を取り出します。 範囲外を指定した場合は nil を返します。
- [PARAM] index:
- バイトを取り出す位置
gsub(pattern, replace) -> String
-
文字列中で pattern にマッチする部分全てを 文字列 replace で置き換えた文字列を生成し返します。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
- [PARAM] replace:
- pattern で指定した文字列と置き換える文字列
例:
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
gsub(pattern) -> Enumerator
-
文字列中で pattern にマッチした部分を順番にブロックに渡し、 その実行結果で置き換えます。 ブロックなしの場合と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
- [RETURN]
- 置換した場合は self、置換しなかった場合は nil
例:
p 'abcabc'.gsub(/[bc]/) {|s| s.upcase } #=> "aBCaBC" p 'abcabc'.gsub(/[bc]/) { $&.upcase } #=> "aBCaBC"
[SEE_ALSO] String#sub
gsub(pattern, hash) -> String
-
文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
- [PARAM] pattern:
- 置き換える文字列のパターン
- [PARAM] hash:
- 置き換える文字列を与えるハッシュ
hash = {'b'=>'B', 'c'=>'C'} p "abcabc".gsub(/[bc]/){hash[$&]} #=> "aBCaBC" p "abcabc".gsub(/[bc]/, hash) #=> "aBCaBC"
gsub!(pattern, replace) -> self | nil
-
文字列中で pattern にマッチする部分全てを文字列 replace に破壊的に置き換えます。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
gsub! は通常 self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
- [PARAM] replace:
- pattern で指定した文字列と置き換える文字列
- [RETURN]
- 置換した場合は 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
gsub!(pattern) -> Enumerator
-
文字列中で pattern にマッチする部分全てを順番にブロックに渡し、 その評価結果に置き換えます。
また、ブロックなしの場合と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
- [RETURN]
- 置換した場合は self、置換しなかった場合は nil
例:
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
-
文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
- [PARAM] pattern:
- 置き換える文字列のパターン
- [PARAM] hash:
- 置き換える文字列を与えるハッシュ
hash = {'b'=>'B', 'c'=>'C'} p "abcabc".gsub(/[bc]/){hash[$&]} #=> "aBCaBC" p "abcabc".gsub(/[bc]/, hash) #=> "aBCaBC"
hash -> Integer
-
self のハッシュ値を返します。 eql? で等しい文字列は、常にハッシュ値も等しくなります。
[SEE_ALSO] Hash
hash -> Fixnum
-
オブジェクトのハッシュ値を返します。Hash クラスでオブジェク トを格納するのに用いられています。
メソッド hash は Object#eql? と組み合わせて Hash クラスで利用されます。その際
A.eql?(B) ならば A.hash == B.hash
の関係を必ず満たしていなければいけません。eql? を再定義した時には必ずこちらも合わせ て再定義してください。
デフォルトでは、Object#object_id と同じ値を返します。 ただし、Fixnum, Symbol, String だけは組込みのハッ シュ関数が使用されます(これを変えることはできません)。
hash を再定義する場合は、一様に分布する任意の整数を返すようにします。
- [RETURN]
- ハッシュ値を返します。Fixnumに収まらない場合は切り捨てられます。
p self.hash #=> 21658870 p 0.hash #=> 1 p 0.0.hash #=> 0 p nil.hash #=> 4 p "ruby".hash #=> -241670986 p "ruby".hash #=> -241670986 p :ruby.hash #=> 103538 p :ruby.hash #=> 103538
[SEE_ALSO] Object#eql?,BasicObject#__id__
hex -> Integer
-
文字列に 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
-
文字列中に部分文字列 substr が含まれていれば真を返します。
- [PARAM] substr:
- 検索する文字列
index(pattern, pos = 0) -> Integer
-
インデックス pos から右に向かって pattern を検索し、 最初に見つかった部分文字列の左端のインデックスを返します。 見つからなければ nil を返します。
引数 pattern は探索する部分文字列、 正規表現、文字コードを示す 0 から 255 の整数のいずれかで指定します。
pos が負の場合、文字列の末尾から数えた位置から探索します。
- [PARAM] pattern:
- 探索する部分文字列、正規表現、文字コードを示す 0 から 255 の整数
- [PARAM] 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) -> ()
-
pos 番目の文字の直前に文字列 other を挿入します。 self[pos, 0] = other と同じ操作です。
- [PARAM] pos:
- 文字列を挿入するインデックス
- [PARAM] other:
- 挿入する文字列
例:
str = "foobaz" str.insert(3, "bar") p str # => "foobarbaz"
[SEE_ALSO] String#[]=
inspect -> String
-
文字列オブジェクトの内容を、出力したときに人間が読みやすいような適当な形式に変換します。 変換された文字列は印字可能な文字のみによって構成されます
現在の実装では、Ruby のリテラル形式を使って、 文字列中の不可視文字をエスケープシーケンスに変換します。
このメソッドは主にデバッグのために用意されています。 永続化などの目的で文字列をダンプしたいときは、 String#dump を使うべきです。
例:
# p ではないことに注意 puts "string".inspect # => "string" puts "\t\r\n".inspect # => "\t\r\n"
[SEE_ALSO] String#dump
inspect -> String
-
オブジェクトを人間が読める形式に変換した文字列を返します。
組み込み関数 Kernel.#p は、このメソッドの結果を使用して オブジェクトを表示します。
puts Class.new.inspect #=> #<Class:0xbafd88> puts Time.now.inspect #=> 2007-10-15 21:01:37 +0900
[SEE_ALSO] Kernel.#p
instance_of?(klass) -> bool
-
オブジェクトがクラス klass の直接のインスタンスである時真を返します。
obj.instance_of?(c) が成立する時には、常に obj.kind_of?(c) も成立します。
- [PARAM] klass:
- Classかそのサブクラスのインスタンスです。
class C < Object end class S < C end obj = S.new p obj.instance_of?(S) # true p obj.instance_of?(C) # false
[SEE_ALSO] Object#kind_of?,Object#class
instance_variable_defined?(var) -> bool
-
インスタンス変数 var が定義されていたら真を返します。
- [PARAM] var:
- インスタンス変数名を文字列か Symbol で指定します。
class Fred def initialize(p1, p2) @a, @b = p1, p2 end end fred = Fred.new('cat', 99) p fred.instance_variable_defined?(:@a) #=> true p fred.instance_variable_defined?("@b") #=> true p fred.instance_variable_defined?("@c") #=> false
[SEE_ALSO] Object#instance_variable_get,Object#instance_variable_set,Object#instance_variables
instance_variable_get(var) -> object|nil
-
オブジェクトのインスタンス変数の値を取得して返します。
インスタンス変数が定義されていなければ nil を返します。
- [PARAM] var:
- インスタンス変数名を文字列か Symbol で指定します。
class Foo def initialize @foo = 1 end end obj = Foo.new p obj.instance_variable_get("@foo") #=> 1 p obj.instance_variable_get(:@foo) #=> 1 p obj.instance_variable_get(:@bar) #=> nil
[SEE_ALSO] Object#instance_variable_set,Object#instance_variables,Object#instance_variable_defined?
instance_variable_set(var, value) -> object
-
オブジェクトのインスタンス変数 var に値 value を設定します。
インスタンス変数が定義されていなければ新たに定義されます。
- [PARAM] var:
- インスタンス変数名を文字列か Symbol で指定します。
- [PARAM] value:
- 設定する値です。
- [RETURN]
- value を返します。
obj = Object.new p obj.instance_variable_set("@foo", 1) #=> 1 p obj.instance_variable_set(:@foo, 2) #=> 2 p obj.instance_variable_get(:@foo) #=> 2
[SEE_ALSO] Object#instance_variable_get,Object#instance_variables,Object#instance_variable_defined?
instance_variables -> [Symbol]
-
オブジェクトのインスタンス変数名をシンボルの配列として返します。
obj = Object.new obj.instance_eval { @foo, @bar = nil } p obj.instance_variables #=> [:@foo, :@bar]
[SEE_ALSO] Object#instance_variable_get,Kernel.#local_variables,Kernel.#global_variables,Module.constants,Module#constants,Module#class_variables
intern -> Symbol
to_sym -> Symbol
-
文字列に対応するシンボル値 Symbol を返します。
なお、このメソッドの逆にシンボルに対応する文字列を得るには Symbol#to_s または Symbol#id2name を使います。
Ruby 1.9 以降では、シンボル文字列にナルキャラクタ("\0")、空の文字列が使用可能になりました。
例:
p "foo".intern # => :foo p "foo".intern.to_s == "foo" # => true
is_a?(mod) -> bool
kind_of?(mod) -> bool
-
オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。
また、オブジェクトがモジュール mod をインクルードしたクラスかそのサブクラス のインスタンスである場合にも真を返します。 上記のいずれでもない場合に false を返します。
- [PARAM] mod:
- クラスやモジュールなど、Moduleかそのサブクラスのインスタンスです。
module M end class C < Object include M end class S < C end obj = S.new p obj.is_a?(S) # true p obj.is_a?(C) # true p obj.is_a?(Object) # true p obj.is_a?(M) # true p obj.is_a?(Hash) # false
[SEE_ALSO] Object#instance_of?,Module#===,Object#class
length -> Integer
size -> Integer
-
文字列の文字数を返します。バイト数を知りたいときは bytesize メソッドを使ってください。
[SEE_ALSO] String#bytesize
ljust(width, padding = ' ') -> String
-
長さ width の文字列に self を左詰めした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。 また、第 2 引数 padding を指定したときは 空白文字の代わりに padding を詰めます。
- [PARAM] width:
- 返り値の文字列の最小の長さ
- [PARAM] padding:
- 長さが width になるまで self の右側に詰める文字
例:
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
-
文字列の先頭にある空白文字を全て取り除いた新しい文字列を返します。 空白文字の定義は " \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
-
文字列の先頭にある空白文字を全て破壊的に取り除きます。 空白文字の定義は " \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"
marshal_dump -> object
-
Marshal.#dump を制御するメソッドです。
Marshal.dump(some) において、出力するオブジェクト some がメソッド marshal_dump を 持つ場合には、その返り値がダンプされたものが Marshal.dump(some) の返り値となります。
marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。 これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。
- [RETURN]
- 任意のオブジェクトで marshal_load の引数に利用できます。
class Foo def initialize(arg) @foo = arg end def marshal_dump @foo end def marshal_load(obj) p obj @foo = obj end end foo = Foo.new(['foo', 'bar']) p foo #=> #<Foo:0xbaf3b0 @foo=["foo", "bar"]> dms = Marshal.dump(foo) p dms #=> "\004\bU:\bFoo[\a\"\bfoo\"\bbar" result = Marshal.load(dms) #=> ["foo", "bar"] # marshal_load の引数 p result #=> #<Foo:0xbaf2ac @foo=["foo", "bar"]>
インスタンス変数の情報は普通マーシャルデータに含まれるので、 上例のように marshal_dump を定義する必要はありません (ただし marshal_dump を定義するとインスタンス変数の情報は ダンプされなくなるので、marshal_dump/marshal_load で扱う必要があります)。 marshal_dump/marshal_load はより高度な制御を行いたい場合や 拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外 に情報を保持する場合に利用します。
特に、marshal_dump/marshal_load を定義したオブジェクトは 特異メソッドが定義されていてもマーシャルできるようになります (特異メソッドの情報が自動的に dump されるようになるわけではなく、 marshal_dump/marshal_load によりそれを実現する余地があるということです)。
[SEE_ALSO] Object#marshal_load, Marshal
marshal_load(obj) -> object
-
Marshal.#load を制御するメソッドです。
some のダンプ結果(Marshal.dump(some)) をロードする(Marshal.load(Marshal.dump(some)))に は some がメソッド marshal_load を持っていなければなりません。 このとき、marshal_dump の返り値が marshal_load の引数に利用されます。 marshal_load 時の self は、生成されたばかり(Class#allocate されたばかり) の状態です。
marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。 これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。
- [PARAM] obj:
- marshal_dump の返り値のコピーです。
- [RETURN]
- 返り値は無視されます。
[SEE_ALSO] Object#marshal_dump, Marshal
match(regexp, pos = 0) -> MatchData
-
regexp.match(self, pos) と同じです。 regexp が文字列の場合は、正規表現にコンパイルします。 詳しくは Regexp#match を参照してください。
method(name) -> Method
-
オブジェクトのメソッド name をオブジェクト化した Method オブジェクトを返します。
me = -365.method(:abs) p me #=> #<Method: Fixnum#abs> p me.call #=> 365
[SEE_ALSO] Module#instance_method,Method,Object#__send__,Kernel.#eval
methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトに対して呼び出せるメソッド名の一覧を返します。 このメソッドは public メソッドおよび protected メソッドの名前を返します。
ただし特別に、引数が偽の時は Object#singleton_methods(false) と同じになっています。
- [PARAM] include_inherited:
- 引数が偽の時は Object#singleton_methods(false) と同じになります。
#例1: class Parent private; def private_parent() end protected; def protected_parent() end public; def public_parent() end end class Foo < Parent private; def private_foo() end protected; def protected_foo() end public; def public_foo() end end obj = Foo.new class <<obj private; def private_singleton() end protected; def protected_singleton() end public; def public_singleton() end end # あるオブジェクトの応答できるメソッドの一覧を得る。 p obj.methods(false) p obj.public_methods(false) p obj.private_methods(false) p obj.protected_methods(false) #実行結果 [:protected_singleton, :public_singleton] [:public_singleton, :public_foo] [:private_singleton, :private_foo] [:protected_singleton, :protected_foo] #例2: # あるオブジェクトの応答できるメソッドの一覧を得る。 # 自身のクラスの親クラスのインスタンスメソッドも含めるために true を指定して # いるが、Object のインスタンスメソッドは一覧から排除している。 p obj.methods(true) - Object.instance_methods(true) p obj.public_methods(true) - Object.public_instance_methods(true) p obj.private_methods(true) - Object.private_instance_methods(true) p obj.protected_methods(true) - Object.protected_instance_methods(true) #実行結果 [:protected_singleton, :public_singleton, :protected_foo, :public_foo, :protected_parent, :public_parent] [:public_singleton, :public_foo, :public_parent] [:private_singleton, :private_foo, :private_parent] [:protected_singleton, :protected_foo, :protected_parent]
[SEE_ALSO] Module#instance_methods,Object#singleton_methods
succ -> String
next -> String
-
self の「次の」文字列を返します。
「次の」文字列は、対象の文字列の右端から アルファベットなら アルファベット順(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
next! -> String
-
self を「次の」文字列に置き換えます。 「次の」文字列は、アルファベットなら 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
nil? -> bool
-
レシーバが nil であれば真を返します。
p false.nil? #=> false p nil.nil? #=> true
[SEE_ALSO] NilClass
object_id -> Integer
-
各オブジェクトに対して一意な整数を返します。あるオブジェクトに対し てどのような整数が割り当てられるかは不定です。
Rubyでは、(Garbage Collectされていない)アクティブなオブジェクト間で 重複しない整数(object_id)が各オブジェクトにひとつずつ割り当てられています。この メソッドはその値を返します。
TrueClass, FalseClass, NilClass, Symbol, Fixnum クラス のインスタンスなど Immutable(変更不可)なオブジェクトの一部は同じ内容ならば必ず同じ object_id になります。
これは、Immutable ならば複数の場所から参照されても`破壊的操作'による問題が発生しないので、 同じ内容のインスタンスを複数生成しないという内部実装が理由です。
p "ruby".object_id #=> 22759500 p "ruby".object_id #=> 22759400 p [].object_id #=> 22759360 p [].object_id #=> 22759340 p :ruby.object_id #=> 103538 p :ruby.object_id #=> 103538 p 11.object_id #=> 23 p 11.object_id #=> 23 p true.object_id #=> 2 p true.object_id #=> 2
[SEE_ALSO] Object#equal?,Symbol
oct -> Integer
-
文字列を 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
-
文字列の最初の文字の文字コードを整数で返します。
self が空文字列のときは例外 TypeError を発生します。
- [RETURN]
- 文字コードを表す整数
- [EXCEPTION] TypeError:
- self の長さが 0 のとき発生
例:
p "a".ord # => 97
[SEE_ALSO] Integer#chr, String#chr
partition(sep) -> [String, String, String]
-
セパレータ sep が最初に登場する部分で self を 3 つに分割し、 [最初のセパレータより前の部分, セパレータ, それ以降の部分] の 3 要素の配列を返します。
self がセパレータを含まないときは、 返り値の第 2 要素と第 3 要素が空文字列になります。
- [PARAM] sep:
- セパレータを表す文字列か正規表現を指定します。
例:
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
-
文字列 other_str を先頭に破壊的に追加します。
- [PARAM] other_str:
- 追加したい文字列を指定します。
例:
a = "world" a.prepend("hello ") # => "hello world" a # => "hello world"
private_methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトが理解できる private メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#private_instance_methods,Object#methods,Object#singleton_methods
protected_methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトが理解できる protected メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#protected_instance_methods,Object#methods,Object#singleton_methods
public_methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトが理解できる public メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#public_instance_methods,Object#methods,Object#singleton_methods
public_send(name, *args) -> object
-
オブジェクトの public メソッド name を args を引数にして呼び出し、メソッ ドの実行結果を返します。
1.public_send(:+, 2) # => 3
- [PARAM] name:
- 文字列かSymbol で指定するメソッド名です。
- [PARAM] args:
- 呼び出すメソッドに渡す引数です。
- [EXCEPTION] ArgumentError:
- name を指定しなかった場合に発生します。
- [EXCEPTION] NoMethodError:
- protected メソッドや private メソッドに対して実行 した場合に発生します。
1.public_send(:puts, "hello") # => NoMethodError
[SEE_ALSO] Object#send
replace(other) -> String
-
self の内容を other の内容で置き換えます。
例:
str = "foo" str.replace "bar" p str # => "bar"
respond_to?(name, include_private = false) -> bool
-
オブジェクトがメソッド name を持つとき真を返します。
オブジェクトが メソッド name を持つというのは、 オブジェクトが メソッド name に応答することができることをいいます。
- [PARAM] name:
- Symbol または文字列で指定するメソッド名です。
- [PARAM] include_private:
- private メソッドを確認の対象に含めるかを true か false で指定します。省略した場合は false(含めな い) を指定した事になります。
class F def hello "Bonjour" end end class D private def hello "Guten Tag" end end list = [F.new,D.new] list.each{|it| puts it.hello if it.respond_to?(:hello)} #=> Bonjour list.each{|it| it.instance_eval("puts hello if it.respond_to?(:hello, true)")} #=> Bonjour # Guten Tag
[SEE_ALSO] Module#method_defined?
respond_to_missing?(symbol, include_private) -> bool
-
自身が symbol で表されるメソッドに対し BasicObject#method_missing で反応するつもりならば真を返します。
Object#respond_to? はメソッドが定義されていない場合、 デフォルトでこのメソッドを呼びだし問合せます。
BasicObject#method_missing を override した場合にこのメソッドも override されるべきです。
false を返します。
- [PARAM] symbol:
- メソッド名シンボル
- [PARAM] include_private:
- private method も含めたい場合に true が渡されます
[SEE_ALSO] Object#respond_to?, BasicObject#method_missing
reverse -> String
-
文字列を文字単位で左右逆転した文字列を返します。
例:
p "foobar".reverse # => "raboof" p "".reverse # => ""
reverse! -> ()
-
文字列を文字単位で左右逆転します。
例:
str = "foobar" str.reverse! p str # => "raboof"
rindex(pattern, pos = self.size) -> Integer | nil
-
文字列のインデックス pos から左に向かって pattern を探索します。 見つかった部分文字列の左端のインデックスを返します。 見つからなければ nil を返します。
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 # 左にずらしていってここで見つかる
- [PARAM] pattern:
- 探索する部分文字列。 文字列、正規表現、文字コードを示す 0 から 255 の整数のいずれか
- [PARAM] pos:
- 探索を始めるインデックス
例:
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
-
長さ width の文字列に self を右詰めした文字列を返します。 self の長さが width より長い時には元の文字列の複製を返します。 また、第 2 引数 padding を指定したときは 空白文字の代わりに padding を詰めます。
- [PARAM] width:
- 返り値の文字列の最小の長さ
- [PARAM] padding:
- 長さが width になるまで self の右側に詰める文字
例:
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]
-
セパレータ sep が最後に登場する部分で self を 3 つに分割し、 [最後のセパレータより前の部分, セパレータ, それ以降の部分] の 3 要素の配列を返します。
self がセパレータを含まないときは、 返り値の第 1 要素と第 2 要素が空文字列になります。
- [PARAM] sep:
- セパレータを表す文字列か正規表現を指定します。
例:
p "axaxa".rpartition("x") # => ["axa", "x", "a"] p "aaaaa".rpartition("x") # => ["", "", "aaaaa"]
[SEE_ALSO] String#partition, String#split
rstrip -> String
-
文字列の末尾にある空白文字を全て取り除いた新しい文字列を返します。 空白文字の定義は " \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
-
文字列の末尾にある空白文字を全て破壊的に取り除きます。 空白文字の定義は " \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(re) -> [String] | [[String]]
-
self に対して正規表現 re を繰り返しマッチし、 マッチした部分文字列の配列を返します。
正規表現が括弧を含む場合は、 括弧で括られたパターンにマッチした部分文字列の配列の配列を返します。
例:
p "foobar".scan(/../) # => ["fo", "ob", "ar"] 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(re) {|s| ... } -> ()
-
正規表現 re がマッチした部分文字列をブロックに渡して実行します。 正規表現 re が括弧を含む場合は、 括弧で括られたパターンにマッチした文字列の配列を渡します。
- [PARAM] re:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
例:
"foobarbazfoobarbaz".scan(/ba./) {|s| p s } # => "bar" # "baz" # "baz" # "baz" "foobarbazfoobarbaz".scan(/(ba)(.)/) {|s| p s } # => ["ba", "r"] # ["ba", "z"] # ["ba", "r"] # ["ba", "z"]
setbyte(index, b) -> Integer
-
index バイト目のバイトを b に変更します。
index に負を指定すると末尾から数えた位置を変更します。
セットした値を返します。
- [PARAM] index:
- バイトをセットする位置
- [PARAM] b:
- セットするバイト(0 から 255 までの整数)
- [EXCEPTION] IndexError:
- 範囲外に値をセットしようとした場合に発生します。
singleton_class -> Class
-
レシーバの特異クラスを返します。 まだ特異クラスがなければ、新しく作成します。
レシーバが nil か true か false なら、それぞれ NilClass, TrueClass, FalseClass を返します。
- [EXCEPTION] TypeError:
- レシーバが Fixnum か Symbol の場合に発生します。
Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>> String.singleton_class #=> #<Class:String> nil.singleton_class #=> NilClass
[SEE_ALSO] Object#class
singleton_methods(inherited_too = true) -> [Symbol]
-
そのオブジェクトに対して定義されている特異メソッド名 (public あるいは protected メソッド) の一覧を返します。
クラスメソッド(Classのインスタンスの特異メソッド)に関しては 引数が真のとき、スーパークラスのクラスメソッドも対象になります。
singleton_methods(false) は、Object#methods(false) と同じです。
- [PARAM] inherited_too:
- 引数が真のとき、スーパークラスのクラスメソッドも対象になります。これが意味を持つのは self がクラスオブジェクトであるときだけです。
#例1: Parent = Class.new class <<Parent private; def private_class_parent() end protected; def protected_class_parent() end public; def public_class_parent() end end Foo = Class.new(Parent) class <<Foo private; def private_class_foo() end protected; def protected_class_foo() end public; def public_class_foo() end end module Bar private; def private_bar() end protected; def protected_bar() end public; def public_bar() end end obj = Foo.new class <<obj include Bar private; def private_self() end protected; def protected_self() end public; def public_self() end end # あるオブジェクトの特異メソッドの一覧を得る。 p obj.singleton_methods(false) p obj.methods(false) p Foo.singleton_methods(false) #実行結果 [:protected_self, :public_self] [:protected_self, :public_self] [:protected_class_foo, :public_class_foo] #例2: # あるオブジェクトの特異メソッドの一覧を得る。 # 親クラスのクラスメソッドも含まれるよう true を指定したが、 # Object のクラスメソッドは一覧から排除している。 p obj.singleton_methods(true) p Foo.singleton_methods(true) - Object.singleton_methods(true) #実行結果 [:protected_self, :public_self, :protected_bar, :public_bar] [:protected_class_foo, :public_class_foo, :protected_class_parent, :public_class_parent]
[SEE_ALSO] Object#methods,Object#extend
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#[] 参照) を 文字列から取り除いたうえで取り除いた部分文字列を返します。
引数が範囲外を指す場合は nil を返します。
split(sep = $;, limit = 0) -> [String] | [[String]]
-
第 1 引数 sep で指定されたセパレータによって文字列を limit 個まで分割し、 結果を文字列の配列で返します。
第 1 引数 sep は以下のいずれかです。
- 正規表現
-
正規表現にマッチする部分で分割する。 特に、括弧によるグルーピングがあればそのグループにマッチした 文字列も結果の配列に含まれる (後述)。
- 文字列
-
その文字列自体にマッチする部分で分割する。
- 1 バイトの空白文字 ' ' か nil
-
先頭と末尾の空白を除いたうえで、空白文字列で分割する。
- 空文字列 '' あるいは空文字列にマッチする正規表現
-
文字列を 1 文字ずつに分割する。マルチバイト文字を認識する。
sep が正規表現で、かつその正規表現に括弧が含まれている場合には、 各括弧のパターンにマッチした文字列も配列に含まれます。 括弧が複数ある場合は、マッチしたものだけが配列に含まれます。
第 2 引数 limit は以下のいずれかです。
- limit > 0
-
最大 limit 個の文字列に分割する
- limit == 0
-
分割個数制限はなしで、配列末尾の空文字列を取り除く
- limit < 0
-
分割個数の制限はなし
- [PARAM] sep:
- 文字列を分割するときのセパレータのパターン
- [PARAM] 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", "", "", ""]
squeeze(*chars) -> String
-
chars に含まれる文字が複数並んでいたら 1 文字にまとめます。
chars の形式は tr(1) と同じです。つまり、 `a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外を意味します。
`-' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`^' もその効果は文字列の先頭にあるときだけです。また、 `-', `^', `\' はバックスラッシュ(`\')によ りエスケープすることができます。
引数を 1 つも指定しない場合は、すべての連続した文字を 1 文字にまとめます。
引数を複数指定した場合は、すべての引数にマッチする文字を 1 文字にまとめます。
- [PARAM] chars:
- 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) -> ()
-
chars に含まれる文字が複数並んでいたら 1 文字にまとめます。
chars の形式は tr(1) と同じです。つまり、 `a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外を意味します。
`-' は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、`^' もその効果は文字列の先頭にあるときだけです。また、 `-', `^', `\' はバックスラッシュ(`\')によ りエスケープすることができます。
引数を 1 つも指定しない場合は、すべての連続した文字を 1 文字にまとめます。
引数を複数指定した場合は、すべての引数にマッチする文字を 1 文字にまとめます。
- [PARAM] chars:
- 1文字にまとめる文字。
例:
str = "112233445566778899" str.squeeze! p str # =>"123456789" str = "112233445566778899" str.squeeze!("2-8") p str # =>"11234567899"
start_with?(str) -> bool
-
self の先頭が str であるとき true を返します。
- [PARAM] str:
- パターンを表す文字列
例:
"string".start_with?("str") # => true "string".start_with?("ing") # => false
[SEE_ALSO] String#end_with?
strip -> String
-
文字列先頭と末尾の空白文字を全て取り除いた文字列を生成して返します。 空白文字の定義は " \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
-
先頭と末尾の空白文字を全て破壊的に取り除きます。 空白文字の定義は " \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
-
文字列中で pattern にマッチした最初の部分を 文字列 replace で置き換えた文字列を生成し返します。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
- [PARAM] replace:
- pattern で指定した文字列と置き換える文字列
例:
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
-
文字列中で pattern にマッチした最初の部分をブロックに渡し、 その評価結果で置き換えた新しい文字列を返します。 ブロックなしの sub と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
例:
p 'abcabc'.sub(/b/) {|s| s.upcase } #=> "aBcabc" p 'abcabc'.sub(/b/) { $&.upcase } #=> "aBcabc"
[SEE_ALSO] String#gsub
sub(pattern, hash) -> String
-
文字列中の pattern にマッチした部分をキーにして hash を引いた値で置き換えます。
- [PARAM] pattern:
- 置き換える文字列のパターン
- [PARAM] hash:
- 置き換える文字列を与えるハッシュ
hash = {'b'=>'B', 'c'=>'C'} p "abcabc".sub(/[bc]/){hash[$&]} #=> "aBCabc" p "abcabc".sub(/[bc]/, hash) #=> "aBCabc"
sub!(pattern, replace) -> self | nil
-
文字列中で pattern にマッチした最初の部分を文字列 replace へ破壊的に置き換えます。
置換文字列 replace 中の \& と \0 はマッチした部分文字列に、 \1 ... \9 は n 番目の括弧の内容に置き換えられます。 置換文字列内では \`、\'、\+ も使えます。 これらは $`、$'、$+ に対応します。
sub! は通常 self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
- [PARAM] replace:
- pattern で指定した文字列と置き換える文字列
- [RETURN]
- 置換した場合は 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
-
文字列中で pattern にマッチした最初の部分をブロックに渡し、 その評価結果へ破壊的に置き換えます。
また、ブロックなしの sub と違い、ブロックの中からは 組み込み変数 $1, $2, $3, ... を問題なく参照できます。
- [PARAM] pattern:
- 置き換える文字列のパターンを表す文字列か正規表現。 文字列を指定した場合は全く同じ文字列にだけマッチする
- [RETURN]
- 置換した場合は self、置換しなかった場合は nil
例:
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
-
文字列中の pattern にマッチした部分をキーにして hash を引いた値で破壊的に置き換えます。
- [PARAM] pattern:
- 置き換える文字列のパターン
- [PARAM] hash:
- 置き換える文字列を与えるハッシュ
- [RETURN]
- 置換した場合は self、置換しなかった場合は nil
sum(bits = 16) -> Integer
-
文字列の 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
- [PARAM] bits:
- チェックサムのビット数
swapcase -> String
-
'A' から 'Z' までのアルファベット大文字を小文字に、 'a' から 'z' までのアルファベット小文字を大文字に変更した文字列を返します。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
例:
p "ABCxyz".swapcase # => "abcXYZ" p "Access".swapcase # => "aCCESS"
[SEE_ALSO] String#upcase, String#downcase, String#capitalize
swapcase! -> self | nil
-
'A' から 'Z' までのアルファベット大文字を小文字に、 'a' から 'z' までのアルファベット小文字を大文字に、破壊的に変更します。
swapcase! は self を変更して返しますが、 置換が起こらなかった場合は nil を返します。
このメソッドはマルチバイト文字を認識しません。
例:
str = "ABCxyz" str.swapcase! p str # => "abcXYZ"
[SEE_ALSO] String#upcase, String#downcase, String#capitalize
taint -> self
-
オブジェクトの「汚染マーク」をセットします。
環境変数(ENVで得られる文字列)など一部のオブジェクトは最初から汚染されています。 オブジェクトの汚染に関してはセキュリティモデルを参照してください。
$SAFE = 1 some = "puts '@&%&(#!'" p some.tainted? #=> false eval(some) #=> @&%&(#! some.taint p some.tainted? #=> true eval(some) # Insecure operation - eval (SecurityError) some.untaint p some.tainted? #=> false eval(some) #=> @&%&(#! p ENV['OS'].tainted? #=> true
[SEE_ALSO] Object#tainted?,Object#untaint,Object#freeze
tainted? -> bool
-
オブジェクトの「汚染マーク」がセットされている時真を返します。
オブジェクトの汚染に関してはセキュリティモデルを参照してください。
p String.new.tainted? #=> false p ENV['OS'].tainted? #=> true
[SEE_ALSO] Object#taint,Object#untaint
tap {|x| ... } -> self
-
self を引数としてブロックを評価し、self を返します。
メソッドチェインの途中で直ちに操作結果を表示するために メソッドチェインに "入り込む" ことが、このメソッドの主目的です。
(1..10) .tap {|x| puts "original: #{x.inspect}"}. to_a .tap {|x| puts "array: #{x.inspect}"}. select {|x| x % 2 == 0} .tap {|x| puts "evens: #{x.inspect}"}. map { |x| x * x } .tap {|x| puts "squares: #{x.inspect}"}
to_a -> Array
-
オブジェクトを配列に変換した結果を返します。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
p( {'a'=>1}.to_a ) # [["a", 1]] p ['array'].to_a # ["array"] p nil.to_a # []
[SEE_ALSO] Object#to_ary,Kernel.#Array
to_ary -> Array
-
オブジェクトの Array への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 配列が使われるすべての場面で代置可能であるような、
- 配列そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_ary [3,4] end end it = Foo.new p([1,2] + it) #=> [1, 2, 3, 4]
[SEE_ALSO] Object#to_a,Kernel.#Array
to_c -> Complex
-
自身を複素数 (Complex) に変換した結果を返します。
以下の形式を解析できます。i、j は大文字、小文字のどちらでも解析できます。
- 実部+虚部i
- 実部+虚部j
- 絶対値@偏角
それぞれの数値は以下のいずれかの形式で指定します。先頭の空白文字や複素 数値の後にある文字列は無視されます。また、数値オブジェクトと同様に各桁 の間に「_」を入れる事ができます。
- "1/3" のような分数の形式
- "0.3" のような10進数の形式
- "0.3E0" のような x.xEn の形式
自身が解析できない値であった場合は 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
-
文字列を 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_hash -> Hash
-
オブジェクトの Hash への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- ハッシュが使われるすべての場面で代置可能であるような、
- ハッシュそのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_hash {'as' => 24} end end it = Foo.new p({:as => 12}.merge(it)) #=> {"as"=>24, :as=>12}
to_i(base = 10) -> Integer
-
文字列を 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
- [PARAM] base:
- 進数を指定する整数。0 か、2〜36 の整数。
- [RETURN]
- 整数
このメソッドの逆に数値を文字列に変換するには、 Kernel.#sprintf, String#%, Integer#to_s を使用します。
String#hex, String#oct, String#to_f, Kernel.#Integer, Kernel.#Float も参照してください。
to_int -> Integer
-
オブジェクトの Integer への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 整数が使われるすべての場面で代置可能であるような、
- 整数そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_int 666 end end it = Foo.new p(9**9 & it) #=> 8
[SEE_ALSO] Kernel.#Integer
to_io -> IO
-
オブジェクトの IO への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- IOオブジェクトが使われるすべての場面で代置可能であるような、
- IOオブジェクトそのものとみなせるようなもの
という厳しいものになっています。
to_proc -> Proc
-
オブジェクトの Proc への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
def doing yield end class Foo def to_proc Proc.new{p 'ok'} end end it = Foo.new doing(&it) #=> "ok"
to_r -> Rational
-
自身を有理数(Rational)に変換した結果を返します。
Kernel.#Rational に文字列を指定した時のように、以下のいずれかの形 式で指定します。
- "1/3" のような分数の形式
- "0.3" のような10進数の形式
- "0.3E0" のような x.xEn の形式
- 数字をアンダースコアで繋いだ形式
例:
' 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_regexp -> Regexp
-
オブジェクトの Regexp への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 正規表現が使われるすべての場面で代置可能であるような、
- 正規表現そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_regexp /[\d]+/ end end it = Foo.new p Regexp.union(/^at/, it) #=> /(?-mix:^at)|(?-mix:[\d]+)/
to_s -> String
to_str -> String
-
self を返します。
例:
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
to_s -> String
-
オブジェクトの文字列表現を返します。
Kernel.#print や Kernel.#sprintf は文字列以外の オブジェクトが引数に渡された場合このメソッドを使って文字列に変換し ます。
class Foo def initialize num @num = num end end it = Foo.new(40) puts it #=> #<Foo:0x2b69110> class Foo def to_s "Class:Foo Number:#{@num}" end end puts it #=> Class:Foo Number:40
[SEE_ALSO] Object#to_str,Kernel.#String
to_str -> String
-
オブジェクトの String への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 文字列が使われるすべての場面で代置可能であるような、
- 文字列そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_str 'Edition' end end it = Foo.new p('Second' + it) #=> "SecondEdition"
[SEE_ALSO] Object#to_s,Kernel.#String
tr(pattern, replace) -> String
-
pattern 文字列に含まれる文字を検索し、 それを replace 文字列の対応する文字に置き換えます。
pattern の形式は tr(1) と同じです。つまり、 `a-c' は a から c を意味し、"^0-9" のように 文字列の先頭が `^' の場合は指定文字以外が置換の対象になります。
replace に対しても `-' による範囲指定が可能です。 例えば String#upcase は tr を使って "foo".tr('a-z', 'A-Z') と書けます。
`-' は文字列の両端にない場合にだけ範囲指定の意味になります。 `^' も文字列の先頭にあるときにだけ否定の効果を発揮します。 また、`-', `^', `\' はバックスラッシュ (`\') によりエスケープできます。
replace の範囲が pattern の範囲よりも小さい場合は、 replace の最後の文字が無限に続くものとして扱われます。
- [PARAM] pattern:
- 置き換える文字のパターン
- [PARAM] replace:
- pattern で指定した文字を置き換える文字
例:
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
-
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 を返します。
- [PARAM] pattern:
- 置き換える文字のパターン
- [PARAM] replace:
- pattern で指定した文字を置き換える文字
[SEE_ALSO] String#tr, String#tr_s
tr_s(pattern, replace) -> String
-
文字列の中に pattern 文字列に含まれる文字が存在したら、 replace 文字列の対応する文字に置き換えます。さらに、 置換した部分内に同一の文字の並びがあったらそれを 1 文字に圧縮します。
pattern の形式は tr(1) と同じです。 つまり「a-c」は a から c を意味し、 "^0-9" のように文字列の先頭が「^」の場合は指定した文字以外が置換の対象になります。
replace でも「-」を使って範囲を指定できます。
「-」は文字列の両端にない場合にだけ範囲指定の意味になります。 同様に、「^」もその効果は文字列の先頭にあるときだけです。 また、「-」、「^」、「\」はバックスラッシュ (「\」) でエスケープできます。
replace の範囲が pattern の範囲よりも小さい場合、 replace の最後の文字が無限に続くものとして扱われます。
- [PARAM] pattern:
- 置き換える文字のパターン
- [PARAM] replace:
- pattern で指定した文字を置き換える文字
例:
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
-
文字列の中に 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"
- [PARAM] pattern:
- 置き換える文字のパターン
- [PARAM] replace:
- pattern で指定した文字を置き換える文字
[SEE_ALSO] String#tr, String#tr_s
trust -> self
-
[TODO]
オブジェクトの「untrustマーク」を取り除きます。
[SEE_ALSO] Object#untrusted?,Object#untrust
unpack(template) -> Array
-
Array#pack で生成された文字列を テンプレート文字列 template にしたがってアンパックし、 それらの要素を含む配列を返します。
- [PARAM] template:
- pack テンプレート文字列
- [RETURN]
- オブジェクトの配列
以下にあげるものは、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
- エンディアン依存、整数サイズ依存 (C の構造体などに適切)
-
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
- エンディアン依存、整数サイズ非依存 (C99 の stdint.h にある厳密な幅を持つ整数型に適切)
-
s: int16_t S: uint16_t l: int32_t L: uint32_t
各テンプレート文字の説明
説明中、Array#pack と String#unpack で違いのあるものは `/' で区切って 「Array#pack の説明 / String#unpack の説明」としています。
- a
-
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 "]
- A
-
ASCII文字列(スペースを詰める/後続するnull文字やスペースを削除)
["abc"].pack("A") # => "a" ["abc"].pack("A*") # => "abc" ["abc"].pack("A4") # => "abc " "abc ".unpack("A4") # => ["abc"] "abc\0".unpack("A4") # => ["abc"]
- Z
-
null終端文字列(aと同じ / 後続するnull文字を削除)
["abc"].pack("Z") # => "a" ["abc"].pack("Z*") # => "abc" ["abc"].pack("Z4") # => "abc\0" "abc\0".unpack("Z4") # => ["abc"] "abc ".unpack("Z4") # => ["abc "]
- b
-
ビットストリング(各バイトごとに下位ビットから上位ビット)
"\377\000".unpack("b*") # => ["1111111100000000"] "\001\002".unpack("b*") # => ["1000000001000000"] "\001\002".unpack("b3") # => ["100"] ["1000000001000000"].pack("b*") # => "\001\002"
- B
-
ビットストリング(各バイトごとに上位ビットから下位ビット)
"\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"
- h
-
16進文字列(下位ニブルが先)
"\x01\xfe".unpack("h*") # => ["10ef"] "\x01\xfe".unpack("h3") # => ["10e"] ["10ef"].pack("h*") # => "\001\376"
- H
-
16進文字列(上位ニブルが先)
"\x01\xfe".unpack("H*") # => ["01fe"] "\x01\xfe".unpack("H3") # => ["01f"] "~".unpack("H2") # => ["7e"] ["01fe"].pack("H*") # => "\001\376" ["7e"].pack("H2") # => "~"
- c
-
char (8bit 符号つき整数)
"\001\376".unpack("c*") # => [1, -2] [1, -2].pack("c*") # => "\001\376" [1, 254].pack("c*") # => "\001\376"
- C
-
unsigned char (8bit 符号なし整数)
"\001\376".unpack("C*") # => [1, 254] [1, -2].pack("C*") # => "\001\376" [1, 254].pack("C*") # => "\001\376"
- s
-
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"
- S
-
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"
- i
-
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"
- I
-
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"
- l
-
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"
- L
-
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"
- q
-
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"
- Q
-
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"
- m
-
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
- M
-
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"]
- n
-
ネットワークバイトオーダー(ビッグエンディアン)の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]
- N
-
ネットワークバイトオーダー(ビッグエンディアン)の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]
- v
-
"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]
- V
-
"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]
- f
-
単精度浮動小数点数(機種依存)
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"
- d
-
倍精度浮動小数点数(機種依存)
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"
- e
-
リトルエンディアンの単精度浮動小数点数(機種依存)
IA-32 (IEEE754):
[1.0].pack("e") # => "\000\000\200?"
SPARC (IEEE754):
[1.0].pack("e") # => "\000\000\200?"
- E
-
リトルエンディアンの倍精度浮動小数点数(機種依存)
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?"
- g
-
ビッグエンディアンの単精度浮動小数点数(機種依存)
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
- G
-
ビッグエンディアンの倍精度浮動小数点数(機種依存)
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
- p
-
ナル終端の文字列へのポインタ
[""].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"
- P
-
構造体(固定長文字列)へのポインタ
[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)
- u
-
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"
- U
-
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]
- w
-
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") である。
- x
-
ナルバイト/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
- X
-
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]
- "x" でナルバイトを埋めることができる
-
[82, 117, 98, 121].pack("ccxxcc") # => "Ru\000\000by"
- "x" で文字を読み飛ばす事が出来る
-
"Ru\0\0by".unpack('ccxxcc') # => [82, 117, 98, 121]
- Hexダンプを数値の配列に変換する例
-
"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]
- バイナリと16進数のpackでは長さ指定は生成されるバイト数ではなく、ビットやニブルの個数を表す
-
[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"
- テンプレート文字'a'の長さ指定は1つの文字列だけに適用される
-
["RUBY", "u", "b", "y"].pack("a4") # => "RUBY" ["RUBY", "u", "b", "y"].pack("aaaa") # => "Ruby" ["RUBY", "u", "b", "y"].pack("a*aaa") # => "RUBYuby"
- テンプレート文字"a"は、長さが足りない分をヌル文字で補う
-
["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" # システムによらずリトルエンディアン
- ネットワークバイトオーダの signed long
-
s = "\xff\xff\xff\xfe" n = s.unpack("N")[0] if n[31] == 1 n = -((n ^ 0xffff_ffff) + 1) end n # => -2
- ネットワークバイトオーダの signed long(その2)
-
s = "\xff\xff\xff\xfe" n = s.unpack("N").pack("l").unpack("l")[0] n # => -2
- IPアドレス
-
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"
- sockaddr_in 構造体
-
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 メソッドがあります。
- '\0'終端文字列のアドレス
-
テンプレート文字 "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"
で得られます。
- UTF-8からUCS-2への変換 (サロゲートを処理していないので UTF-16 とはいえない)
-
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"
untaint -> self
-
オブジェクトの「汚染マーク」を取り除きます。
汚染マークを取り除くことによる危険性はプログラマが責任を負う必要が あります。
オブジェクトの汚染に関してはセキュリティモデルを参照してください。
- [EXCEPTION] SecurityError:
- セキュリティレベルが3以上の時にこのメソッドを使用すると発生します。
[SEE_ALSO] Object#taint,Object#tainted?
untrust -> self
-
[TODO]
オブジェクトの「untrustマーク」をセットします。
[SEE_ALSO] Object#trust,Object#untrusted?
untrusted? -> bool
-
[TODO]
オブジェクトの「untrustマーク」がセットされている時真を返します。
[SEE_ALSO] Object#trust,Object#untrust
upcase -> String
-
'a' から 'z' までのアルファベット小文字を大文字に変換した文字列を作成し返します。
このメソッドはマルチバイト文字列を認識しますが、 それはあくまでも「1 文字を 1 文字として認識する」だけであって、 いわゆる全角アルファベットの大文字小文字までは変換しません。
例:
p "stRIng? STring.".upcase # => "STRING? STRING."
[SEE_ALSO] String#upcase!, String#downcase, String#swapcase, String#capitalize
upcase! -> self | nil
-
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
-
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
- [PARAM] max:
- 繰り返しをやめる文字列
- [PARAM] exclusive:
- max を含むかどうか。false の場合は max を含む。
valid_encoding? -> bool
-
文字列の内容が、現在のエンコーディングに照らしあわせて妥当であれば true を返します。さもなくば false を返します。
privateメソッド
initialize(*args, &block) -> object
-
ユーザ定義クラスのオブジェクト初期化メソッド。
このメソッドは Class#new から新しく生成されたオブ ジェクトの初期化のために呼び出されます。他の言語のコンストラクタに相当します。 デフォルトの動作ではなにもしません。
initialize には Class#new に与えられた引数がそのまま渡されます。
サブクラスではこのメソッドを必要に応じて再定義されること が期待されています。
initialize という名前のメソッドは自動的に private に設定され ます。
- [PARAM] args:
- 初期化時の引数です。
- [PARAM] block:
- 初期化時のブロック引数です。必須ではありません。
class Foo def initialize name puts "initialize Foo" @name = name end end class Bar < Foo def initialize name, pass puts "initialize Bar" super name @pass = pass end end it = Bar.new('myname','0500') p it #=> initialize Bar # initialize Foo # #<Bar:0x2b68f08 @name="myname", @pass="0500">
[SEE_ALSO] Class#new
initialize_copy(obj) -> object
-
(拡張ライブラリによる) ユーザ定義クラスのオブジェクトコピーの初期化メソッド。
このメソッドは self を obj の内容で置き換えます。ただ し、self のインスタンス変数や特異メソッドは変化しません。 Object#clone, Object#dupの内部で使われています。
initialize_copy は、Ruby インタプリタが知り得ない情報をコピーするた めに使用(定義)されます。例えば C 言語でクラスを実装する場合、情報 をインスタンス変数に保持させない場合がありますが、そういった内部情 報を initialize_copy でコピーするよう定義しておくことで、dup や clone を再定義する必要がなくなります。
デフォルトの Object#initialize_copy は、 freeze チェックおよび型のチェックを行い self を返すだけのメソッドです。
initialize_copy という名前のメソッドは 自動的に private に設定されます。
- [EXCEPTION] TypeError:
- レシーバが freeze されているか、obj のクラスがレシーバ のクラスと異なる場合に発生します。
[SEE_ALSO] Object#clone,Object#dup
以下に例として、dup や clone がこのメソッドをどのように利用しているかを示します。
obj.dup は、新たに生成したオブジェクトに対して initialize_copy を呼び
obj2 = obj.class.allocate obj2.initialize_copy(obj)
obj2 に対してさらに obj の汚染状態、インスタンス変数、ファイナライ ザをコピーすることで複製を作ります。 obj.clone は、さらに 特異メソッドのコピーも行います。
obj = Object.new class <<obj attr_accessor :foo def bar :bar end end def check(obj) puts "instance variables: #{obj.inspect}" puts "tainted?: #{obj.tainted?}" print "singleton methods: " begin p obj.bar rescue NameError p $! end end obj.foo = 1 obj.taint check Object.new.send(:initialize_copy, obj) #=> instance variables: #<Object:0x4019c9d4> # tainted?: false # singleton methods: #<NoMethodError: ...> check obj.dup #=> instance variables: #<Object:0x4019c9c0 @foo=1> # tainted?: true # singleton methods: #<NoMethodError: ...> check obj.clone #=> instance variables: #<Object:0x4019c880 @foo=1> # tainted?: true # singleton methods: :bar
remove_instance_variable(name) -> object
-
オブジェクトからインスタンス変数 name を取り除き、そのインス タンス変数に設定されていた値を返します。
- [PARAM] name:
- 削除するインスタンス変数の名前をシンボルか文字列で指定します。
- [EXCEPTION] NameError:
- オブジェクトがインスタンス変数 name を持たない場合に発生します。
class Foo def foo @foo = 1 p remove_instance_variable(:@foo) #=> 1 p remove_instance_variable(:@foo) # instance variable @foo not defined (NameError) end end Foo.new.foo
[SEE_ALSO] Module#remove_class_variable,Module#remove_const
定数
Encoding
-
[TODO]
Encoding
-
[TODO]