1206yaya
3/9/2015 - 6:44 AM

Rubyメモ

Rubyメモ



### 配列の要素を削除する
# delete_at, delete_if, reject!, delete, clear, slice!, shift, pop, -
list1 = [0, 1, nil, nil,2, 3, 4, 5, 6, 7, 7, 7]

p list1.shift # 0
p list1 # [1, nil, nil, 2, 3, 4, 5, 6, 7, 7, 7]
p list1.shift(2) # [1, nil]
p list1 # [nil, 2, 3, 4, 5, 6, 7, 7, 7]
p list1.pop # 7
p list1 # [nil, 2, 3, 4, 5, 6, 7, 7]
p list1.pop(2) # [7, 7]
p list1 # [nil, 2, 3, 4, 5, 6]
# nil を取り除く
list1.compact!
p list1 # [2, 3, 4, 5, 6]

list1.delete(6)
p list1 # [2, 3, 4, 5]

list1.delete_at(1)
p list1 # [2, 4, 5]

p list1 - [4,5] # [2]
p list1 # [2, 4, 5]
list1.clear
p list1 # []

### 配列に要素を追加する
# unshift, push, <<, concat(配列を追加する)
# +(配列を追加する)
list2 = ["b", "c"]

list2.unshift("First")
p list2 # ["First", "b", "c"] # ["First", "b", "c"]

list2.push("Last")
p list2 # ["First", "b", "c", "Last"] # ["First", "b", "c", "Last"]

list2 << "<<"
p list2 # ["First", "b", "c", "Last", "<<"] # ["First", "b", "c", "Last", "<<"]

list2.concat(["array_concat1", "array_concat2"])
p list2 # ["First", "b", "c", "Last", "<<", "array_concat1", "array_concat2"] # ["First", "b", "c", "Last", "<<", "array_concat1", "array_concat2"]

list2.pop; list2.pop
p list2 # ["First", "b", "c", "Last", "<<"] # ["First", "b", "c", "Last", "<<"]

# 「+」非破壊的メソッド
p list2 + ["+", "+"] # ["First", "b", "c", "Last", "<<", "+", "+"] # ["First", "b", "c", "Last", "<<", "+", "+"]
p list2 # ["First", "b", "c", "Last", "<<"] 

### 配列の要素を参照する
# [], slice, values_at, at, fetch, first, last, assoc, rassoc
list3 = [0, 1, 2, 3, 4, 5, 6, 7]

p list3.at(1) # 1
p list3.at(10) # nil

p list3.fetch(1) # 1
p list3.fetch(10, "ERROR") # "ERROR"
p list3.fetch(10){|n| "ERROR #{n}"} # "ERROR 10"

p list3.first(3) # [0, 1, 2]
# assoc 配列の配列の最初の要素が == で等しければ配列を返し、なければnil
list4 = [[1,2],[3,4],[5,6]]
p list4.assoc(3) # [3, 4]

# rassoc 配列の配列のインデックス1の要素が == で等しければ配列を返し、なければnil
list4 = [[1,2],[3,4],[5,6]]
p list4.rassoc(4) # [3, 4]

### 列の要素を調べる
# include?, index, rindex
list4 = [0, 1, 2, 3, 4, 5, 6, 7]
p list4.index(4) # 4
p list4.rindex(4) # 4

### 配列の演算(集合的)
# | &
p [1,2,3] | [1,3,5] # [1, 2, 3, 5]
p [1,2,3] & [1,3,5] # [1, 3]

### 列の要素での繰り返し
# each, each_index, cycle, reverse_each

# [1,2,3].cycle{|n| puts n} # 無限ループ

### 列の長さを求める
p [1, nil, nil].length # 3
p [1, nil, nil].count # 3

### 配列をソートする
list5 = [1,3,2,6,4]
p list5.sort{|a, b| a <=> b} # [1, 2, 3, 4, 6]
p list5.sort{|a, b| b <=> a} # [6, 4, 3, 2, 1]

### 配列を変換する
# uniq, compact, reverse, flatten, collect, map, shuffle

p [[[1,2], 3], [[4,5],6]].flatten(1) # [[1, 2], 3, [4, 5], 6] 

### 配列を組み合わせて生成する
# product, zip, *

p [1, 2].product(["a", "b", "c"]) # [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"], [2, "c"]] 

