Ruby 数组 API 一览表Ruby Playground 创建数组获取 hash 字符串比较数组索引数组方法

创建数组

%w[foo bar baz] # => ["foo", "bar", "baz"]
%w[1 % *]       # => ["1", "%", "*"]
%i[foo bar baz] # => [:foo, :bar, :baz]
%i[1 % *]       # => [:"1", :%, :*]

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

Array.new(4) {|i| i.to_s } # => ["0", "1", "2", "3"]
Array.new(3) {Array.new(3)}
# => [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]

获取 hash 字符串

p [0, 1, 3].hash #=> "A,1,3,7"
p [0, 1, 4].hash #=> "A,1,3,9"

比较数组

[0, 1, 3].hash == [0, 1, 3].hash #=> true

[0, 1, 2] <=> [0, 1, 3] # => -1
[0, 1, 2] <=> [0, 1, 1] # => 1
[0, 1, 2] <=> [0, 1] # => 1
[0, 1, 2] <=> [0, 1, 2] # => 0

[:foo, 'bar', 2] == [:foo, 'bar', 2.0] # => true 每个元素通过 == 方法对比
[] == [] # => true

[:foo, 'bar', 2].eql? [:foo, 'bar', 2] # => true 每个元素通过 eql? 方法对比
[].eql? [] # => true

索引数组

arr = [1, 2, 3, 4, 5, 6]
arr[-3]   #=> 4
arr[2, 3] #=> [3, 4, 5] 其中的 3 表示长度，而不是下标
arr[1..4] #=> [2, 3, 4, 5]
arr[1..-3] #=> [2, 3, 4]

a = ['--', 'data1', '--', 'data2', '--', 'data3']
a[(1..).step(2)] # => ["data1", "data2", "data3"]

方法示例	说明
arr.at(0)
arr.values_at(0, 2)	返回从0开始的 2 个元素组成的数组
arr.values_at(0..1)	返回下标从 0 到 1（含）的元素组成的数组
arr.fetch(100, "oops")	使用兜底值获取
arr.take(3)	获取前 N 个元素
arr.drop(3)	删除前 N 个元素
arr.length	获取长度
arr.count	获取长度
arr.size	获取长度
arr.empty?	判断是否长度为 0
arr.include?(100)	判断是否包含元素
arr.all? {}	判断是否所有元素都满足某个条件
arr.any? {}	判断是否有至少一个元素满足某个条件
arr.none?	判断是否不含 truthy 元素
arr.none? {}	判断是否不含满足某个条件的元素
arr.index 'bar'	获取第一个 'bar' 的下标
arr.index {}	获取满足条件的第一个元素的下标
arr.rindex	跟 index 类似，但是是从最后一个元素开始查找
arr.first	顾名思义
arr.last	顾名思义
arr.max(n)	不传 n 则 n 为 1，获取最大的 n 个元素
arr.min(n)	不传 n 则 n 为 1，获取最小的 n 个元素
arr.minmax {}	返回 `[最小值, 最大值]`，可指定如何比较，默认使用 `<=>`
arr.assoc(4)	默认元素为二维数组，找到第一个首个元素等于 4 的元素
arr.rassoc(4)	跟 assoc 功能相同，方向相反
arr.dig(1, 2, 3)	获取 arr.1.2.3

插入元素

arr = [1, 2, 3, 4]
arr << 6    #=> [1, 2, 3, 4, 5, 6]

方法示例	说明	别名
arr << 6	追加元素
arr.push(5)	追加元素	append
arr.unshift(0)	在开头插入元素	prepend
arr.insert(3, 'first', 'second')	在指定位置插入元素

删除元素

arr =  [1, 2, 3, 4, 5, 6]
arr.pop #=> 6
arr #=> [1, 2, 3, 4, 5]

方法示例	说明
arr.pop	弹出最后一个元素
arr.shift	弹出第一个元素
arr.delete_at(2)	弹出指定位置的元素
arr.delete(2)	删除等于 2 的所有元素
arr.compact	删除所有 nil（返回新数组）
arr.compact!	删除所有 nil（改变自身）
arr.uniq	去除重复元素，可加 !

遍历数组

方法示例	说明
arr.each {}	遍历
arr.each_index {}	遍历，带 index
arr.reverse_each {}	反向遍历
arr.cycel(n) {}	遍历多次
arr.combination(len) {}	每次遍历时获取 len 个元素
arr.permutation(len) {}	对元素进行排列组合再遍历

过滤元素

方法示例	说明	别名
arr.select { }	保留某些元素，可加 !	filter
arr.reject {}	排除某些元素，可加 !
arr.drop_while {}	排除某些元素
arr.take_while {}	保留头部的某些元素
arr.delete_if {}	删除某些元素（有破坏性，会改变自身）
arr.keep_if {}	保留某些元素（破坏性）
arr.bsearch {}	用二分法来查找满足条件的第一个元素
arr.bsearch_inx {}	同上，但是返回的是下标
arr.sample(n)	从数组中随机选择 n 个元素
arr.shuffle	把数组的元素随机排列，可加 !

转换数组

方法示例	说明	别名
arr.map {}	映射（可加 !）	collect
arr.sort {}	排序，可加 !
arr.sort_by {}	排序，必须指定排序依据，可加 !
arr.reverse	反转，可加 !
arr.rotate(index)	旋转，假想数组是一个圆圈，可加 !
arr.flatten(level)	拍平，可加 !
arr.inspect	转为字符串，字符串带 `[]`	to_s
arr.join	连成字符串
arr.to_a	返回一个数组
arr.to_h	返回一个 Hash 对象，key 和 value 相等
arr.transpose	进行行列式转换
arr.zip	类似于 transpose，但是数组长度可以不相等

其他

方法示例	说明
a.concat([2, 3], [4, 5])	连接数组
a = [0, 1] + [2, 3]	连接数组
[0, 1, 2, 3] - [3, 0]	返回差集（删除所有 3 和 0）
[0, 1, 2, 3].difference([3, 0])	返回差集（删除所有 3 和 0）
a.fill(:x, start or range, length)	填充数组
a.replace(new_arr)	用新数组替换旧数组
[0, 1, 2, 3] & [1, 2]	返回交集
[0, 1, 2, 3].intersection([0, 1, 2])	返回交集
[0, 1, 1] \| [2, 2, 3]	返回并集（去重之后的）
[0, 1, 2, 3].union([4, 5], [6, 7])	返回并集（去重之后的）
['a', 'b'].product [1, 2]	返回乘积
arr * 3 或 arr * ','	复制数字或连接数组里的元素
arr.sum(init)	求和