| 生成 |
`[]`, `Array.new`, `%w`, `%i` |
リテラル、`new`メソッド、文字列配列 (`%w`)、シンボル配列 (`%i`) で生成します。
arr1 = [1, "two", 3.0, :four]
arr2 = Array.new(3, "A") #=> ["A", "A", "A"]
arr3 = Array.new(3) { |i| i * i } #=> [0, 1, 4]
arr4 = %w(apple banana orange) #=> ["apple", "banana", "orange"]
arr5 = %i(red green blue) #=> [:red, :green, :blue]
|
| 要素アクセス |
`[]`, `at`, `first`, `last`, `fetch` |
インデックスで要素を取得します。`fetch`は範囲外アクセス時にエラーを発生させるか、デフォルト値を返します。
arr = [:a, :b, :c, :d, :e]
p arr[0] #=> :a
p arr.at(1) #=> :b
p arr[-1] #=> :e
p arr.first #=> :a
p arr.last #=> :e
p arr[1, 3] #=> [:b, :c, :d] (インデックス1から3要素)
p arr[1..3] #=> [:b, :c, :d] (インデックス1から3まで)
p arr.fetch(2) #=> :c
# p arr.fetch(10) #=> IndexError
p arr.fetch(10, "default") #=> "default"
p arr.fetch(10) { |i| "missing index #{i}" } #=> "missing index 10"
|
| 要素の追加/挿入 |
`push`, `<<`, `unshift`, `insert` |
末尾に追加 (`push`, `<<`)、先頭に追加 (`unshift`)、指定位置に挿入 (`insert`) します。これらは破壊的メソッドです。
arr = [1, 2, 3]
arr.push(4, 5)
p arr #=> [1, 2, 3, 4, 5]
arr << 6
p arr #=> [1, 2, 3, 4, 5, 6]
arr.unshift(0)
p arr #=> [0, 1, 2, 3, 4, 5, 6]
arr.insert(3, "a", "b")
p arr #=> [0, 1, 2, "a", "b", 3, 4, 5, 6]
|
| 要素の削除 |
`pop`, `shift`, `delete`, `delete_at`, `compact`, `uniq`, `slice!`, `clear` |
末尾 (`pop`)、先頭 (`shift`)、指定要素 (`delete`)、指定インデックス (`delete_at`)、`nil`要素 (`compact`)、重複要素 (`uniq`) を削除します。`slice!` は範囲指定で削除。`clear` は全要素削除。`!`なしの`compact`, `uniq`は非破壊的です。
arr = [1, 2, nil, 3, 2, nil, 4]
p arr.pop #=> 4
p arr #=> [1, 2, nil, 3, 2, nil]
p arr.shift #=> 1
p arr #=> [2, nil, 3, 2, nil]
p arr.delete(2) #=> 2 (最初に見つかった2を削除し、削除した要素を返す)
p arr #=> [nil, 3, 2, nil]
p arr.delete_at(1) #=> 3 (インデックス1を削除)
p arr #=> [nil, 2, nil]
p arr.compact #=> [2] (非破壊)
p arr #=> [nil, 2, nil]
arr.compact!
p arr #=> [2] (破壊的)
arr = [1, 2, 2, 3, 1]
p arr.uniq #=> [1, 2, 3] (非破壊)
arr.uniq!
p arr #=> [1, 2, 3] (破壊的)
arr = [10, 20, 30, 40, 50]
p arr.slice!(1, 2) #=> [20, 30] (削除した要素)
p arr #=> [10, 40, 50]
arr.clear
p arr #=> []
|
| 要素の置換 |
`[]=` , `fill` |
指定したインデックスや範囲の要素を置き換えます。`fill`は指定範囲を指定値やブロックの結果で埋めます。
arr = [1, 2, 3, 4, 5]
arr[1] = "two"
p arr #=> [1, "two", 3, 4, 5]
arr[2..3] = ["a", "b", "c"]
p arr #=> [1, "two", "a", "b", "c", 5]
arr.fill(0, 1, 3) # インデックス1から3要素を0で埋める
p arr #=> [1, 0, 0, 0, "c", 5]
arr.fill { |i| i * 10 } # 全要素をインデックス*10で埋める
p arr #=> [0, 10, 20, 30, 40, 50]
|
| 結合・複製 |
`+`, `concat`, `*`, `dup`, `clone` |
配列同士を結合 (`+`, `concat`)、配列を繰り返して結合 (`*`)、配列を複製 (`dup`, `clone`)します。`+`, `*` は新しい配列を返し、`concat` は破壊的です。`dup`は浅いコピー、`clone`は状態（frozenなど）もコピーします。
a1 = [1, 2]
a2 = [3, 4]
p a1 + a2 #=> [1, 2, 3, 4] (非破壊)
p a1.concat(a2) #=> [1, 2, 3, 4] (破壊的, a1が変わる)
p a2 * 3 #=> [3, 4, 3, 4, 3, 4]
a3 = [1, [2, 3]]
a4 = a3.dup
a5 = a3.clone
p a3.equal?(a4) #=> false
p a3[1].equal?(a4[1]) #=> true (内部配列は同じオブジェクト - 浅いコピー)
a3.freeze
# a4[0] = 100 # OK
# a5[0] = 100 # FrozenError (cloneはfreeze状態もコピー)
|
| 比較 |
`==`, `<=>` |
`==` は要素と順序が同じ場合に `true` を返します。`<=>` は辞書順で比較します。
p [1, 2, 3] == [1, 2, 3] #=> true
p [1, 2, 3] == [1, 3, 2] #=> false
p [1, 2] <=> [1, 3] #=> -1
p [1, 2] <=> [1, 2] #=> 0
p [1, 3] <=> [1, 2] #=> 1
p [1, 2] <=> [1, 2, 3] #=> -1
|
| 検索・選択 |
`include?`, `index`, `rindex`, `find`, `detect`, `select`, `filter`, `reject`, `grep`, `bsearch`, `bsearch_index` |
要素の存在確認、インデックス検索、条件に合う最初の要素 (`find`/`detect`)、条件に合う全要素 (`select`/`filter`)、条件に合わない全要素 (`reject`)、パターンマッチ (`grep`)、二分探索 (`bsearch`/`bsearch_index` – ソート済配列用)を行います。
arr = [10, 20, 30, 40, 20, 50]
p arr.include?(30) #=> true
p arr.index(20) #=> 1 (最初の20のインデックス)
p arr.rindex(20) #=> 4 (最後の20のインデックス)
p arr.find { |x| x > 25 } #=> 30 (最初に見つかった要素)
p arr.select { |x| x.even? } #=> [10, 20, 30, 40, 20, 50]
p arr.reject { |x| x < 30 } #=> [30, 40, 50]
words = ["apple", "banana", "apricot"]
p words.grep(/ap/) #=> ["apple", "apricot"]
p words.grep(/a/) { |word| word.upcase } #=> ["APPLE", "BANANA", "APRICOT"]
sorted_arr = [1, 3, 5, 7, 9]
p sorted_arr.bsearch { |x| x >= 6 } #=> 7
p sorted_arr.bsearch_index { |x| x >= 6 } #=> 3
|
| 繰り返し処理 |
`each`, `map`, `collect`, `each_with_index`, `reverse_each` |
各要素に対してブロックを実行 (`each`)、ブロックの戻り値で新しい配列を作成 (`map`/`collect`)、要素とインデックスを使って繰り返し (`each_with_index`)、逆順で繰り返し (`reverse_each`)。
arr = [1, 2, 3]
arr.each { |x| print x * 2, " " } #=> 2 4 6
puts
squares = arr.map { |x| x * x }
p squares #=> [1, 4, 9]
p arr #=> [1, 2, 3] (非破壊)
arr.map! { |x| x * x } # 破壊的map (collect!も同じ)
p arr #=> [1, 4, 9]
arr.each_with_index { |val, idx| puts "Index #{idx}: #{val}" }
# Index 0: 1
# Index 1: 4
# Index 2: 9
arr.reverse_each { |x| print x, " " } #=> 9 4 1
puts
|
| ソート・順序 |
`sort`, `sort!`, `sort_by`, `sort_by!`, `reverse`, `reverse!`, `shuffle`, `shuffle!` |
要素をソート (`sort`)、ブロックの評価結果でソート (`sort_by`)、順序を反転 (`reverse`)、要素をランダムに並び替え (`shuffle`) します。`!` 付きは破壊的メソッドです。
arr = [3, 1, 4, 1, 5, 9, 2]
p arr.sort #=> [1, 1, 2, 3, 4, 5, 9] (非破壊)
p arr #=> [3, 1, 4, 1, 5, 9, 2]
words = ["caterpillar", "ant", "bee"]
p words.sort_by { |word| word.length } #=> ["ant", "bee", "caterpillar"]
p arr.reverse #=> [2, 9, 5, 1, 4, 1, 3] (非破壊)
arr.sort! # 破壊的ソート
p arr #=> [1, 1, 2, 3, 4, 5, 9]
arr.reverse! # 破壊的反転
p arr #=> [9, 5, 4, 3, 2, 1, 1]
p arr.shuffle #=> (ランダムな順序の配列)
p arr #=> [9, 5, 4, 3, 2, 1, 1] (非破壊)
arr.shuffle!
p arr #=> (ランダムな順序の配列 - 破壊的)
|
| 集合演算 |
`&`, `|`, `-`, `uniq` |
積集合 (`&`)、和集合 (`|`)、差集合 (`-`) を計算します。和集合の結果は重複を含みますが、`uniq`と組み合わせることで重複を除去できます。
a1 = [1, 2, 3, 4]
a2 = [3, 4, 5, 6]
p a1 & a2 #=> [3, 4] (積集合)
p a1 | a2 #=> [1, 2, 3, 4, 5, 6] (和集合, 重複除去)
p (a1 + a2).uniq # 上と同じ
p a1 - a2 #=> [1, 2] (差集合 a1にありa2にないもの)
p a2 - a1 #=> [5, 6] (差集合 a2にありa1にないもの)
|
| 変換 |
`join`, `flatten`, `transpose`, `zip` |
要素を文字列で結合 (`join`)、ネストした配列を平坦化 (`flatten`)、行列の転置 (`transpose` – 全要素が配列である必要あり)、複数の配列の要素をまとめる (`zip`)。
arr = [1, "two", 3.0]
p arr.join(" - ") #=> "1 - two - 3.0"
nested = [1, [2, 3], [4, [5]]]
p nested.flatten #=> [1, 2, 3, 4, 5] (完全に平坦化)
p nested.flatten(1) #=> [1, 2, 3, 4, [5]] (1レベルのみ平坦化)
matrix = [[1, 2], [3, 4], [5, 6]]
p matrix.transpose #=> [[1, 3, 5], [2, 4, 6]]
a1 = [1, 2, 3]
a2 = [:a, :b, :c]
a3 = ["X", "Y"]
p a1.zip(a2, a3) #=> [[1, :a, "X"], [2, :b, "Y"], [3, :c, nil]]
|
| その他 |
`length`, `size`, `count`, `empty?`, `sample`, `permutation`, `combination`, `rotate` |
要素数、指定要素 or 条件に合う要素の数 (`count`)、空かの判定、ランダムな要素取得 (`sample`)、順列 (`permutation`)、組み合わせ (`combination`)、要素のローテーション (`rotate`)。
arr = [1, 2, 3, 2, 1]
p arr.length #=> 5
p arr.size #=> 5
p arr.count(2) #=> 2 (要素2の数)
p arr.count { |x| x > 1 } #=> 3 (条件に合う要素の数)
p [].empty? #=> true
p arr.sample #=> (ランダムな1要素)
p arr.sample(2) #=> (ランダムな2要素の配列)
p [1, 2, 3].permutation.to_a
#=> [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
p [1, 2, 3].combination(2).to_a
#=> [[1, 2], [1, 3], [2, 3]]
a = [1, 2, 3, 4]
p a.rotate #=> [2, 3, 4, 1] (非破壊)
p a.rotate(2) #=> [3, 4, 1, 2]
p a.rotate(-1) #=> [4, 1, 2, 3]
a.rotate! # 破壊的ローテーション
p a #=> [2, 3, 4, 1]
|
コメント