p [1, 2].zip(["a", "b"]) # [[1, "a"], [2, "b"]]
p [1, 2].zip(["a", "b"], ["x", "y"]) # [[1, "a", "x"], [2, "b", "y"]]

p [1, 2] * 4 # [1, 2, 1, 2, 1, 2, 1, 2]

# 正規表現オブジェクトの生成方法
p /Ruby/ # /Ruby/
p %r(Ruby) # /Ruby/
p %r|Ruby| # /Ruby/
p Regexp.new("Ruby") # /Ruby/

p /bb/ =~ "aabbcc" # 2

# 直前の正規表現のマッチした文字より前方を格納
p $` # "aa"
# 直前の正規表現のマッチした文字を格納
p $& # "bb"
# 直前の正規表現のマッチした文字より後方を格納
p $' # "cc"

p /a{2,}b/ === "aab"
### 「 | 」or条件
p /^(aa|bb)c$/ === "aac" # true
p /^(aa|bb)c$/ === "bbc" # true

### 「 [] 」文字列集合
p /a[bcd]e[fg]h/ === "abegh" # true

### 正規表現記号
# 「¥d」数字
p /a\db/ === "a2b" # true

## 繰り返死を表現する正規表現記号
# 「*」直前の文字の0回以上の繰り返し
p /a(bc)*d/ === "abcbcd" # true

### 正規表現後方参照 ()でグループ化した正規表現にマッチした結果は、特殊変数で取り出せる。
%r|(http://www(@)(.*)/)| =~ "http://www@xyz.org/"
p $0 # "/Users/aya/RubymineProjects/RubyCoding/sikaku/ch03_reg.rb"
p $1 # "http://www.xyz.org/" # 「$1」最初の正規表現グループにマッチした文字列を保持
p $2 # "@"
p $3 # "xyz.org"
p $4 # nil

%r|(http://www(\.)(.*)/)| =~ "http://www.xyz.org/"
p $0 # "/Users/aya/RubymineProjects/RubyCoding/sikaku/ch03_reg.rb"
p $1 # "http://www.xyz.org/" # 「$1」最初の正規表現グループにマッチした文字列を保持
p $2 # "."
p $3 # "xyz.org"
p $4 # nil

### 正規表現のオプション
# 「i」大文字と小文字を区別しない
p /ruby/i === "RUBY" # true

# 「m」正規表現記号「.」が改行にもマッチするようにする
p /a.*b/ === "a\nb" # false
p /a.*b/m === "a\nb" # true
### 変数の参照について
v1 = "foo1"
v2 = v1
p v1.object_id # 70184282982480
p v2.object_id # 70184282982480
p v1.equal?(v2) # true

# 何らかの操作後は、メモリを共有している他の変数に影響を与えず
# 新たに作成されたオブジェクトを指す
v1 += "foo2"
p v1 # "foo1foo2"
p v1.object_id # 70184282981320
p v2 # "foo1"
p v2.object_id # 70184282982480

v2 = v1
# 非破壊的メソッド
p v1.chop # "foo1foo"
p v2 # "foo1foo2"

p v1.object_id # 70184282981320
p v2.object_id # 70184282981320

### 破壊的メソッド
# 何らかの操作後は、メモリを共有している他の変数にも影響を与え
# 同じメモリに居続ける
p v1.object_id # 70184282981320
p v1.chop! # "foo1foo"
p v1.object_id # 70184282981320

p v2 # "foo1foo"
p v2.object_id # 70184282981320
### シンボル
# シンボルは同じ参照を共有する
p "foo1".object_id # 70124153420240
p "foo1".object_id # 70124153419760

p :foo1.object_id # 1079208
p :foo1.object_id # 1079208
p :foo2.object_id # 510088

### 比較の強さ
# equal? > eql? > ==
# 参照 > 型 and オブジェクト内容 > オブジェクト内容

# == は オブジェクトが等しいかどうか
# equal? は 参照が等しいかどうか
p "foo1" == "foo1" # true
p "foo1".equal?("foo1") # false

p :foo1 == :foo1 # true
p :foo1.equal?(:foo1) # true

# eql? は 型とオブジェクトが等しいかどうか
p "foo1".eql?("foo1") # true
p "foo1".eql?("foo2") # false

p 1.0 == 1 # true
p (1.0).eql?(1) # false
p (1.0).eql?(1.0) # true