ruby 的数组操作

转自：http://fujinbing.iteye.com/blog/1126232

1. &

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

取两个数组中都有的元素，但只取一个，不重复取。

2. *

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

如果*号后面跟的是数字n，将原先数组中的所有元素重复n次，串联起来。相当于普通数字的乘法操作。

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

如果*号后面跟的是字符串，也将返回字符串。

3. +

[ 1, 2, 3 ] + [1, 4, 5 ] # => [1, 2, 3, 1, 4, 5]

简单的将两个数组连接在一起，不删除重复元素。

4. -

[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]

# => [3, 3, 5]

从第一个数组中删除所有出现在第二给数组中的元素。

5. <<

[ 1, 2 ] << "c" << "d" << [ 3, 4 ] << [3, 4]

# => [1, 2, "c", "d", [3, 4], [3, 4]]

在数组末尾添加新元素，也不管重复不重复。

6. ==

[ "a", "c" ] == [ "a", "c", 7 ] # => false

[ "a", "c", 7 ] == [ "a", "c", 7 ] # => true

[ "a", "c", 7 ] == [ "a", "d", "f" ] # => false

判断两个数组是否相等——数组相等的前提是，数组所有元素相等，数组大小也当然相等。

7. |

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

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

取两个数组中所有元素组成的集合，删除重复元素。

8. at

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

a.at(0) # => "a"

a.at(-1) # => "e"

a.at(5) # => nil

取回某个索引中的元素，倒数第一个索引是-1，第二个是-2。

9. clear

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

a.clear # => []

删除数组中的所有元素

10. collect!

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

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

a # => ["a$", "b$", "c$", "d$"]

对数组中的每一个元素进行遍历，block中对元素的操作将改变元素的值。

11. compact

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

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

12. concat

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

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

13. count

[1, 2, 3, 4].count(3) # => 1

[1, 2, 3,3, 4].count(3) # => 2

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

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

14. delete

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

a.delete("b") # => "b"

a # => ["a", "c"]

a.delete("z") # => nil

a.delete("z") { "not found" } # => "not found"

删除数组中值为某个给定值的元素。

15. each

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

a.each {|x| print x, " -- " }

result :

a -- b -- c --

遍历数组，打印元素值。

16. each_index

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

a.each_index {|x| print x, " -- " }

result :

0 -- 1 -- 2 --

遍历数组，打印索引。

17. empty?

[].empty? # => true

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

判断数组是否为空。

18. join

[ "a", "b", "c" ].join # => "abc"

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

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

19. last

[ "w", "x", "y", "z" ].last # => "z"

[ "w", "x", "y", "z" ].last(1) # => ["z"]

[ "w", "x", "y", "z" ].last(3) # => ["x", "y", "z"]

如果不给定参数，取最后一个元素。如果给定参数n，取最后n个参数组成数组。

20. length

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

长度。空元素nil也算元素，计算在长度范围内。

21. pop

a = %w{ f r a b j o u s }

a.pop # => "s"

a # => ["f", "r", "a", "b", "j", "o", "u"]

a.pop(3) # => ["j", "o", "u"]

a # => ["f", "r", "a", "b"]

返回删除了最后n个元素后的数组。

22. push

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

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

在数组末尾插入元素。

23. replace

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

a.replace([ "x", "y", "z" ]) # => ["x", "y", "z"]

a # => ["x", "y", "z"]

用新数组替换旧数组。

24. reverse

[ "a", "b", "c" ].reverse # => ["c", "b", "a"]

[ 1 ].reverse # => [1]

反转数组。

25. shift

args = [ "-m", "-q", "-v", "filename" ]

args.shift # => "-m"

args.shift(2) # => ["-q", "-v"]

args # => ["filename"]

从数组头部删除n个元素，并将他们返回。若删除的是一个，则返回字符串。若删除两个以上元素，则返回这n个组成的新数组。原数组被改变。

26. unshift

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

a.unshift("a") # => ["a", "b", "c", "d"]

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

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

27. shuffle

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

将原数组随机打乱。

28. sort

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

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

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

返回排序好的数组。

29. values_at

a = %w{ a b c d e f }

a.values_at(1, 3, 5) # => ["b", "d", "f"]

a.values_at(1, 3, 5, 7) # => ["b", "d", "f", nil]

a.values_at(-1, -3, -5, -7) # => ["f", "d", "b", nil]

a.values_at(1..3, 2...5) # => ["b", "c", "d", "c", "d", "e"]

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

30. uniq

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

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

返回数组中不同的元素。原数组不受影响。

Ruby迭代器each、map、collect、inject

说明：

each——连续访问集合的所有元素

collect—-从集合中获得各个元素传递给block，block返回的结果生成新的集合。

map——-同collect。

inject——遍历集合中的各个元素，将各个元素累积成返回一个值。

例子：

def debug(arr)

puts '--------'

puts arr

end

h = [1,2,3,4,5]

h1 = h

h1.each{|v|puts sprintf('values is:%s',v)}

h2 = h.collect{|x| [x,x*2]}

debug h2

h3 = h.map{|x| x*3 }

debug h3

h4 = h.inject{|sum,item| sum+item}

debug h4

结果：

values is:1

values is:2

values is:3

values is:4

values is:5

--------

1

2

2

4

3

6

4

8

5

10

--------

3

6

9

12

15

--------

15

names = %w[ruby rails java python cookoo firebody]

等同于：

names = ["ruby", "rails", "java", "python", "cookoo", "firebody"]

arr = [1,2,3]

1) arr2 = arr.each{|element| element = element * 2} #arr与arr2仍然都等于[1,2,3] each返回原数组 遍历内对元素的更改不会保存

2) arr2 = arr.map{|element| element = element* 2} #arr等于[1,2,3] arr2等于[2,4,6] map返回更改后的数组 遍历内对元素的更改不会保存

3) arr2 = arr.map!{|element| element = element * 2} #arr与arr2都等于[2,4,6] map!返回更改后的数组 遍历对元素内的更改会保存

collect 效果等于 map

collect! 效果等于map!

if ($ != jQuery) { $ = jQuery.noConflict(); }