!のつかない破壊的メソッドまとめ

はじめに

• Ruby技術者認定試験Silver合格に向けて、自分用まとめ
• 情報元：Ruby 2.1.0 リファレンスマニュアル

String

<<

self << other -> self

selfに文字列otherを破壊的に連結します。
other が 整数である場合は other.chr(self.encoding) 相当の文字を末尾に追加します。
self を返します。

String#<<

str = "string"
str << "YYY"

p str   #=> "stringYYY"

[]=

self[nth] = val

nth 番目の文字を文字列 val で置き換えます。

String#[]=

buf = "string"
buf[1] = "!!"
p buf   # => "s!!ring"

clear

clear -> self

文字列の内容を削除して空にします。
self を返します。

String#clear

str = "abc"
str.clear
p str     # => ""

concat

concat(other) -> self

self に文字列 other を破壊的に連結します。
other が 整数である場合は other.chr(self.encoding) 相当の文字を末尾に追加します。
self を返します。

String#concat

str = "string"
str.concat "XXX"
p str    # => "stringXXX"

insert

insert(pos, other) -> self

pos 番目の文字の直前に文字列 other を挿入します。
self[pos, 0] = other と同じ操作です。

String#insert

str = "foobaz"
str.insert(3, "bar")
p str   # => "foobarbaz"

replace

replace(other) -> String

self の内容を other の内容で置き換えます。

String#replace

str = "foo"
str.replace "bar"
p str   # => "bar"

setbyte

setbyte(index, b) -> Integer

index バイト目のバイトを b に変更します。
index に負を指定すると末尾から数えた位置を変更します。
セットした値を返します。

String#setbyte

str = "hello, world"
str.setbyte(1, 0x45)
p str   # => "hEllo, world"

Array

<<

self << obj -> self

指定された obj を自身の末尾に破壊的に追加します。

Array#<<

ary = [1]
ary << 2
p ary   # => [1, 2]

[]=

self[nth] = val

nth 番目の要素を val に設定します。
nth が配列の範囲を越える時には配列の長さを自動的に拡張し、 拡張した領域を nil で初期化します。

Array#[]=

a = [0, 1, 2, 3, 4, 5]
a[0] = "a"
p a   #=> ["a", 1, 2, 3, 4, 5]

clear

clear -> self

配列の要素をすべて削除して空にします。

Array#clear

ary = [1, 2]
ary.clear
p ary   #=> []

concat

concat(other) -> self

配列 other を自身の末尾に破壊的に連結します。

Array#concat

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#delete

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#delete_at

array = [0, 1, 2, 3, 4]
array.delete_at 2
p array             #=> [0, 1, 3, 4]

delete_if

delete_if {|x| ... } -> self

要素を順番にブロックに渡して評価し、その結果が真になった要素をすべて削除します。

Array#delete_if

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 の代わりにブロックを指定するとブロックの評価結果を値とします。

Array#fill

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 を一つも指定しなければ何もしません。

Array#insert

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 を返した要素を削除します。

Array#keep_if

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#pop

array = [1, [2, 3], 4]
p array.pop      # => 4
p array.pop      # => [2, 3]
p array          # => [1]

push

push(*obj) -> self

指定された obj を順番に配列の末尾に追加します。
引数を指定しなければ何もしません。

Array#push

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 の内容で置き換えます。

Array#replace

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 分する簡単な方法として使えます。

Array#shift

a = [0, 1, 2, 3, 4]
p a.shift            #=> 0
p a                  #=> [1, 2, 3, 4]

unshift

unshift(*obj) -> self

指定された obj を引数の最後から順番に配列の先頭に挿入します。
引数を指定しなければ何もしません。

Array#unshift

arr = [1,2,3]
arr.unshift 0
p arr             #=> [0, 1, 2, 3]

Hash

[]=

self[key] = value

key に対して value を関連づけます。value を返します。

Hash#[]=

h = {}
h[:key] = "value"
p h   #=>{:key => "value"}

clear

clear -> self

ハッシュの中身を空にします。
空にした後の self を返します。 デフォルト値の設定はクリアされません。

Hash#clear

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 に対応する要素を取り除きます。

Hash#delete

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 を返します。

Hash#delete_if

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 と同じです。

Hash#replace

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] という形式の値を返すわけではないことに注意)。

Hash#shift

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 を返します。

Hash#store

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 を使って暗黙の変換を試みます。

Hash#update

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"}