注意，Array类中包含了Enumerable模块，所以Enumerable中的方法也都能使用，例如Enumerable中非常好用的reduce()方法。

创建arr时，允许解析表达式。例如，范围表达式、变量等。

1
2
3
4
5

[-10...0, 0..10]
[-5...0, 0..5][0].to_a #=> [-5, -4, -3, -2, -1]

a=10;b=20
c=[a, b]

其中上面表示Range的 -5...0 和 0..5 区别在于前者不包含尾边界，即它是左闭右开的，而后者是左右都闭。

1
2
3

ary = Array.new    #=> []
Array.new(3)       #=> [nil, nil, nil]
Array.new(3, true) #=> [true, true, true]

当new()指定了第二个参数时，各初始化的元素将 指向同一个对象 。

1
2

arr=Array.new(3, "abc")
arr[1][0]="A"   #=> ["Abc", "Abc", "Abc"]

例如，初始化互不影响的3个『abc』元素数组。

1
2
3

arr = Array.new(3) {"abc"}
arr[0][1]="A"
p arr          # ["aAc", "abc", "abc"]

多维数组：

1

Array.new(3){Array.new(2)} #=> [[nil, nil], [nil, nil], [nil, nil]]

1
2
3

{:a => "a", :b => "b"}.to_a   #=> [[:a, "a"], [:b, "b"]]
Array({:a => "a", :b => "b"}) #=> [[:a, "a"], [:b, "b"]]
Array(1..5)  #=> [1, 2, 3, 4, 5]

关于它的内部逻辑，稍做演示。例如，String类既没有to_ary，也没有to_a方法：

1
2
3
4
5
6
7
8
9
10

"a".methods.grep(/to_a|to_ary/)  #=> []

mystr = "hello world"
Array(mystr)    #=> ["hello world"]


def mystr.to_a
  split(/ /)
end
Array(mystr)  #=> ["hello", "world"]

由于 arr[] 提供的功能已经足够丰富，所以at()方法和slice()方法很少用。

如果索引越界，则返回nil。但是有一个特殊情况，当使用slice的操作时，因为要返回的是数组，所以有如下”异常”情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

a = %w(a b c d e)
a[4]       #=>"e"
a[4,0]     #=>[]
a[4,1]     #=>["e"]
a[4..100]  #=>["e"]

a[5]       #=>nil
a[5,0]     #=>[]
a[5,1]     #=>[]
a[5..100]  #=>[]

a[6]       #=>nil
a[6,0]     #=>nil
a[6,1]     #=>nil

上面a[5]返回nil，但a[5,x]返回空数组，而a[6]以及a[6,x]则直接返回nil。首先a[6]以及a[6,x]都是索引越界，所以返回nil。而a[5]的5是索引越界，所以返回nil。问题是a[5,x]返回的是空数组，而不是nil。这是因为a[5,x]是一个slice操作，它要求返回新数组。从下面的slice操作可以理解为什么a[5,1]返回空数组。

1
2
3
4
5
6
7

p a[0, 5]   # ["a", "b", "c", "d", "e"]
p a[1, 4]   # ["b", "c", "d", "e"]
p a[2, 3]   # ["c", "d", "e"]
p a[3, 2]   # ["d", "e"]
p a[4, 1]   # ["e"]
p a[5, 0]   # []
p a[5, 1]   # []

也就是说，对于slice操作，arr[len, x]的arr[len]可以认为是最边缘的元素，尽管arr[len]已经越界了。

其实 slice() 是按规则删除元素，只不过它不影响原始数组。而 slice!() 则是删除一些元素并直接影响原始数组，也就是在原处修改数组。

1
2

a = [1, 2, 3, 4]
a.slice!(1,2)  # 返回:[2, 3]，a变成[1, 4]

因为通过索引方式取值时，索引越界时默认会返回nil。因此还定义了另一个方法fetch，它会在索引越界时直接报错或指定默认返回信息：

1
2
3
4
5
6
7

arr = [11,22,33,44]
arr.fetch(-1)          #=> 44
arr.fetch(3)           #=> 44
arr.fetch(4)           # 报错
arr.fetch(4,"cat")     #=> "cat"
arr.fetch(4) {|idx| puts "index #{idx} out of bounds"}
#=>index 4 out of bounds

1
2
3
4
5

a = %w(a b c d e)
p a.values_at(1)          # ["b"]
p a.values_at(0, 0, 2, 4) # ["a", "a", "c", "e"]
p a.values_at(1, 2, 10)   # ["b", "c", nil]
p a.values_at(1..3)       # ["b", "c", "d"]

除了这种方式可以取得分散元素，还可以使用map()函数进行操作。例如，等价于 values_at(0,0,2,4,10) 的写法为：

