Ruby语言入门（12）- 内部类 - Array

上一篇 / 下一篇  2013-02-01 15:54:37 / 个人分类：语言

查看( 352 ) / 评论( 0 ) / 评分( 0 / 0 )
数组的元素可以是任意的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:

 

评分：0

我来说两句

日历

« 2024-03-19  
日 一 二 三 四 五 六
     12
3456789
10111213141516
17181920212223
24252627282930
31      

数据统计

  • 访问量: 148372
  • 日志数: 185
  • 文件数: 6
  • 建立时间: 2007-08-06
  • 更新时间: 2015-01-06

RSS订阅

Open Toolbar