Ruby语言入门(12)- 内部类 - Array
上一篇 / 下一篇 2013-02-01 15:54:37 / 个人分类:语言
数组的元素可以是任意的Ruby对象。包含的模块:Enumerable
类生成方法有:
Array[item,...]
a=Array[1,2,3]
=>[1,2,3]
Array.new([size[, val]])
a=Array.new(5,1)
=>[1,1,1,1,1]
Array.new(ary)
b=Array.new(a)
=>[1,1,1,1,1]
a==b
=>true
Array.new(size) {|index| ... }
a=Array.new(3){"test"}
=>["test","test","test"]
类的内置方法有:
self[nth]
返回第nth个数组元素。首元素算做第0个元素。若nth值为负,则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若第nth个元素不存在,则返回nil。
a=Array[1,2,3]
a[1]
=>2
a[-1]
=>3
self[start..end]
以数组形式返回从第start个元素到第end个元素间的所有元素。若start值为负,则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若start的值超出数组范围则返回nil。若end的值超出数组长度时,超出的部分将被忽略。另外,若范围的起点比终点还大时,返回nil。
a=Array[1,2,3]
a[1..10]
=>[2,3]
a[-1..3]
=>[3]
self[start, length]
以数组形式返回从第start个元素算起的length个数组元素。若start值为负,则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若length超出从第start个元素算起的剩余长度时,超过部分将被忽略。若length为负,则返回nil。
a=Array[1,2,3]
a[1,4]
=>[2,3]
a[-1,2]
=>[3]
self[nth]=val
将第nth个数组元素的值设定为val。若nth超出数组范围时,将自动加长数组并以nil对新增部分进行初始化。
a=Array[1,2,3]
a[6]=6
a
=>[1,2,3,nil,nil,6]
self[start..end]=val
将从第start个数组元素到第end个数组元素间的所有元素替换为val的内容。若val并非数组时,则就以val进行替换。若val的元素个数过多时,后面的元素将会发生移位。若val为nil或空数组[]时,将删除从start到end的元素。
a=Array[1,2,3]
a[1..3]=["a","b"]
a
=>[1,"a", "b"]
a[1..3]=6
a
=>[1,6]
a=[0, 1, 2, 3, 4, 5]
a[0..2]=["a", "b"]
a
=> ["a", "b", 3, 4, 5]
a[2..4] = nil
a
=> ["a", "b"]
self[start, length]=val
将从索引start算起的length个数组元素替换为val的内容。若val不是数组时,则调用val.to_ary或使用[val]进行替换。返回val。
a=Array[1,2,3]
a[1,3]=["a","b"]
a
=>[1,"a", "b"]
a[1,3]=6
a
=>[1,6]
a=[0, 1, 2, 3]
a[1, 2]=['a', 'b', 'c']
a
=> [0, "a", "b", "c", 3]
a[2, 1] = 99
a
=> [0, "a", 99, "c", 3]
a[1, 0] = ['inserted']
a
=> [0, "inserted", "a", 99, "c", 3]
self + other
将self和other的内容连起来后生成新数组并返回该数组。若other并非数组时则使用other.to_ary的返回值。若该返回值依然不是数组时,则引发TypeError异常。
a=[1,2]
b=[3,4]
a+b
=>[1,2,3,4]
self * times
将数组内容重复多次后生成一个新数组并返回该数组.
a=[1, 2, 3]
a*3
=> [1, 2, 3, 1, 2, 3, 1, 2, 3]
若times为字符串,则其动作等同于self.join(times)。
a*"a"
=>"1a2a3a"
self - other
集合的补集运算。从self中删除other的元素后生成一个新数组并返回该数组。重复元素将被清除。
a=[1, 2, 3]
a-[1]
=> [2, 3]
self & other
集合的交集运算。将同属于两个数组的元素重组为一个新数组并返回该数组。重复元素将被清除。
a=[1, 2, 3]
b=[1, 4, 5]
a&b
=> [1]
self | other
集合的并集运算。将任属两数组之一的元素重组为一个新数组并返回该数组。重复元素将被清除。
a=[1, 2, 3]
b=[1, 4, 5]
a|b
=> [1,2,3,4,5]
self << obj
将obj追加到数组尾部。
a=[1, 2, 3]
a<<5
=> [1,2,3,5]
a<<5<<6<<7
=>[1,2,3,5,5,6,7]
self <=> other
使用<=>来依次比较self和other中的各个元素。若self大则返回正整数;若相等返回0;若小则返回负整数。如果各个元素均相等,且其中一个数组已到达尾部时,则认定较短的数组为小。
self = = other
使用==来依次比较self和other中的各个元素,若所有元素均相等时返回真。
assoc(key)
对数组中的元素数组进行检索,若某元素数组的首元素与key相等时就返回该元素数组。使用==操作符进行比较。若没有符合条件的元素数组就返回nil。
a = [[1,15], [2,25], [3,35]]
a.assoc(2)
=> [2, 25]
a.assoc(15)
=>nil
at(pos)
返回位于pos的数组元素。与self[pos]相同。
a = [[1,15], [2,25], [3,35]]
a.at(2)
=> [3, 35]
a[2]
=> [3, 35]
clear
删除数组中的所有元素。返回self。
clone/dup
生成一个与receiver内容一样的新数组并返回它。clone会拷贝frozen tainted singleton-class等信息,而dup则只拷贝内容。
collect! {|item| ..} / map! {|item| ..}
依次将数组的各个元素传给块进行计算,然后以计算结果来替换该数组元素
a = [1, 2, 3]
aa.map! {|i| i * 3 }
a
=> [3, 6, 9]
compact/compact!
compact从self中删除值为nil的元素后生成新数组并返回它。compact!是具有破坏性的,若对原数组进行了改动就返回self,若没有进行改动则返回nil。
a = [1, nil, 2, nil, 3, nil]
a.compact!
a
=> [1, 2, 3]
concat(other)
将other连接到self末尾(该动作具有破坏性)。返回self。
a=[1,2]
b=[3,4]
a.concat(b)
a
=>[1,2,3,4]
delete(val)/delete(val) { ... }
使用==来分别比较val与每个数组元素,若相等则删除该元素。若发现了与val相等的元素就返回val。若没有发现与val相等的元素则返回nil,若指定了块的话就对块进行计算并返回结果。
array = [1, 2, 3, 2, 1]
array.delete(2)
array
=> [1, 3, 1]
delete_at(pos)
删除pos所指位置的元素并返回它。若pos超出数组范围则返回nil。与at一样,可以使用负的索引从尾部起指定.
array = [0, 1, 2, 3, 4]
array.delete_at(2)
array
=> [0, 1, 3, 4]
delete_if {|x| ... }
reject! {|x| ... }
依次将元素传给块进行计算,若结果为真就删除相应元素。delete_if通常返回self。若没有删除任何元素时,reject!会返回nil。
a=[1,2,3]
a.delete_if{|x|x=false}
=>[1,2,3]
a.delete_if{|x|x=true}
=>[]
each {|item| .... }
依次使用每个元素来计算块。返回self。
a=[1, 2, 3]
a.each{|i|puts i}
1
2
3
=>[1,2,3]
each_index {|index| .... }
依次使用每个元素的索引来对块进行计算
a=[1, 2, 3]
a.each_index{|i|puts i}
1
2
3
=>[1,2,3]
empty?
若数组元素数目为0则返回真。
eql?(other)
使用Object#eql?来依次计算self和other的各个元素,若所有元素均相等则返回真。
fetch(nth)
fetch(nth, ifnone)
fetch(nth) {|nth| ... }
与Array#[nth]一样,返回第nth个元素。但若没有第nth个元素的话,它的运作就有别于Array#[nth]了:第一种形式会引发IndexError异常。第二种形式会返回参数ifnone。而第三种形式会返回块的计算结果。
a=[1, 2, 3]
a.fetch(1)
=>2
fill(val)
fill(val, start[, length])
fill(val, start..end)
fill {|index| ... }
fill(start[, length]) {|index| ... }
fill(start..end) {|index| ... }
将val赋值给数组中被指定的范围内的所有元素。在第二种形式中,若省略length则意味着将指定范围扩大到数组尾部。若指定范围最终超出原数组的长度时,将自动加长原数组,并以val来对新增元素进行初始化。
a=[1, 2, 3]
a.fill(1)
=>[1,1,1]
first/first(n)
返回数组的首元素。若没有首元素则返回nil。
a=[1, 2, 3]
a.first
=>1
a.first(2)
=>[1,2]
flatten/flatten!
将带嵌套的数组重整为不带嵌套的单纯数组,并返回它。flatten!的重整具有破环性,若原数组不带嵌套则返回nil。
a=[1, [2, 3, [4], 5]]
a.flatten
=> [1, 2, 3, 4, 5]
include?(val)
若数组中包含==val的元素就返回真。
index(val)
返回数组中第一个==val的元素的位置。若没有与其相等的元素则返回nil。
a=[1, 2, 3]
a.index(1)
=>0
insert(nth, val[, val2 ...])/insert(nth, [val[, val2 ...]])
在索引为nth的元素前面插入第2参数以后的值。返回self。
a=[1, 2, 3]
a.insert(2,'a','b')
=>[1,2,"a","b",3]
join([sep])
将sep字符串夹在各元素中间使数组转换为字符串,并返回该字符串。
若数组元素并非字符串的话,就调用to_s然后再进行连接。若元素依然是数组时,将再归调用(同样适用sep)join来连接字符串。
若sep为nil则使用空字符串。
若参数sep被省略,则使用变量$,的值。$,的默认值为nil。
a = [1,2,3]
ary.join("a")
=> "1a2a3"
last/last(n)
返回数组末尾的元素。若数组为空时,返回nil。
a=[1, 2, 3]
a.last
=>3
a.lasst(2)
=>[2,3]
length/size
返回数组长度。若数组为空则返回0.
a=[1, 2, 3]
a.length
=>3
a.size
=>3
nitems
返回非nil元素的个数
pack(template)
按照template所指字符串的样式,以二进制的形式将数组的内容打包成字符串,并返回该字符串
pop
删除末尾元素并返回它。若数组为空则返回nil。
a=[1, 2, 3]
a.pop
=>[1,2]
push(obj1[, obj2 ...])/push([obj1[, obj2 ...]])
依次将obj1, obj2 ...添加到数组结尾。
array = [1, 2, 3]
array.push(4)
=>[1,2,3,4]
rassoc(obj)
假定self是数组中的元素数组,若首次发现元素数组中索引为1的元素与obj相等时就返回该元素。使用==操作符进行比较。若没有符合条件的元素数组则返回nil。
a = [[15,1], [25,2], [35,3]]
a.rassoc(2)
=> [25, 2]
replace(another)
以数组another来替换该数组的内容。返回self。
a = [1, 2, 3]
a.replace([4, 5])
=>[4,5]
reverse/reverse!
reverse将所有元素以逆序重新排列生成新数组并返回它。reverse!的逆序排列过程具有破环性。reverse通常返回新数组。若数组只有1个元素,reverse!会返回nil,除此以外将返回self。
a = [1, 2, 3]
a.reverse
=>[3,2,1]
reverse_each {|item| ... }
对各个元素以逆序对块进行计算。返回self。
rindex(val)
返回最后一个== val的元素的索引值。若没有符合条件的元素时返回nil。
p [1, 0, 0, 1, 0].rindex(1)
=> 3
shift
删除数组的首元素并返回它。剩余元素依次提前。若数组为空返回nil。
slice(pos[, len])/slice(start..last)
与self[]相同。
slice!(pos[, len])/slice!(start..last)
删除指定的元素并返回它。若没有可删除的元素时返回nil。
sort
sort!
sort {|a, b| ... }
sort! {|a, b| ... }
对数组内容进行排序。若带块调用时,将把2个参数传给块,然后使用块的计算结果进行比较。若没有块时,使用<=>操作符进行比较。sort将生成一个经过排序的新数组并返回它。sort!的对self的排序过程具有破环性。
to_a/to_ary
原封不动地返回self。
to_s
与self.join($,)相同。
transpose
将self看作是由行和列构成的矩阵,然后进行行列互调(将行和列互换)。生成一个新数组并返回它。若原数组为空,则生成空数组并返回它。
uniq/uniq!
uniq会删除数组中的重复元素后生成新数组并返回它。剩下的元素会向前移动。uniq!具有破环性,若进行了删除则返回self,若没有删除则返回nil。
unshift(obj1[, obj2 ...])
unshift([obj1[, obj2 ...]])
依次将obj1, obj2 ...插到数组的头部。返回self。
values_at(index_1, ... , index_n)
以数组形式返回其索引值与各参数值相等的元素。若指定了超出范围的索引值时,将指派nil与其对应
TAG:
标题搜索
日历
|
|||||||||
日 | 一 | 二 | 三 | 四 | 五 | 六 | |||
1 | 2 | 3 | 4 | 5 | 6 | ||||
7 | 8 | 9 | 10 | 11 | 12 | 13 | |||
14 | 15 | 16 | 17 | 18 | 19 | 20 | |||
21 | 22 | 23 | 24 | 25 | 26 | 27 | |||
28 | 29 | 30 |
我的存档
数据统计
- 访问量: 150739
- 日志数: 185
- 文件数: 6
- 建立时间: 2007-08-06
- 更新时间: 2015-01-06