1

p [0, 0, 2, 4, 10].map{|i| a[i]}

1
2
3

a=%w(a b c d e)
p a.fetch(10)  # 报错：索引越界IndexError
p a.fetch(10, "ten") # 指定默认值

使用first()和last()可以取得数组中的第一个元素和最后一个元素，它们会取得元素后立即退出。

1
2
3

a = %w(a b c d e)
p a.first     # "a"
p a.last      # "e"

使用take()可以取得数组中的前n个元素，使用drop()可以取得除了数组前n个元素外剩下的元素。它们都不会删除元素。因为不改变原数组，所以它们的时间复杂度都是O(n)，其中n为所返回元素个数。

1
2
3
4

a = %w(a b c d e f)
p a.take(2)  # ["a", "b"]
p a.drop(2)  # ["c", "d", "e", "f"]
p a          # ["a", "b", "c", "d", "e", "f"]

它们返回的都是数组，只不过一些是原地修改，一些是返回新的数组对象。

复杂的三角恋
在array中，filter和select等价，在Enumerable中也有filter、select和find_all，它们等价。
此外，Enumerable中的find是find_all的单元素版，等价于Enumerable的detect。

1
2
3
4
5
6
7
8

arr = [1, 2, 3, 4, 5, 6]
new_arr = arr.select {|a| a > 3}
p new_arr      # [4, 5, 6]
p arr          # [1, 2, 3, 4, 5, 6]

new_arr = arr.select! {|a| a > 3}
p new_arr      # [4, 5, 6]
p arr          # [4, 5, 6]

1
2
3
4
5
6
7
8

arr = [1, 2, 3, 4, 5, 6]
new_arr = arr.reject {|a| a > 3}
p new_arr      # [1, 2, 3]
p arr          # [1, 2, 3, 4, 5, 6]

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

a = %w(a b c d e)

# 单元素赋值
a[1] = "bb"  # 为第2个元素赋值

# 范围赋值
a[1, 2] = ["bb", "cc"]  # a=%w(a bb cc d e)
a[1, 2] = %w(bb)  # a=%w(a bb d e)
a[1, 2] = %w(bb cc dd)  # a=%w(a bb cc dd d e)

# 完全插入元素：指定len为0
a[1, 0] = %w(B C) # a=%w(a B C b c d e)
a[-1,0] = "f"     # 不是插入在数组尾部，而是倒数第二个位置

# 范围赋值替换
a[1..1] = "e"     # 替换第二个元素
a[-1..-1] = "e"   # 替换尾部元素

# 完全删除元素：将右边对象设置为空数组
a[1, 2] = []  # a=%w(a d e)

赋值语句的返回值是所赋值内容。例如 a[1,0] = %w[B C] 的返回值是 %w[B C] ，于此同时原始数组被修改。

需要注意，当使用数组子集赋值(即使用范围索引 arr[x..y] 或 arr[x,y] )时，等号右边的内容将展开对各个范围内的元素进行赋值。但如果是对单个元素赋值，则是将等号右边的整个对象赋值给该元素。从数组元素保存的是引用去考虑这方面，很容易理解。

1
2
3
4
5
6
7
8
9
10
11
12

arr = [1,2,3,4,5]      #=> [1, 2, 3, 4, 5]
arr[1..3] = [22,33,44]
arr                    #=> [1, 22, 33, 44, 5]

arr[1,3] = [2,3,4]
arr                    #=> [1, 2, 3, 4, 5]
arr[1,1] = [22,33]
arr                    #=> [1, 22, 33, 3, 4, 5]

# 注意，引用了整个数组
arr[1] = [222,333]     #=> [222, 333, 444]
arr                    #=> [1, [222, 333], 33, 4, 5]

因为ruby中的一元运算符操作 x += y 和二元运算符操作 x = x + y 完全等价，都会创建新对象x。所以，涉及到大数组时，效率会比较低下。

+ 可以将两数组加在一起返回一个新数组：

1
2

arr = [1, 2, 3]
arr1 = arr + [3, 4, 5]  # arr不变，arr1=[1,2,3,3,4,5]

concat() 方法也能将0到多个数组扩展到一个数组上。它是原地修改的，所以时间复杂度是O(n)，n为追加部分的元素个数。注意，concat()会将参数数组全都”压平”然后追加到原数组尾部：

1
2
3
4
5
6
7
8
9

["a", "b"].concat(["c", "d"])   # ["a", "b", "c", "d"]
["a"].concat(["b"], ["c", "d"]) # ["a", "b", "c", "d"]
["a"].concat     # ["a"]

