独学Ruby - 基礎（Arrayクラス）

Ruby プログラミング

配列クラス(Array)

  • 配列の作り方
  • インデックスの使い方
  • 集合としての配列
  • 列としての配列

配列の作り方

  • 基本
# 基本
my_array = [1, 2, 3, "1", "2", "3"]
p my_array

[1, 2, 3, "1", "2", "3"]
  • Array.new(要素数, 初期値)
#  Array.new
my_array = Array.new
p my_array

my_array = Array.new(6)
p my_array

my_array = Array.new(6, 0)
p my_array

[]
[nil, nil, nil, nil, nil, nil]
[0, 0, 0, 0, 0, 0]
  • %w
#  %w
lang = %w(RUby Perl Python Scheme Pke REBOL)
p lang

["RUby", "Perl", "Python", "Scheme", "Pke", "REBOL"]

  • to_aメソッド

    多くのクラスで定義されており、オブジェクトを配列に変換する

# to_aメソッド
color_table = {"block"=>"#000000", "white"=>"#FFFFFF"}
p color_table.to_a

[["block", "#000000"], ["white", "#FFFFFF"]]

  • splitメソッド

    カンマや空白で区切られた文字列から配列を作る

# splitメソッド
column = "2010/01/09 22:33 foo.html proxy.example.jp".split()
p column

column = "2010/01/09 22:33 foo.html proxy.example.jp".split(" ")
p column

column = "2010/01/09,22:33,foo.html,proxy.example.jp".split(",")
p column

["2010/01/09", "22:33", "foo.html", "proxy.example.jp"]
["2010/01/09", "22:33", "foo.html", "proxy.example.jp"]
["2010/01/09", "22:33", "foo.html", "proxy.example.jp"]

インデックスの使い方

要素を取り出す

  • 添え字指定
my_array = [1 ,2 ,3 ,4, 5, 6]
p my_array[0]

# マイナスインデックス
p my_array[-1]

# 範囲指定
p my_array[0..2]
p my_array[0, 3]

1
6
[1, 2, 3]
[1, 2, 3]
  • atメソッド
# atメソッド
p my_array.at(0)
p my_array[0]
  • sliceメソッド
# sliceメソッド
p my_array.slice(1)
p my_array[1]

p my_array.slice(-1)
p my_array[-1]

p my_array.slice(0..2) 
p my_array[0..2]

p my_array.slice(0, 3)
p my_array[0, 3]

要素を置き換える

alpha = ["a", "b", "c", "d", "e", "f"]
p alpha

alpha[2, 3] = ["C", "D", "E"]
p alpha

alpha[0..1] = ["A", "B"]
p alpha

alpha[-1] = "F"
p alpha

["a", "b", "c", "d", "e", "f"]
["a", "b", "C", "D", "E", "f"]
["A", "B", "C", "D", "E", "f"]
["A", "B", "C", "D", "E", "F"]

要素を挿入する

alpha = ["a", "b", "c", "d", "e", "f"]
p alpha

alpha[2, 0] = ["X", "Y"]
p alpha

["a", "b", "c", "d", "e", "f"]
["a", "b", "X", "Y", "c", "d", "e", "f"]

複数のインデックスから配列をつくる

  • values_atメソッド
alpha = %w(a b c d e f)
p alpha

p alpha.values_at(1, 3 ,5)

["a", "b", "c", "d", "e", "f"]
["b", "d", "f"]

集合としての配列

  • 共通集合
  • 和集合
  • 差集合
# 共通集合 (AND, OR)
ary1 = ["a", "b", "c"]
ary2 = ["b"]
p (ary1 & ary2)
p (ary1 | ary2)
p ary1 + ary2
p ary1 - ary2

# 和差演算
ary1 = [1, 2, 3]
ary2 = [4, 3, 2]
p (ary1 & ary2)
p (ary1 | ary2)
p ary1 + ary2
p ary1 - ary2

["b"]
["a", "b", "c"]
["a", "b", "c", "b"]
["a", "c"]

[2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4, 3, 2]
[1]

列としての配列

  • キュー
  • スタック
機能 先頭に要素を追加する操作 末尾に要素を追加する操作
要素を加える unshift push
要素を取り除く shift pop
要素を参照する first last 
alpha = ["a", "b", "c", "d", "e"]
p alpha

# 末尾に要素を追加する
p alpha.push("f")

# 末尾から要素を取り除く
p alpha.pop

# 末尾の要素を参照する
p alpha.last

# 先頭に要素を追加する
p alpha.unshift("F")

# 先頭から要素を取り除く
p alpha.shift

# 先頭の要素を参照する
p alpha.first

["a", "b", "c", "d", "e"]
["a", "b", "c", "d", "e", "f"]
"f"
"e"
["F", "a", "b", "c", "d", "e"]
"F"
"a"

配列操作メソッド

機能 メソッド
配列の先頭に新しい要素を付け加える a.unshift(item)
配列の末尾に新しい要素を付け加える a << item
a.push(item)
配列aに配列bを連結する a.concat(b)
a+b
配列から要素(nil)を取り除く a.compact
a.compact!
配列から要素(x)を取り除く a.delete(x)
配列からn番目の要素を取り除く a.delete_at(n)
配列から条件を満たす要素を取り除く a.delete_if{|item|...}
a.reject{|item|...}
a.reject!{|item|...} 
# obj.unshift(item)
a = [1,2,3,4,5]
p a
a.unshift(0)
p a

p "-----------------"

# a << item
a = [1,2,3,4,5]
p a
a << 6
p a

p "-----------------"

# a.push(item)
a = [1,2,3,4,5]
p a
a.push(6)
p a

p "-----------------"

# a.concat(b)
a = [1,2,3]
b = [4,5,6]
print "a=", a, "b=", b , "\n"
c = a.concat(b)
print "c=", c, "\n"

p "-----------------"

# a+b
a = [1,2,3]
b = [4,5,6]
print "a=", a, "b=", b , "\n"
c = a + b
print "c=", c, "\n"

# a.compact
a = [1, nil, 3, nil, nil]
b = a.compact
print "a=", a, "b=", b,"\n"
a.compact!
print "a=", a, "b=", b,"\n"

p "-----------------"

# delete
a = [1, 2, 3, 2, 1]
p a
del_value = a.delete(2)
p del_value
p a


p "-----------------"

# delete_at
a = [1, 2, 3, 2, 1]
p a
del_value = a.delete_at(0)
p del_value
p a

p "-----------------"

# delete_if
a = [1, 2, 3, 2, 1]
b = a.delete_if{|i| i >= 2}
p b

p "-----------------"

# reject, reject!
a = [1, 2, 3, 2, 1]
b = a.reject{|i| i >= 2}
p b

a = [1, 2, 3, 2, 1]
b = a.reject!{|i| i >= 2}
p b