返回列表

Ruby数组

默认分类 2011-04-08 19:06:36

转载:http://www.udpwork.com/item/3904.html

python和ruby这种语言的内置数据结构强大到让我震惊。下面展示了ruby数组的部分魔力,原文请看这里
首先,说明所使用ruby的环境:
ikbear@ikbear-desktop:~$ ruby -v
ruby 1.9.2p0 (2010-08-18 revision 29036) [i686-linux]
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"]
返回数组中不同的元素。原数组不受影响。
31.include
['Cat', 'Dog', 'Bird'].include? 'Dog' # => true
如果数组中存在指定元素返回true,否则返回false。