a = [1, 2, 3]
a.concat([4, 5])  # a=[1, 2, 3, 4, 5]

a = [1, 2]
a.concat(a, a)   # a=[1, 2, 1, 2, 1, 2]

* 对于数组有两种用法：

1
2
3
4
5
6
7
8
9
10

# 1.数组乘一个数值对象，返回新数组
# 数值必须在数组后面，不能放前面
arr = [1, 2, 3]
arr1 = arr * 2  # arr不变，arr1=[1,2,3,1,2,3]

# 2.数组乘一个字符串，将返回字符串而非新数组
# 相当于join方法，所以可用于分隔各元素
arr = [1, 2, 3]
arr1 = arr * ","   # arr不变，arr1="1,2,3"
arr2 = arr * ",+"  # arr不变，arr2="1,+2,+3"

如果只想分隔除最后一个元素外的其它元素，并单独处理最后一个元素。可参考如下：

1
2

arr = %w[perl php shell ruby]
arr[0..-2].join(", ") + " and " + arr[-1]

1
2
3
4
5
6
7
8
9

a = %w(a b c d e)
p a.length      # 5
p a.count       # 5
p a.size        # 5

ary = [1, 2, 4, 2]
ary.count                  # 4，数组元素个数
ary.count(2)               # 2，等于2的元素个数
ary.count {|x| x%2 == 0}   # 3，偶元素个数

检查数组是否为空数组，使用 empty?() 方法：

1

p a.empty?      # false

检查数组是否包含某元素，使用 include?() 方法：

1
2

p a.include?('c')  # true
p a.include?('x')  # false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# push()向尾部插入元素
# push()返回数组自身，可以链式插入
# append()等价于push()
arr = [1, 2, 3, 4]
arr.push(5)   # arr = [1, 2, 3, 4, 5]
arr.push(6).push(7) #  arr = [1,2,3,4,5,6,7]

# <<向尾部插入元素
# <<返回数组自身，所以可以进行链式插入
arr = [1, 2, 3, 4]
arr << 5          # arr = [1, 2, 3, 4, 5]
arr << 6 << 7     # arr = [1,2,3,4,5,6,7]
arr <<8 <<[9, 10] # [1,2,3,4,5,6,7,8,[9,10]]

# unshift()向头部插入元素
# prepend()等价于unshift()
arr = [1, 2, 3, 4]
arr.unshift(0).unshift(-1) # arr=[-1,0,1,2,3,4]

# insert()向给定索引位置处插入元素，可一次性插入多个
arr = [0, 1, 2, 3, 4]
arr.insert(3, "Ruby") # [0, 1, 2, 'Ruby', 3, 4]
arr.insert(3,"Perl","Shell") # # [0,1,2,'Perl','Shell','Ruby',3,4]

# 通过范围赋值的方式插入元素
arr = [0, 1, 2, 3, 4]
arr[1,0] = [11, 22]  # [0, 11, 22, 1, 2, 3, 4]
arr[1..1] = [11, 22]  # 与上等价

对于大数组(或未来可能会变大的数组)来说，不要使用insert和unshift插入元素，因为它们会伴随着元素的迁移。而应该使用 << 或 push 或 append 在尾部插入元素。

pop()、shift()、delete_at()：

1
2
3
4
5
6
7
8
9
10
11
12
13

# pop()移除数组尾部元素并返回该元素
arr = [1, 2, 3, 4, 5, 6]
arr.pop   # 返回6， arr变成[1, 2, 3, 4, 5]

# shift()从数组头部移除一个元素并返回该元素
arr.shift     # 返回1，arr变成[2, 3, 4, 5]

# delete_at()移除给定索引位置处的元素并返回该元素
arr.delete_at(2)  # 返回4，arr变成[2, 3, 5]

# 通过范围赋值的方式删除元素
arr = [1, 2, 3, 4, 5, 6]
arr[1, 2] = []   # arr = [1, 4, 5, 6]

对于大数组(或未来可能会变大的数组)来说，不要使用delete_at和shift删除元素，因为它们会伴随着元素的迁移。而应该使用pop删除尾部元素。

按给定值删除元素

delete()：找到元素则删除，找不到元素则返回nil，如果给了语句块，则在且仅在找不到元素时执行语句块

1
2
3
4
5
6

# delete()删除数组中等于某个值的元素
arr1=[1, 2, 2, 4]
arr2 = %w(Perl Shell Python Ruby)
arr1.delete(2)       # 返回2，arr1变成[1,4]
arr2.delete "Shell"  # 返回"Shell"，arr2变成%w(Perl Python Ruby)
arr2.delete("PHP") {"element not found"}

删除重复元素

uniq()、compact()以及成对的带感叹号后缀的uniq!()、compact!()：

