Ruby Array类

Array类

更新: 2017/06/03

更新: 2017/08/31 更新sort的详细内容

更新: 2017/09/07 增加each_with_index, each.with_index(offset = 0)

更新: 2017/10/25 补充slice的说明

更新: 2017/11/05 补充末尾添加数组的concat相当于 +=

更新: 2018/02/14 增加second

更新: 2018/02/24 增加搜索元素相关

更新: 2018/02/28 补充shift, unshift, pop, push的参数说明和返回值说明

                          补充first, last 参数, 补充second不能有参数

更新: 2018/03/01  增加join把数组连结成字符串

更新: 2018/03/20 增加drop(n), take(n)

                          补充map, collect是同一个方法

更新: 2018/03/27 增加 include?(val) -> bool 

更新: 2018/04/02 补充delete_if, map评价方式

更新: 2018/04/04 增加clone, dup

更新: 2018/05/26 增加assoc

更新: 2018/09/28 补充%W, %I

 生成

 

 a = [1,2,3] # 字面生成
 a = Array.new()  # => [] 方法生成
 a = Array.new(2) # =>  [nil, nil]
 a = Array.new(n) {|temp| ...}
 a = Array.new(2, 1)  # =>  [1, 1]
 a = %w(i am a duck)  # %W解析插值， %w不解析 
                      # 元是单词字符串
                      # => ["i", "am", "a", "duck"]
 a = %i(you are also a duck) # %I解析插值, %i不解析
                             # 元是单词符号(symbol, :a)
                             # => [:i, :am, :a, :duck]

 a = [1,2,3].to_a()  # 转换

 

 复制

 clone -> Array

 dup -> Array

 ● 元素不复制(指针的还是指针)

 ● clone也包含了frozen tainted singleton-class的内容

 索引

 a = Array.new(12, 1)
获取一个
 b = a[1]   b = a.at(1)   b = a.slice(1)
获取子数组
 b = a[1..2] b = a.slice(1..2)
 b = a[1...2] b = a.slice(1...2)
获取子数组， 通过首项和数组长度
 b = a[1, 5]  b = a.slice(1..6)

 插入新元素

 b = Array.new(4, 95)
 a[n, 0] = b

 取出多个元素

 a.values_at(n1, n2, ...)

 长度

 a.length
 a.size

 是否包含指定元素

 include?(val) -> bool

 集合运算

 并集 a | b
 交集 a & b

 | 和 +的区别 
 |是集合运算，不包含重复

 序列和堆

 序列： 先放的先拿
 堆：    先放的后拿

 增加元素

开头	unshift(obj, ...)  参数: 一个或多个要追加的元素  从开头按参数顺序增加  返回自己
结尾	push(obj, ...)  参数: 一个或多个要追加的元素  按顺序在末尾增加 a = [] a.push(1, 2, 3) // [1, 2, 3]  返回自己

 

 删除元素

  

开头

 

 

a.shift(n)	从开头删除指定数量的元素  n=1时返回被删除元素，>1时返回被删除元素的数组  改变自身
a.drop(n)	删除从开头开始的n个元素  返回删除后的整个数组(不该变自身)

 

结尾

 pop(n)

 从末尾删除指定数量的元素

 n=1时返回被删除元素，>1时返回被删除元素的数组

 

 读取元素

 开头:    first(n)    结尾:  last(n)

 第二个: second() 这个不能有参数

 开头开始指定个: take(n)

 搜索元素

 

 

返回找到的第一个的索引	find_index(val) -> Integer | nil  index(val) -> Integer | nil  find_index {|item| ...} -> Integer | nil   index {|item| ...} -> Integer | nil
返回找到的最后一个索引	rindex(val) -> Integer | nil  rindex {|item| ... } -> Integer | nil
元素为数组, 搜索子数组内第一个元素	assoc(key) -> Array | nil

 

 主要方法

注：改变自己的method会改变所以参照的对象

 增加首元素

 a.unshift(n)

 增加尾元素

 a.push(n)     a << n

 末尾添加数组

 a.concat(b)   a += b

 取出一部分

 a[n], a[m...n], a[m..n], a[n, length]

 a[n]  取出第n个
 a[m...n] m<= i
 a[m..n] m<= i <=n a[0..2]   a[0] a[1] a[2] 包含右边
 a[n, length]  从n开始，获取length个元素
 相当于
 a.slice(...)
 a.slice!(...)

 删除nil

 a.compact()  去除nil

 去掉所有n

 a.delete(n)    去除所有n

 删掉第n+1个

 a.delete_at(n) 去除第n+1个

 满足条件时删除 

删除返回true的

 a.delete_if do |temp| # 总是返回自身
    ...
 end

 相当于

 a.reject! do |temp|
    ...
 end

 去除重复

 a.uniq()
 a.uniq!()

 读取并删除首元素
 读取并删除尾元素

 a.shift()
 a.pop()

 加工原数组

 a.collect  {|temp| ...}
 a.collect! {|temp| ...}
 a.map {|temp| ...}
 a.map! {|temp| ...}

注: map, collect是同一个方法 

     返回值作为新元素, 不返回则为nil

 填充新值

 a.fill(value)
 a.fill(value, begin)
 a.fill(value, begin, len)
 a.fill(value, n..m)

 展开所有子集合

 a.flatten()
 a.flatten!()

 倒转

 a.reverse()
 a.reverse!()

 排序

 a.sort()
 a.sort!()
 a.sort  {|temp| ...}
 a.sort! {|temp| ...}
 sampe = target.sort { |a, b|
    b.contents.count <=> a.contents.count
 }

 通过某个值排序 

 a.sort_by {|temp| ...}
 a.sort_by! {|temp| ...}

注意: 从小到大排(升序)
        元素变成返回值
例子:
 a.sort_by! {|temp|
    temp.count
 }

 遍历

 a.each {|temp|}
 a.zip
带索引
 从0开始 a.each_with_index {|temp, index|}
 从n开始 a.each.with_index(n) {|temp, index|}

 获取字符串 

 a.join(sep="")

 按将数组内容按sep为分割连结成字符串

 [1, 2, 3].join('/') # '1/2/3'