Ruby Array

   1. 数组的创建：

array = [1, 2, "3", "4"] 或者
array = Array.new
array = Array.new(6)        #创建[nil, nil, nil, nil, nil, nil]
array = Array.new(6, "a")   #创建["a", "a", "a", "a", "a", "a"]

   也可以使用"%w"方法专门用来创建字符串数组：

array = %w(a b c d) #使用空格作为元素的分隔符。返回值["a", "b", "c", "d"]

 

   2.通过索引存取数组的值, 在Ruby中，数组索引可以是正整数（从前到后，从0开始）也可以是负整数

   （从后到前，从-1开始)还可以是范围（Range）：

array = [1, 2, 3, 4, 5, 6]
puts array[0]     # =>1
puts array[0, 2]  # =>1, 2
puts array[0..2]  #=>[1, 2, 3]
puts array[0...2] #=>[1, 2]
puts array[-2, 2] #=>[5, 6] 

#array[-2, 2]:前一个整数-2表示开始的索引，后面一个整数2表示数量

 

   3. +  (串联方法）简单的将两个数组连接在一起， 不删除重复元素。

a = [1, 2, 1]
b = [4, 5, 2]
p a + b #=>[1, 2, 1, 4, 5, 2]

 

   4. -  (数组差集) 从第一个数组中删除所有出现在第二个数组中的元素。

p [1, 2, 3] - [1, 2] #=> [3]
p [1, 2, 3, 4, 1, 5, 1, 6] - [2, 3, 4, 5, 6]  #=>[1, 1, 1]
p [1, 2, 3, 4, 1, 5, 1, 6] - [1, 2, 3, 4, 5, 6] #=> []

 

   5. & (数组交集) 取两个数组中都有的元素， 但只取一个， 不重复取。

p [1, 1, 3, 5] & [1, 2, 3]  #=>[1, 3] 

 

   6. << (追加元素) 在数组末尾添加新元素， 也不管重复不重复。

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

 

   7. | (数组并集) 取两个数组中所有元素组成的集合，删除重复元素。

p [1, 2, 3, 4] | [1, 2, 6] #=>[1, 2, 3, 4, 6]

 

   8. * (重复数组)  将数组内容重复多次后生成一个新数组并返回该数组。

     a. 如果 * 后面跟的是数字n， 将原先数组中的所有元素重复n次， 串联起来。 

p [1, 2, 3] * 3  #=> [1, 2, 3, 1, 2, 3, 1, 2, 3]

 

     b.如果 * 后面跟的是字符串，就相当于 array.join(string)

p [1, 2, 3] * ","  #=> "1,2,3"

 

   9. ==  用来比较两个数组中的各个元素

p ["a", "b"] == [”a", "b", 8]  #=> false
p [1, 2, 3] == [1, 2, "3"]  #=> false
p [1, 2, 3] == [ 1, 2, 3] #=> true

 

   10. <=> 当两个数组进行比较时，会把两个数组相同索引(从0开始)上的值拿来比较，如：

p [0,10,20]<=> [0,20,20]    #=> -1 因为当索引为1时， 10 < 20

 

   另外，比较的两个数组的元素是字符串，那么就比较它们的ASCII;如果一个数组比另一个长且其它元素都相同，那么数组长的‘大’。然而，如果一个短数组里面的一个元素比另一个长数组里面的同位置的元素大，则认为短数组‘大’。

p [1, 2, 3, 4, 5] <=> [1, 2, 3, 4, 5] #=> 0
p [1, 2, 3, 4] <=> [1, 2, 3, 4, 5] #=> -1
p [1, 2, 3, 5] <=> [1, 2, 3, 4] #=> 1
p [10,  20, 30] <=> [1, 2, 3, 5] #=> 1
p [1, 2] <=> [2, 1] #=> -1
p ["an", "b"] <=> ["An", 'B'] #=> -1
p ["an", "b"] - [1 ,2] #=> nil

 

   11. assoc(key) 对数组中的元素数组进行检索，若某元素数组的首元素与key相等时就返回该元素数组。使用==操作符进行比较。若没有符合条件的元素数组就返回nil。

array = [[1, 20], [2, 25], [3, 30]]
p array.assoc(2)           # => [2, 25]
p array.assoc(100)         # => nil
p array.assoc(15)          # => nil

 

   12. rassoc(obj)假定array是数组中的元素数组，若首次发现元素数组中索引为1的元素与obj相等时就返回该元素。使用==操作符进行比较。若没有符合条件的元素数组则返回nil。

array = [[15,1], [25,2], [35,3]]
p array.rassoc(2)    # => [25, 2]

 

   13. at(pos)返回位于pos的数组元素。与self[pos]相同。

array = [ "a", "b", "c", "d", "e" ] 
p array.at(0) # => "a" 
p array.at(-1) # => "e" 
p array.at(5) # => nil 

   

   14. clear 删除数组中的所有元素。

array = [ "a", "b", "c", "d", "e" ] 
p array.clear # => [] 

   

    15. collect! {|item| ..} 对数组中的每一个元素进行遍历，block中对元素的操作将改变元素的值。

array = [ "a", "b", "c", "d" ] 
array.collect! {|x| x + "$" } # => ["a$", "b$", "c$", "d$"] 
p array # => ["a$", "b$", "c$", "d$"] 

  

   16. map! {|item| ..} 依次将数组的各个元素传给块进行计算，然后以计算结果来替换该数组元素。

array = [1, 2, 3]
array.map! {|i| i * 3 }
p array   #=> [3, 6, 9]

   

   17.compact 删除数组中所有值为nil的元素，也即压缩数组。

p [ "a", nil, "b", nil, "c", nil ].compact # => ["a", "b", "c"] 

   

   18.compact! compact从array中删除值为nil的元素后生成新数组并返回它。compact!是具有破坏性的，若对原数组进行了改动就返回array，若没有进行改动则返回nil。

array = [1, nil, 2, nil, 3, nil]
p array.compact   #=> [1, 2, 3]
p array           #=> [1, nil, 2, nil, 3, nil]
array.compact!
p array           #=> [1, 2, 3]
p array.compact!  #=> nil

 

   19. concat  将第二个数组中的元素添加在第一个数组末尾，组成新数组。

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

 

   20. count  计算数组中等于某个值的元素有几个。

p [1, 2, 3, 4].count(3) # => 1 
p [1, 2, 3,3, 4].count(3) # => 2 
p [1, 2, 3, 4].count {|obj| obj > 2 } # => 2 

 

   21. delete(val) 和  delete(val) { . . . } 使用==来分别比较val与每个数组元素，若相等则删除该元素。若发现了与val相等的元素就返回val。若没有发现与val相等的元素则返回nil，若指定了块的话就对块进行计算并返回结果。

array = [1, 2, 3, 2, 1]
p array.delete(2)       #=> 2
p array                 #=> [1, 3, 1]

# 若向无块的参数传递了 nil 时，则无法从其返回值中判断
# 到底有没有进行删除
ary = [nil,nil,nil]
p ary.delete(nil)       #=> nil
p ary                   #=> []
p ary.delete(nil)       #=> nil

p a = [ "a", "b", "b", "b", "c" ] 
p a.delete("b")  # => "b" 
p a                   # => ["a", "c"] 
p a.delete("z")  # => nil 
p a.delete("z") { "not found" }  # => "not found" 

 

   22.  delete_at(pos) 删除pos所指位置的元素并返回它。若pos超出数组范围则返回nil。与at一样，可以使用负的索引从尾部起指定元素。

array = [0, 1, 2, 3, 4]
array.delete_at(2)
p array             #=> [0, 1, 3, 4]

 

   23. each {|item| ... } 依次使用每个元素来使用block，返回array。

[1, 2, 3].each do |i|
  puts i
end
#=> 1 2 3

a = [ "a", "b", "c" ] 
a.each {|x| print x, " -- " } 
#=> a -- b -- c --

 

   24. each_index 依次使用每个元素的索引来对块进行计算。

a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }
#=>  0 -- 1 -- 2 -- 

 

   25. empty? 判断数组是否为空。 

[].empty? #=> true
[1, 2].empty? #=>false

 

   26. join 将数组中的元素连接成字符串。如果给定参数，则在每个元素直接加入该参数。

p  [ "a", "b", "c" ].join       # => "abc"
p  [ "a", "b", "c" ].join("-")  # => "a-b-c"  

 

   27. first 返回数组的首元素。若数组为空则返回nil。

         first(n) 将以数组形式返回前n个元素，n必须大于0。

ary =  [0, 1, 2]
p ary.first       #=> 0
p ary.first(0)  #=>[]
p ary.first(1)  #=>[0]
p ary.first(2)  #=>[0, 1]
p ary.first(3)  #=>[0, 1, 2]
p ary.first(4)  #=>[0, 1, 2]

 

   28. last 返回数组的最后一个元素。若数组为空则返回nil。

         last(n) 将以数组形式返回倒数n个元素，n必须大于0。

ary =  [0, 1, 2]
p ary.last       #=> 2
p ary.last(0)  #=>[]
p ary.last(1)  #=>[2]
p ary.last(2)  #=>[1, 2]
p ary.last(3)  #=>[0, 1, 2]
p ary.last(4)  #=>[0, 1, 2]

 

   29. lenght  和 size 返回数组的长度，若数组为空则返回 0。

         nitems  返回非nil元素的个数。

p [1, nil, 3, nil, 5].length  # => 5
p [1, nil, 3, nil, 5].nitems  # => 3

 

   30. pop 删除末尾元素并返回删除元素。若数组为空则返回nil。

a = %w{ f r a b j o u s } 
p a.pop      # => "s" 
p a             # => ["f", "r", "a", "b", "j", "o", "u"] 
p a.pop(3) # => ["j", "o", "u"] 
p a            # =>  ["f", "r", "a", "b"] 

 

   31. push 在数组末尾插入元素。

a = [ "a", "b", "c" ] 
p a.push("d", "e", "f")   # => ["a", "b", "c", "d", "e", "f"] 

array = [1, 2, 3]
array.push(4)
array.push( [5, 6] )
array.push(7, 8)
p array          # => [1, 2, 3, 4, [5, 6], 7, 8]

 

   32. unshift 在数组头部加入元素，原数组元素往后移。

a = [ "b", "c", "d" ] 
p a.unshift("a")   # => ["a", "b", "c", "d"]  
p a.unshift(1, 2)  # => [1, 2, "a", "b", "c", "d"] 
p a.unshift([0])   # =>  [[0], 1, 2, "a", "b", "c", "d"]

 

   33. shift 从头部删除数组元素，并返回被删除的元素。 若数组为空则返回nil。

array = [ "a", "b", "b", "c" ] 
p array.shift      # => "a" 
p array.shift(2) # => ["b", "b"] 
p array             # => ["c"] 

 

   34. replace 用新数组替换旧数组。

a = [1, 2, 3]
a.replace [4, 5, 6, 7]
p a                 #=> [4, 5, 6, 7]

 

   35. reverse  reverse! reverse_each {|item| ... } 

        reverse 将所有元素以逆序重新排列生成新数组并返回它。reverse!的逆序排列过程具有破环性。

        reverse_each {|item| ... }  对各个元素以逆序对块进行计算。返回array。

p [1, 2, 3].reverse #=>[3, 2, 1]
p [1].reverse!   #=>[1]
p [1, 2, 3].reverese_each{|i| p i }

 #=> 3 
     2
     1

 

   36. rindex(value) 返回最后一个== val的元素的索引值。若没有符合条件的元素时返回nil。

p [1, 0, 0, 1, 0].rindex(1)   #=> 3
p [1, 0, 0, 0, 0].rindex(1)   #=> 0
p [0, 0, 0, 0, 0].rindex(1)   #=> nil

 

   37. shuffle 将原数组随机打乱。

p [ 1, 2, 3, 4, 5, 1 ].shuffle  #=> [3, 1, 1, 5, 4, 2]

 

 

   38. sort 对数组进行排序，返回排序好的数组。

a = [ "d", "a", "e", "c", "b" ] 
a.sort! # => ["a", "b", "c", "d", "e"] 
a # => ["a", "b", "c", "d", "e"] 

 

 

   39.values_at 一次取回多个索引位置的值。

p a = %w{ a b c d e f } #=> ["a", "b", "c", "d", "e", "f"] 
p a.values_at(1, 3, 5) # => ["b", "d", "f"] 
p a.values_at(1, 3, 5, 7) # => ["b", "d", "f", nil] 
p a.values_at(-1, -3, -5, -7) # => ["f", "d", "b", nil] 
p a.values_at(1..3, 2...5) # => ["b", "c", "d", "c", "d", "e"] 

 

 

   40. uniq 返回数组中不同的元素。原数组不变。

a = [ "a", "a", "b", "b", "c" ] 
p a.uniq # => ["a", "b", "c"] 
p a #=> [ "a", "a", "b", "b", "c" ] 

 

 

   参考：http://fujinbing.iteye.com/blog/1126232

             http://www.kuqin.com/rubycndocument/man/built-in-class/class_object_array.html

             http://www.cnblogs.com/puresoul/archive/2011/10/20/2218690.html