配列のメソッドまとめ

覚えてないので自分用のカンペ。

# 配列に要素を加えるメソッド

### a.unshift(item)
- 配列aの**先頭**に新しい要素をつけ加えるメソッド
 
```ruby
a = [1,2,3,4,5]
a.unshift(0)
p a 
=> [0,1,2,3,4,5]  # 出力結果
```


### a << item もしくは a.push(item)
- << とpushは同じ働きのメソッドで、配列aの**末尾**に新しい要素itemを付け加える。

```ruby
a = [1,2,3,4,5]
a << 6  # もしくはa.push(6)
p a
=> [1,2,3,4,5,6]
```


### a.concat(b) もしくは a + b
- 配列(a)に別の配列(b)を連結する。
- concatは破壊的メソッド。(レシーバにあたるオブジェクトの値そのものを変える。もしb=aとして別の変数にオブジェクトを入れてても、aとbは同一オブジェクトを示すため、aに破壊的メソッドを使えばbの値も変更される)
- ＋は元の配列をそのままにして新しい配列を作る。

```ruby
a = [1,2,3,4,5]
a.concat([8,9])
p a
=> [1,2,3,4,5,8,9]
```


### a[n] = item もしくは a[n..m] = item もしくは a[n, len] = item
- 配列aの指定された部分の要素をitemに置き換える。

```ruby
a = [1,2,3,4,5,6,7,8]
a[2..4] = 0
p a
=> [1,2,0,6,7,8]
a[1,3] = 9
p a
=> [1,9,7,8]
```





# 配列から要素を取り除くメソッド

### a.compact もしくは a.compact!
- 配列aの中から要素がnilのものを取り除く。
- compactは新しい配列を作る。compact！メソッドはnilを取り除いたあとのaを返すが、何も取り除けなければnilを返す。

```ruby
a = [1,nil,3,nil,nil]
a.compact!
p a
=> [1,3]
```


### a.delete(x)
- 配列aから要素xを取り除く。

```ruby
a = [1,2,3,2,1]
a.delete(2)
p a
=> [1,3,1]
```

### a.delete_at(n)
- 配列a[n]の要素を取り除く。

```ruby
a = [1,2,3,4,5]
a.delete_at(2)
p a
=> [1,2,4,5]
```

### a.delete_if{|item| ・・・} もしくは a.reject{|item| ・・・} もしくは a.reject!{|item| } ・・・}
- 配列aの各要素itemについて、ブロックを実行した結果が真だった場合、aからitemを取り除く。
- delete_ifとreject!は破壊的なメソッド。

```ruby
a = [1,2,3,4,5]
a.delete_if(|i| i>3)
p a
=> [1,2,3]
```

### a.slice!(n) もしくは a.slice!(n..m) もしくは a.slice!(n,len)
- 配列aから指定され部分を取り除き、取り除いた値を返す。
- slice！は破壊的なメソッド

```ruby
a = [1,2,3,4,5]
p a.slice!(1,2)
=> [2,3]
p a
=> [1,4,5]
```

### a.uniq もしくは a.uniq!
- 配列のaの重複する要素を削除。uniq！は破壊的なメソッド。

```ruby
a = [1,2,3,4,3,2,1]
a.uniq!
p a
=> [1,2,3,4]
```

### a.shift
- 配列aの**先頭**要素を取り除き、取り除いた値を返す。
 
```ruby
a = [1,2,3,4,5]
a.shift
=> 1
p a
=> [2,3,4,5]
```

### a.pop
- 配列aの**末尾**要素を取り除き、取り除いた値を返す。

```ruby
a= [1,2,3,4,5]
a.pop
=> 5
p a
=> [1,2,3,4]
```


# 配列の要素を置き換えるメソッド
これも！がつくものは破壊的なメソッド、！がつかないものは別の配列を作って返すメソッド。


### a.collect{|item| ・・・} もしくは a.collect!{|item| } ・・・} もしくは a.map{|item|} ・・・} もしくは a.map!{|item| ・・・}
- 配列aの各要素itemにブロックを適用し、その結果を集めて新しい配列を作る。
- 要素数は変わらないが、配列の各要素はブロック中の処理によって前と異なるものになる。

```ruby
a = [1,2,3,4,5]
a.collect! {|item| item * 2}
p a
=> [2,4,6,8,10]
```

### a.fill(value) もしくは a.fill(value,begin) もしくは a.fill(value,begin,len) もしくは a.fill(value,n..m)
- 配列aの要素をvalueに置き換える。引数が１つの場合は、aの要素すべてをvalueにする。
- 引数が２つの場合はbeginから配列の末尾まで、引数が３つの場合はbeginからlen個までをvalueにする。
- また２つ目の引数に「n..m」と範囲を指定している場合はその範囲をvalueにする。

```ruby
p [1,2,3,4,5].fill(0)
=> [0,0,0,0,0]
p [1,2,3,4,5].fill(0,2)
=> [1,2,0,0,0]
p [1,2,3,4,5].fill(0,2,2)
=> [1,2,0,0,5]
p [1,2,3,4,5].fill(0,2..3)
=> [1,2,0,0,5]
```

### a.flatten もしくは a.flatten!
- 配列を平坦化する。(「平坦化」というのは、配列の中に配列が入れ子になっているような場合に、その入れ子を展開して、１つの大きな配列にする操作のこと。)

```ruby
a = [1,2,3,4,5]
a.reverse!
p a
=> [5,4,3,2,1]
```

### a.reverse もしくは a.reverse!
- 配列aの要素を逆順に並べ替える。

```ruby
a = [1,2,3,4,5]
a.reverse!
p a
=> [5,4,3,2,1]

```

### a.sort もしくは a.sort! もしくは a.sort{|i,j| ・・・} もしくは a.sort!{|i,j| ・・・}
- 配列aの各要素を並べ替える。並べ替え方は、ブロックで指定。
- ブロックを指定しない場合は<=>演算子を使って比較する。

```ruby

a = [2,4,3,5,1]
a.sort!
p a 
=> [1,2,3,4,5]

# 文字列同士を<=>演算子で比較した場合は文字コードの値で大小が決まる。（アルファベットの場合は大文字の次に小文字）
array = ["Ruby", "Perl", "PHP", "Python"]
sorted = array.sort
p sorted
=> ["PHP", "Perl", "Python", "Ruby"]

# 文字列長い順にソート
array = ["Ruby", "Perl", "PHP", "Python"]
sorted = array.sort{ |a,b| b.length <=> a.length }
p sorted
=> ["Python", "Perl", "Ruby", "PHP"]
```

### a.sort_by{|i| ・・・}
- 配列aの要素を並べ替える。
- 並べ替え方はすべての要素についてブロックを評価した結果をソートした順に行われる。

```ruby
a = [2,4,3,5,1]
p a.sort_by{|i| -i}
=> [5,4,3,2,1]
```