はじめに
- Ruby技術者認定試験Silver合格に向けて、自分用まとめ
- 情報元：Ruby 2.1.0 リファレンスマニュアル
String
<<
self << other -> self
selfに文字列otherを破壊的に連結します。
otherが 整数である場合はother.chr(self.encoding)相当の文字を末尾に追加します。
selfを返します。
str = "string"
str << "YYY"
p str #=> "stringYYY"
[]=
self[nth] = val
nth番目の文字を文字列valで置き換えます。
buf = "string"
buf[1] = "!!"
p buf # => "s!!ring"
clear
clear -> self
文字列の内容を削除して空にします。
selfを返します。
str = "abc"
str.clear
p str # => ""
concat
concat(other) -> self
selfに文字列otherを破壊的に連結します。
otherが 整数である場合はother.chr(self.encoding)相当の文字を末尾に追加します。
selfを返します。
str = "string"
str.concat "XXX"
p str # => "stringXXX"
insert
insert(pos, other) -> self
pos番目の文字の直前に文字列otherを挿入します。
self[pos, 0] = otherと同じ操作です。
str = "foobaz"
str.insert(3, "bar")
p str # => "foobarbaz"
replace
replace(other) -> String
selfの内容をotherの内容で置き換えます。
str = "foo"
str.replace "bar"
p str # => "bar"
setbyte
setbyte(index, b) -> Integer
indexバイト目のバイトをbに変更します。
indexに負を指定すると末尾から数えた位置を変更します。
セットした値を返します。
str = "hello, world"
str.setbyte(1, 0x45)
p str # => "hEllo, world"
Array
<<
self << obj -> self
指定された
objを自身の末尾に破壊的に追加します。
ary = [1]
ary << 2
p ary # => [1, 2]
[]=
self[nth] = val
nth番目の要素をvalに設定します。
nthが配列の範囲を越える時には配列の長さを自動的に拡張し、 拡張した領域をnilで初期化します。
a = [0, 1, 2, 3, 4, 5]
a[0] = "a"
p a #=> ["a", 1, 2, 3, 4, 5]
clear
clear -> self
配列の要素をすべて削除して空にします。
ary = [1, 2]
ary.clear
p ary #=> []
concat
concat(other) -> self
配列
otherを自身の末尾に破壊的に連結します。
array = [1, 2]
a = [3, 4]
array.concat a
p array # => [1, 2, 3, 4]
delete
delete(val) -> object | nil
delete(val) { ... } -> object
指定された
valと==で等しい要素を自身からすべて取り除きます。
等しい要素が見つかった場合は最後に見つかった要素を、 そうでない場合にはnilを返します。
ブロックが与えられた場合、valと等しい要素が見つからなかったときにブロックを評価してその結果を返します。
array = [1, 2, 3, 2, 1]
p array.delete(2) #=> 2
p array #=> [1, 3, 1]
Note:
String#deleteは非破壊的
Hash#deleteは破壊的
delete_at
delete_at(pos) -> object | nil
指定された位置
posにある要素を取り除きそれを返します。
posが範囲外であったらnilを返します。
array = [0, 1, 2, 3, 4]
array.delete_at 2
p array #=> [0, 1, 3, 4]
delete_if
delete_if {|x| ... } -> self
要素を順番にブロックに渡して評価し、その結果が真になった要素をすべて削除します。
a = [0, 1, 2, 3, 4, 5]
a.delete_if{|x| x % 2 == 0}
p a #=> [1, 3, 5]
fill
fill(val) -> self
fill {|index| ... } -> self
すべての要素に
valをセットします。
このメソッドがvalのコピーでなくval自身をセットする ことに注意してください。
valの代わりにブロックを指定するとブロックの評価結果を値とします。
a = [0, 1, 2, 3, 4]
a.fill(10)
p a #=> [10, 10, 10, 10, 10]
insert
insert(nth, *val) -> self
インデックス
nthの要素の直前(nthが負の場合は直後)に第 2 引数以降の値を挿入します。
引数valを一つも指定しなければ何もしません。
ary = [1, 2, 3]
ary.insert(2, "a", "b")
p ary # => [1, 2, "a", "b", 3]
keep_if
keep_if {|item| ... } -> self
keep_if -> Enumerator
ブロックが
falseを返した要素を削除します。
a = %w{ a b c d e f }
a.keep_if {|v| v =~ /[aeiou]/}
a # => ["a", "e"]
pop
pop -> object | nil
pop(n) -> Array
自身の末尾から要素を取り除いてそれを返します。
引数を指定した場合はその個数だけ取り除き、それを配列で返します。
空配列の場合、nが指定されていない場合はnilを、 指定されている場合は空配列を返します。
また、nが自身の要素数より少ない場合はその要素数の配列を 返します。どちらの場合も自身は空配列となります。
返す値と副作用の両方を利用して、個数を指定して配列を 2 分する簡単な方法として使えます。
array = [1, [2, 3], 4]
p array.pop # => 4
p array.pop # => [2, 3]
p array # => [1]
push
push(*obj) -> self
指定された
objを順番に配列の末尾に追加します。
引数を指定しなければ何もしません。
array = [1, 2, 3]
array.push 4
array.push [5, 6]
array.push 7, 8
p array # => [1, 2, 3, 4, [5, 6], 7, 8]
replace
replace(another) -> self
配列の内容を配列
anotherの内容で置き換えます。
a = [1, 2, 3]
a.replace [4, 5, 6]
p a #=> [4, 5, 6]
shift
shift -> object | nil
shift(n) -> Array
配列の先頭の要素を取り除いてそれを返します。
引数を指定した場合はその個数だけ取り除き、それを配列で返します。
空配列の場合、nが指定されていない場合はnilを、 指定されている場合は空配列を返します。
また、nが自身の要素数より少ない場合はその要素数の配列を 返します。どちらの場合も自身は空配列となります。
返す値と副作用の両方を利用して、個数を指定して配列を 2 分する簡単な方法として使えます。
a = [0, 1, 2, 3, 4]
p a.shift #=> 0
p a #=> [1, 2, 3, 4]
unshift
unshift(*obj) -> self
指定された
objを引数の最後から順番に配列の先頭に挿入します。
引数を指定しなければ何もしません。
arr = [1,2,3]
arr.unshift 0
p arr #=> [0, 1, 2, 3]
Hash
[]=
self[key] = value
keyに対してvalueを関連づけます。valueを返します。
h = {}
h[:key] = "value"
p h #=>{:key => "value"}
clear
clear -> self
ハッシュの中身を空にします。
空にした後のselfを返します。 デフォルト値の設定はクリアされません。
h = Hash.new("default value")
h[:some] = "some"
p h #=> {:some=>"some"}
h.clear
p h #=> {}
p h.default #=> "default value"
delete
delete(key) -> object | nil
delete(key) {|key| ... } -> object
keyに対応する要素を取り除きます。
h = {:ab => "some" , :cd => "all"}
p h.delete(:ab) #=> "some"
p h.delete(:ef) #=> nil
p h.delete(:ef){|key|"#{key} Nothing"} #=> "ef Nothing"
p h #=> {:cd=>"all"}
Note:
String#deleteは非破壊的
Array#deleteは破壊的
delete_if
delete_if -> Enumerator
delete_if {|key, value| ... } -> self
キーと値を引数としてブロックを評価した結果が真であ るような要素を
selfから削除します。
ブロックを省略した場合はEnumeratorを返します。
h = { 2 => "8" ,4 => "6" ,6 => "4" ,8 => "2" }
h.delete_if{|key, value| key.to_i < value.to_i }
p h # => {6=>"4", 8=>"2"}
replace
replace(other) -> self
ハッシュの内容を
otherの内容で置き換えます。
デフォルト値の設定もotherの内容になります。
otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
self = other.to_hash.dupと同じです。
foo = {1 => 'a', 2 => 'b'}
bar = {2 => 'B', 3 => 'C'}
foo.replace(bar)
p foo #=> {2=>"B", 3=>"C"}
shift
shift -> [object, object]
ハッシュからキーが追加された順で先頭の要素をひとつ取り除き、
[key, value]という配列として返します。
shiftは破壊的メソッドです。selfは要素を取り除かれた残りのハッシュに変更されます。
ハッシュが空の場合、デフォルト値（Hash#defaultまたはHash#default_procのブロックの値か、どちらもnilならばnil） を返します(このとき、[key,value]という形式の値を返すわけではないことに注意)。
h = {:ab => "some" , :cd => "all"}
p h.shift #=> [:ab, "some"]
p h.shift #=> [:cd, "all"]
p h #=> {}
p h.shift #=> nil
h1 = Hash.new("default value")
p h1 #=> {}
p h1.shift #=> "default value"
store
store(key, value) -> object
keyに対してvalueを関連づけます。valueを返します。
h = {}
h.store(:a, 1)
p h # => {:a=>1}
update
update(other) -> self
update(other) {|key, self_val, other_val| ... } -> self
selfとotherのハッシュの内容をマージ(統合)します。Hash#merge!と同じです。
デフォルト値はselfの設定のままです。otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
foo = {1 => 'a', 2 => 'b', 3 => 'c'}
bar = {2 => 'B', 3 => 'C', 4 => 'D'}
p foo.update(bar) #=> {1=>"a", 2=>"B", 3=>"C", 4=>"D"}
p foo #=> {1=>"a", 2=>"B", 3=>"C", 4=>"D"}