t
args = ["-m", "-q", "filename"]
args.shift # "-m"
args # ["-q", "filename"]
args = [ "-m", "-q", "filename" ]
args.shift(2) #=> ["-m", "-q"]
args #=> ["filename"]
flatten()和flatten!()
flatten → new_ary
flatten(level) → new_ary
flatten! → ary or nil
flatten!(level) → ary or nil
将多层次的嵌套数组压平,level可以指定最多压到那一层。对于带感叹号后缀的方法,如果数组无法再压或层数不够,则返回nil。
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]
a.flatten # [1,2,3,4,5,6,7,8,9,10]
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten(1) # [1, 2, 3, [4, 5]]
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten! #=> [1, 2, 3, 4, 5]
a.flatten! #=> nil,已经压平了
a #=> [1, 2, 3, 4, 5]
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten!(1) #=> [1, 2, 3, [4, 5]]
a.flatten!(1) #=> [1, 2, 3, 4, 5]
a.flatten!(1) #=> nil
hash()
计算数组的hash值。执行eql?()
的比较时,其比较依据就是hash值。
[1, 2].hash # 2027605168499122706
[1, 2.0].hash # 3393919734812826294
include?()
include?(object) → true or false
判断数组中是否包含某元素。判断的依据是使用==
比较。
a = [ "a", "b", "c" ]
a.include?("b") # true
a.include?("z") # false
[1, 2.0].include?(2) # true
index()和rindex()
index(obj) → int or nil
index {|item| block} → int or nil
index → Enumerator
rindex(obj) → int or nil
rindex {|item| block} → int or nil
rindex → Enumerator
搜索数组中满足条件的元素并返回其索引位置,搜索不到将返回nil。
# index(obj)、rindex(obj)
# 返回数组中第一个、最后一个等于obj的元素位置
# 使用"=="进行测试
a = [ "a", "b", "c" ]
p a.index("b") # 1
p a.index("z") # nil
p a.index {|x| x == "b"} # 1
# (r)index {|item| block}
# 返回第一个/最后一个满足语句块中条件的元素位置
a = [ "a", "b", "b", "b", "c" ]
p a.rindex("b") # 3
p a.rindex("z") # nil
p a.rindex {|x| x == "b"} # 3
initialize_copy()和replace()
两者等价。
initialize_copy(other_ary) → ary
使用other_ary数组替换当前数组中的元素,并按需收缩、扩展。
注意原处修改。
a = %w(a b c d e) # ["a", "b", "c", "d", "e"]
a.replace(%w[x y z]) # ["x", "y", "z"]
a # ["x", "y", "z"]
join()
join(separator=$,) → str
将数组各元素通过连接符连接起来,转换成字符串返回。
不给sep时默认以$,
作为连接符,如果$,
为nil(默认就是nil),则默认使用空字符进行连接。
嵌套数组会递归连接。
连接符必须是字符串类型。
实际上,join()的过程是:将数组各元素全都使用to_s
转换成字符串,然后对连接符使用to_str
转换成字符串。
["a","b","c"].join # "abc"
["a","b","c"].join("-") # "a-b-c"
["a",[1,2,[:x,:y]], "b" ].join("-") # "a-1-2-x-y-b"
# 数值不能作为连接符,因为它没有定义to_str
%w(perl shell ruby).join(1) # TypeError
max()和min()
max → obj
max {|a, b| block} → obj
max(n) → array
max(n) {|a, b| block} → array
min → obj
min {|a, b| block} → obj
min(n) → array
min(n) {|a, b| block} → array
无参数、无语句块的形式,表示从数组中返回最大/最小的元素。何为最大/最小,只有数组中所有元素都实现了Comparable
模块才允许比较,也就是能使用<=>
对数组不同元素之间进行比较。
带语句块形式的形式,表示将每个元素传递到语句块之后经过一番处理,然后通过<=>
比较得到返回结果。
带参数的形式则表示以数组的方式返回最大/最小的n个元素,也就是返回前几名对象。
ary = %w(albatross dog horse)
ary.max # "horse"
ary.max {|a, b| a.length <=> b.length} # "albatross"
ary.max {|a, b| b.length <=> a.length} # &quo