1
2
3
4
5
6
7

# uniq()删除重复元素，不是原处修改对象的
arr=%w(a b c x y a c b y)
uniq_arr = arr.uniq   # uniq_arr=%w(a b c x y)，arr不变

# uniq!()删除重复元素，直接修改原始对象且返回修改后的数组
arr=%w(a b c x y a c b y)
uniq_arr = arr.uniq!   # uniq_arr和arr都变成%w(a b c x y)

1
2
3
4
5
6
7
8
9
10
11

# compact()删除所有nil元素，不是原处修改对象
arr = ["a", "b", "c", nil, "a", "c", nil, "b"]
compact_arr = arr.compact
p compact_arr    # ["a", "b", "c", "a", "c", "b"]
p arr            # ["a","b","c",nil,"a","c",nil,"b"]

# compact!()删除所有nil元素，原处修改对象
arr = ["a", "b", "c", nil, "a", "c", nil, "b"]
compact_arr = arr.compact!
p compact_arr    # ["a", "b", "c", "a", "c", "b"]
p arr            # ["a", "b", "c", "a", "c", "b"]

clear()直接清空数组：

1
2

a = [1,2,3]
a.clear()    # a=[]

clear()的内部行为是将数组的start元素索引和元素数量total设置为0。

直接将空数组赋值给变量 arr=[] 也可以清空数组，但其内部过程是创建一个空数组对象并让变量指向该空数组。

迭代数组中每个元素，并将每个元素传递给语句块中的变量。最后返回数组自身。

1
2
3
4

arr = [1, 2, 3, 4, 5]
arr.each {|a| print a -= 10, " "}
## 输出：-9 -8 -7 -6 -5
## arr=[1, 2, 3, 4, 5]

注意，Ruby中是按引用赋值的，所以each迭代(也包括for，for的本质是each)时控制变量总是引用数组原元素，也因此，修改控制变量的值会直接修改原数组元素，除非这个元素是不可变对象。

例如，上面示例中数组的元素全部是数值，数值是不可变对象，所以修改控制变量a后不会影响原数组元素。但如果元素是可变对象，则会直接修改原数据：

1
2
3
4
5
6
7
8
9
10
11

a=%w[perl shell python php ruby]
a.each {|x| x[1]="L" }
puts a
# 输出：
=begin
pLrl
sLell
pLthon
pLp
rLby
=end

迭代数组中的每个元素，并将每个元素的索引传递给语句块中的变量。最后返回数组自身。

1
2
3
4
5
6
7
8
9
10
11
12
13

a = ["a", "b", "c", "d"]

a.each_index do |x|
  puts "index: #{x}"
end

## 输出结果：
=begin
index: 0
index: 1
index: 2
index: 3
=end

数组还继承了Object类的 === ，对于数组而言，它等价于 == 。

返回true/false。注意，如果含有nil元素，则nil与nil的比较结果为true。

1
2
3
4

[ "a", "c" ]    == [ "a", "c", 7 ]     # false
[ "a", "c", 7 ] == [ "a", "d", "f" ]   # false
[ "a", "c", 7 ] == [ "a", "c", 7 ]     # true
["a", 1, 1.2] == ["a", 1.0, 1.2]       # true

它是根据各对象计算出的hash值比较的，一般来说比 == 要严格一点。

1
2
3
4
5
6

[1, 2] == [1, 2.0]      # true
[1, 2].eql?([1, 2.0])   # false
[1, 2].eql?([1, 2])     # true

[1, 2].hash    # 2027605168499122706
[1, 2.0].hash  # 3393919734812826294

这个方法比 == 和 eql?() 都要严格。

1
2
3
4
5

[1,2].equal?([1,2])  # false

a = [1, 2]
b = a
a.equal?(b)  # true

对于数组而言，对数组中的每个元素都一一对应的比较，直到找到某个数组中的元素不等于另一个数组中对应索引处的元素就返回结果。如果数组长短不一致，且较短数组的所有元素都和另一数组对应元素相等，则长数组更大。于是可以推断，只有两数组长度、内容完全相等(通过 == 号比较，例如1等于1.0)，数组才相等。

1
2
3
4
5
6
7
8
9
10
11
12

arr = [1, 3, 5, 7]
arr1 = [1, 3.0, 5, 7]
arr2 = [1, 3, 5]
arr3 = [1, 3, 5, 7, 9]
arr4 = [1, 3, 7, 5]
arr5 = [1, 3, 7, 5, nil]

p arr <=> arr1   # 0
p arr <=> arr2   # 1
p arr <=> arr3   # -1
p arr <=> arr4   # -1
p arr <=> arr5   # -1