#初始化
a = Array.new
p a #=>[]
a = Array.new(5)
p a #=>[nil, nil, nil, nil, nil]
a = Array.new(5,0)
p a #=>[0, 0, 0, 0, 0]
city = ["北京", "上海", "廣州"]
p city #=> ["北京", "上海", "廣州"]
puts city #=>北京
#=>上海
#=>廣州
city = Array.new
city[0] = "北京"
city[1] = "上海"
city[2] = "廣州"
p city #=> ["北京", "上海", "廣州"]
city = %w(北京 上海 廣州)
p city #=> ["北京", "上海", "廣州"]
#使用split函數進行分隔
city = '北京,上海,廣州'.split(',')
p city #=> ["北京", "上海", "廣州"]
#使用%W{...}將字符串轉換成數組
str = "深圳"
city_1 = %W{北京 上海 廣州 #{str}}
p city_1 #=>["北京", "上海", "廣州", "深圳"]
#使用%w{...}進行轉換
str = "深圳"
city_2 = %w{北京 上海 廣州 #{str}}
p city_2 #=>["北京", "上海", "廣州", "\#{str}"]
r = 1..5 # Range
#使用to_a、entries將范圍類型數據轉換成數組
p r.to_a # Array， to_a等同於entries #=> [1, 2, 3, 4, 5]
p r.entries #=> [1, 2, 3, 4, 5]
r = 'a'..'e'
p r.to_a #=> ["a", "b", "c", "d", "e"]
#基本操作
#數組的長度會按需要自動增加
city = Array.new
puts "數組的長度為：" + city.size.to_s #0
city[2] = "香港"
puts "數組的長度為：" + city.size.to_s #3
p city #=> [nil, nil, "香港"]
city = ["北京", "上海", "廣州", "深圳"]
#對一個元素賦值
city[4] = "香港"
#得到數組長度
puts "數組的長度為：" + city.size.to_s #=> 數組的長度為：5
puts "數組的長度為：" + city.length.to_s #5
puts "數組的長度為：" + city.count.to_s #5
p city #=> ["北京", "上海", "廣州", "深圳", "香港"]
#獲取某一元素
puts "第二個元素為：" + city[1] #上海
puts "倒數第二個元素為：" + city[-2] #深圳
college = ["北京大學", "清華大學"]
college.unshift("浙江大學", "復旦大學") #向數組頭部添加元素列表
college.push("南京大學", "武漢大學") #向數組尾部添加元素列表
college << "南開大學" #向數組尾部添加一個元素
puts college.size.to_s #=> 7
p college #=> ["浙江大學", "復旦大學", "北京大學", "清華大學", "南京大學", "武漢大學", "南開大學"]
#獲取數組第一個元素，first(n),取前n個元素
p college.first #=> "浙江大學"
p college.first(3) #=> ["浙江大學", "復旦大學", "北京大學"]
#獲取數組最后一個元素，last(n),取后n個元素
p college.last #=> "南開大學"
p college.last(3) #=> ["南京大學", "武漢大學", "南開大學"]
puts college.shift #刪除並獲取數組第一個元素
puts college.pop #刪除並獲取數組最后一個元素，pop和push組合起來可以把一個Array直接當成Stack
puts college.size.to_s #=> 5
p college #=> ["復旦大學", "北京大學", "清華大學", "南京大學", "武漢大學"]
p college[2,3] #截取從索引2開始，長度為3的元素列表
p college[2..3] #截取從索引2開始，到索引3的元素列表
p college[2...3] #截取從索引2開始，到索引3(不包括)的元素列表
city_1 = ["北京", "上海", "廣州"]
city_2 = ["香港", "澳門"]
city_3 = city_1 + city_2
puts city_3.size.to_s #=> 5
city_1.concat(city_2)
puts city_1.size.to_s #=> 5
#兩數組相連 +/concat
#a.concat(b)，連結，得到a中所有數據和b中所有數據組成的數組，並保存在a中，a變b不變
p ["北京", "上海", "廣州"].concat(["廣州", "香港", "澳門"]) #=> ["北京", "上海", "廣州", "廣州", "香港", "澳門"]
#a + b，和集，得到a中所有數據和b中所有數據組成的數組，a、b均不變
p ["北京", "上海", "廣州"] + ["廣州", "香港", "澳門"] #=> ["北京", "上海", "廣州", "廣州", "香港", "澳門"]
#a - b，差集，得到由a中元素去除同時存在於a數組和b數組中的元素后剩余元素組成的數組
p ["北京", "上海", "廣州"] - ["北京", "香港", "澳門"] #=> ["上海", "廣州"]
#p&b，交集，取兩個數組中都存在的元素，等於 a - (a - b)和b - (b - a)
p (["北京", "上海", "廣州"] & ["北京", "香港", "澳門"]) #=> ["北京"]
#a|b，並集，合並兩個數組，並保證元素的唯一性，等於(a - b) + (b - a) + a&b
p (["北京", "上海", "上海", "廣州"] | ["北京", "香港", "澳門"]) #=> ["北京", "上海", "廣州", "香港", "澳門"]
#include?(obj)，判斷數組元素中是否包含指定對象
citys = ["北京", "上海", "廣州", "香港", "澳門"]
puts citys.include? "上海" #=> true
#delete(X)，刪除數組中所有與X相同的元素， 返回X
citys = ["北京", "上海", "廣州", "北京", "香港", "澳門"]
p citys.delete("北京") #=> "北京"
p citys #=> ["上海", "廣州", "香港", "澳門"]
#delete_at(n)，刪除第n個元素，返回被刪除的元素對象
citys = ["北京", "上海", "廣州", "北京", "香港", "澳門"]
p citys.delete_at(3) #=> "北京"
p citys #=> ["北京", "上海", "廣州", "香港", "澳門"]
#delete_if，刪除滿足條件的元素，返回處理后的原數組
abc = [ "a", "b", "b", "b", "c" ]
p abc.delete_if {|x| x >= "b" } #=> ["a"]
#slice/each_slice/each_cons
#slice(m, n)返回原數組中下標為m到下標為n之間的元素組成的數組
#slice!(m, n)，同時改變原數組，從原數組中刪除返回的元素
citys = ["北京", "上海", "廣州", "香港", "澳門"]
p citys.slice(1, 3) #=> ["上海", "廣州", "香港"]
p citys #=> ["北京", "上海", "廣州", "香港", "澳門"]
p citys.slice!(1, 3) #=> ["上海", "廣州", "香港"]
p citys #=> ["北京", "澳門"]
#each_slice，迭代取出間隔分割的數組，返回nil
citys = ["北京", "上海", "廣州", "香港", "澳門"]
citys.each_slice(2){|city|
p city
}
#=> ["北京", "上海"]
#=> ["廣州", "香港"]
#=> ["澳門"]
#each_cons，迭代取出滑動分組的數組，返回nil
citys = ["北京", "上海", "廣州", "香港", "澳門"]
citys.each_cons(2){|city|
p city
}
#=> ["北京", "上海"]
#=> ["上海", "廣州"]
#=> ["廣州", "香港"]
#=> ["香港", "澳門"]
#insert(n, obj)，在某序列前插入元素對象，改變原數組
citys = ["北京", "上海", "廣州", "香港", "澳門"]
p citys.insert(2, "2") #=> ["北京", "上海", "2", "廣州", "香港", "澳門"]
p citys #=> ["北京", "上海", "2", "廣州", "香港", "澳門"]
#a[n..m]，選擇改變數組
citys = ["北京", "上海", "廣州", "香港", "澳門"]
citys[1..3] = [1, 2, 3]
p citys #=> ["北京", 1, 2, 3, "澳門"]
#Array.flatten，將數組中類型為數組的元素中的所有元素取出插入原數組中
#重復這個操作，直到原數組中所有的元素的數據類型均不為數組
#Array.flatten(n)，重復n次轉變操作，結束后數組中元素仍可能為數組
nums = [[1, 2], [[2, 3], [3, 4]], 6]
p nums.flatten #=> [1, 2, 2, 3, 3, 4, 6]
s = [ 1, 2, 3 ] # [1, 2, 3]
t = [ 4, 5, 6, [7, 8] ] # [4, 5, 6, [7, 8]]
a = [ s, t, 9, 10 ] # [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
p a.flatten #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = [ 1, 2, [3, [4, 5] ] ]
p a.flatten(1) #=> [1, 2, 3, [4, 5]]
p a.flatten #=> [1, 2, 3, 4, 5]
#去重
nums = [1, 1, 2, 2, 3, 3]
p a.uniq #去除重復的元素，保證元素唯一 #=>[1, 2, 3]
#排序
arr = [9, 8, 7, 1, 2, 5, 3]
p arr.sort #=> [1, 2, 3, 5, 7, 8, 9]
p arr #=> [9, 8, 7, 1, 2, 5, 3]
p arr.sort! #=> [1, 2, 3, 5, 7, 8, 9]
p arr #=> [1, 2, 3, 5, 7, 8, 9]
p arr.sort{|a, b| b<=>a} #=> [9, 8, 7, 5, 3, 2, 1]
wuwei = ['酸', '甘', '苦', '辛', '咸']
#min/min_by/max/max_by取最小/大值，均不改變原數組
#minmax/minmax_by，返回最小值、最大值組成的數組，均不改變原數組
puts wuwei.min #=> 咸
#取最大值
puts wuwei.max #=> 酸
puts wuwei.min_by{|v| #=> 咸
v = '0'
}
puts wuwei.max_by{|w| #=> 酸
w = '1'
}
p wuwei #=> ["酸", "甘", "苦", "辛", "咸"]
p wuwei.minmax #=> ["咸", "酸"]
p wuwei.minmax_by{|w| #=> ["咸", "酸"]
w
}
#shuffle，打亂元素順序， 隨機變化（ 洗牌）
nums = [ 1, 2, 3 ]
p nums.shuffle #=> [2, 3, 1]
p nums.shuffle #=> [3, 2, 1]
p nums.shuffle #=> [1, 3, 2]
p nums.shuffle #=> [1, 3, 2]
#遍歷
#each/each_with_index/cycle/cycle(n)
#each/each()依次取出每一個元素，每次取出的一個元素可以被
#跟隨的塊函數接收，返回原數組；each_with_index/each_with_index()得到
#元素的同時還得到當前元素在數組中的序列值，返回原數組
#cycle，除非遇到break、return、exit等語句，否則無限循環數組，返回nil
#cycle(n)，除非遇到break、return、exit等語句，否則循環數組n次，返回nil
nums = [1, 2, 3]
b = nums.each{|value| p value} #=>1
#=>2
#=>3
puts b #=> [1, 2, 3]
nums.each_with_index do |value, index|
puts "#{index} : #{value}"
puts ( value + index ).to_s
end
#=>0 : 1
#=>1
#=>1 : 2
#=>3
#=>2 : 3
#=>5
abc = ('a'..'c').to_a
#abc.cycle {|x| puts x } # a, b, c, a, b, c,.. forever.
abc.cycle(2) {|x| puts x } # a, b, c, a, b, c.
#reduce,別名inject，迭代累加/減，不改變原數組
#inject理解的難點在於block中的兩個參數
#sum是上一次block的返回值，默認初始化為0或nil
#可以傳入初始值c
#value是當前的元素對象
arry = (1..3).to_a
n = arry.reduce(:+)
puts n #=>6
n = arry.reduce(:-)
puts n #=>-4
#帶有初始值的累加
c = 10
n = arry.reduce(c) do |sum, value|
p sum
sum + value
end
puts n
#=>10
#=>11
#=>13
#=>16
puts n = arry.inject(:+) #=> 6
abc = ('a'..'c').to_a
puts abc.inject(:+) #=> abc
puts abc.inject('A') {|sum, value| sum + value } #=> Aabc
#join 返回由數組中各元素連結成的一個字符串，原數組不變
abc = ['a', 'b', 'c']
p abc.join #=> "abc"
p abc.join('-') #=> "a-b-c"
p abc #=> ["a", "b", "c"]
#map, 別名collect，處理數組中的每一個元素並放入新數組中，返回新數組
#map!、collect!將同時改變原數組
arry = %w(a b cD)
p arry #=> ["a", "b", "cD"]
s1 = arry.reduce(:+)
s2 = arry.map(&:upcase)
s3 = arry.map do |item|
item.upcase
end
p arry
p s1
p s2
p s3
#=>["a", "b", "cD"]
#=>"abcD"
#=>["A", "B", "CD"]
#=>["A", "B", "CD"]
#find/find_all/select
# find到一個即返回，別名detect
rs = (1..8).to_a.find {|i|
i % 2 == 0 and i % 4 == 0
}
p rs #=> 4
# find_all找到全部符合條件的對象，別名select
rs = (1..8).to_a.find_all {|i|
i % 2 == 0 and i % 4 == 0
}
p rs #=> [4, 8]
# select，找到全部符合條件的對象，別名find_all
arry = (1..8).to_a
arrySelect = arry.select { |x|
x % 2 == 0
}
puts arrySelect.to_s #=> [2, 4, 6, 8]
#take(n)/take_while/drop(n)/drop_while
#取前n個元素/取滿足條件的元素/取除去前n個元素剩余的元素/取除去滿足條件的元素剩余的元素
#返回這些元素組成的數組，不改變原數組
a = ["北京", "上海", "廣州", "香港", "澳門"]
p b = a.take(2) #=> ["北京", "上海"]
p a #=> ["北京", "上海", "廣州", "香港", "澳門"]
p b = a.drop(2) #=> ["廣州", "香港", "澳門"]
b = a.take_while{|value|
value == '北京'
}
p b #=> ["北京"]
b = a.drop_while{|value|
value == '北京'
}
p b #=> ["上海", "廣州", "香港", "澳門"]
# reject，迭代數組元素，從原數組中刪除符合條件的元素對象，改變原數組，返回處理后的數組
arry = (1..8).to_a
arryReject = arry.reject { |x| x % 2 == 0 }
puts arryReject.to_s #=> [1, 3, 5, 7]
#根據條件分組，分組后得到哈希表
arry = (1..8).to_a
arryGroupBy = arry.group_by{ |x| x % 2 == 0 }
puts arryGroupBy #=> {false=>[1, 3, 5, 7], true=>[2, 4, 6, 8]}
puts arryGroupBy.class #=> Hash
value = arryGroupBy[false]
p value #=> [1, 3, 5, 7]
puts value.class #=> Array
arryGroupBy = arry.group_by{ |x| 2 }
puts arryGroupBy #=> {2=>[1, 2, 3, 4, 5, 6, 7, 8]}
value = arryGroupBy[2]
p value #=> [1, 2, 3, 4, 5, 6, 7, 8]
puts value.class #=>Array
#zip(Array,...)，遍歷數組，對每個元素，從各個數組參數中取出與其序列相同的元素，組成新的
#數組作為代碼塊的傳入參數，返回nil
a = [1, 4, 7]
b = [2, 5, 8]
c = [3, 6, 9]
d = a.zip(b, c){|e|
p e
e
}
p d
#=> [1, 2, 3]
#=> [4, 5, 6]
#=> [7, 8, 9]
#=> nil
#to_enum，轉變成枚舉類型，這樣可以使用next
#不改變原數組，返回生成的枚舉對象
p f = a.to_enum #=> #<Enumerator: [1, 4, 7]:each>
p a #=> [1, 4, 7]
p f.next #=> 1
p f.next #=> 4
#all?/any?/none?/one?
#迭代取出元素並代入代碼塊，代碼塊均返回真？/
#迭代取出元素並代入代碼塊，代碼塊至少有一次返回真？/
#迭代取出元素並代入代碼塊，代碼塊均不返回真？/
#迭代取出元素並代入代碼塊，代碼塊有且僅有一次返回真？
#返回真或假，原數組內容不變
wuxing = ['金', '木', '水', '火', '土']
puts wuxing.all?{|value| #=> false
value == '木'
}
puts wuxing.any?{|value| #=> true
value == '木'
}
puts wuxing.all?{|value| #=> true
value = '木'
}
p wuxing #=> ["金", "木", "水", "火", "土"]
以上是根據個人的理解總結的一些方法，有理解不到位或錯誤的地方還請大家指正。