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

# はじめに

* Ruby技術者認定試験Silver合格に向けて、自分用まとめ
* 情報元：[Ruby 2.1.0 リファレンスマニュアル](https://docs.ruby-lang.org/ja/2.1.0/doc/index.html)

# String

## <<

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

```ruby:String#<<
str = "string"
str << "YYY"

p str   #=> "stringYYY"
```

## []=

`self[nth] = val`

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

```ruby:String#[]=
buf = "string"
buf[1] = "!!"
p buf   # => "s!!ring"
```

## clear

`clear -> self`

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

```ruby:String#clear
str = "abc"
str.clear
p str     # => ""
```

## concat

`concat(other) -> self`

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

```ruby:String#concat
str = "string"
str.concat "XXX"
p str    # => "stringXXX"
```

## insert

`insert(pos, other) -> self`

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

```ruby:String#insert
str = "foobaz"
str.insert(3, "bar")
p str   # => "foobarbaz"
```

## replace

`replace(other) -> String`

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

```ruby:String#replace
str = "foo"
str.replace "bar"
p str   # => "bar"
```

## setbyte

`setbyte(index, b) -> Integer`

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

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

# Array

## <<

`self << obj -> self`

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

```ruby:Array#<<
ary = [1]
ary << 2
p ary   # => [1, 2]
```

## []=

`self[nth] = val`

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

```ruby:Array#[]=
a = [0, 1, 2, 3, 4, 5]
a[0] = "a"
p a   #=> ["a", 1, 2, 3, 4, 5]
```

## clear

`clear -> self`

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

```ruby:Array#clear
ary = [1, 2]
ary.clear
p ary   #=> []
```

## concat

`concat(other) -> self`

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

```ruby: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` と等しい要素が見つからなかったときにブロックを評価してその結果を返します。

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

```ruby: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`

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

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

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

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

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

```ruby:Array#pop
array = [1, [2, 3], 4]
p array.pop      # => 4
p array.pop      # => [2, 3]
p array          # => [1]
```

## push

`push(*obj) -> self`

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

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

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

```ruby:Array#shift
a = [0, 1, 2, 3, 4]
p a.shift            #=> 0
p a                  #=> [1, 2, 3, 4]
```

## unshift

`unshift(*obj) -> self`

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

```ruby:Array#unshift
arr = [1,2,3]
arr.unshift 0
p arr             #=> [0, 1, 2, 3]
```

# Hash

## []=

`self[key] = value`

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

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

## clear

`clear -> self`

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

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

```ruby: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` を返します。
 
```ruby: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` と同じです。

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

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

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

```ruby: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"}
```