定义二维数组:
list = [['保密',''],['男',1],['女',0]]
引用
怎么创建与返回值是二维数组形式
不知道你想要怎样的答案
如果是一方法想要返回二维数组，方法的最后一行是那个数组就好了
def list
[['保密',''],['男',1],['女',0]]
end
输出二维数组：
p [['保密',''],['男',1],['女',0]]
#或者
puts [['保密',''],['男',1],['女',0]].inspect
根据内容删除数组：
irb(main):010:0> [[1],2,3].delete([1])
=> [1]
irb(main):011:0> [[1],2,3].delete(2)
=> 2
irb(main):012:0>
根据索引删除数组：
irb(main):012:0> [[1],2,3].delete_at(2)
=> 3
irb(main):013:0> [[1],2,3].delete_at(0)
=> [1]
irb(main):014:0>
插入起始位置
irb(main):021:0> [[1],2,3].insert(0, ['aa'])
=> ["aa", [1], 2, 3]
插入末尾位置
irb(main):022:0> [[1],2,3].insert(-1, ['aa'])
=> [[1], 2, 3, "aa"]
ruby中数组不用预分配空间，所以不用覆盖长度，超出长度索引，不抛出，返回nil
irb(main):023:0> [[1],2,3][100]
=> nil
数组常用功能
ZIP
a=[1,2,3,4,5]
b=[‘a’,’b’,’c’,’d’]
a.zip(b)
b.zip(a)
join
输出数组元素的一个逗号分隔的列表.您将能够得到一个字符串分隔的任何字符串
a.join(‘,’)
输出数组元素的一个逗号分隔的列表将能够得到一个字符串分隔的任何字符串，数组中的元素使用Array＃join方法。
p ["apple", "orange", "lemon"].join(',') #=> "apple,orange,lemon"
p ["apple", "orange", "lemon"].join('#') #=> "apple#orange#lemon"
p [55, 49, 100, 100, 0].join(',') #=> "55,49,100,100,0"
p [3, ["apple", 250], ["orange", 400]].join(',') #=> "3,apple,250,orange,400"
获取数组中的元素数
你可以得到数组中的元素个数的数组长度数组大小的方法或方法。
p ["apple", "orange", "lemon"].size #=> 3
p ["apple", "orange", "lemon"].length #=> 3
p [55, 49, 100, 100, 0].size #=> 5
p [3, ["apple", 250], ["orange", 400]].size #=> 3
将元素添加到数组
可以使用Array＃<<的方法，Array＃unshift方法，Array＃push。
array＃<<
将元素追加早最后，array＃unshift方法可以将元素添加到数组开头。
A = [1,2,3,4,5]＃=> [1,2,3,4,5]
A << 99＃=> [1,2,3,4,5,99]
A.Unshift （99）＃=> [99,1,2,3,4,5,99]
Array#push
方法可以被添加到的数组元素的结尾
A = [1,2,3,4,5]
A.Push（10）＃=> [1，2，3，4，5，10]
从开头或结尾的数组元素删除
在Array＃shift的方法，可以检索的元素，从一开始的数组。
array＃pop方法是可以检索的数组中的元素。提取值的数组移位的方法，数组＃pop方法，数组中的元素的提取物中删除。
a = [1,2,3,4,5]
a.push(10) #=> [1, 2, 3, 4, 5, 10]
p a.pop #=> 10
p a.pop #=> 5
p a #=> [1, 2, 3, 4]
提取一个子数组
你可以把部分的数组用array#slice的方法或Array＃[]的方法。
a = [1,2,3,4,5]
p a[0,2] #=> [1, 2]
p a[1..3] #=> [2, 3, 4]
p a.slice(0,2) #=> [1, 2]
p a.slice(1..3) #=> [2, 3, 4]
操作
交集
&
数组与，返回两数组的交集
[1,2] & [2,3] =>[2]
复制
*
复制数组n次
[1,2]*2 => [1,2,1,2]
并集
+
返回两数组的并集，但不排除重复元素
[1,2]+[2,3] =>[1,2,2,3]
追加
<<
追加元素，但不排除重复元素
[1,2]<<[2,3] => [1,2,2,3]
追加(去重)
|
追加元素，但排除重复元素
[1,2] | [2,3] => [1,2,3]
差集
-
返回第一个数组与第二个数组不同的元素
[1,2]-[2,3] => [1]
比较
<=>
比较数组
[1,2]<=>[2,3] =>flase
比较相等
==
比较数组，若所有元素均相等时返回真
[1,2]==[2,1] =>flase
寻找(关联)
assoc
从数组的每个元素中寻找指定对象
[[1,2],[3,4]].assoc(2)=> [1,2]
按索引查找
at
找到数组的第N个元素
负数表示逆向查找
["a","b","c","d","e"].at(0) => "a"
["a","b","c","d","e"].at(-1) => "e"
清空
clear
删除数组中的所有元素
["a","b","c","d","e"]. clear
过程块遍历处理
collect
collect！
用一个过程块对数组的每个元素进行处理
["a","b","c","d"].collect {|x| x + "!" } => ["a!", "b!", "c!", "d!"]
去nil
compact
compact!
删除值为nil的元素后生成新数组并返回它
["a",nil,"b",nil,"c",nil].compact => ["a", "b", "c"]
删除指定
delete
删除元素，如果元素重复，全部删除
a = [ "a", "b", "b", "b", "c" ]
a.delete("b")
puts a => ["a","c"]
删除位置
delete_at
删除pos所指位置的元素并返回它。若pos超出数组范围则返回nil
a = %w( ant bat cat dog )
a.delete_at(2)
a=> ["ant", "bat", "dog"]
a.delete_at(99) => nil
删除条件
delete_if
根据条件删除
a = [ "a", "b", "c" ]
a.delete_if {|x| x >= "b" } => ["a"]
遍历
each
对数组的每个元素按值进行迭代操作
查找
查寻方法find，也有：
list = ['a','b','c'] list.find{|x| x=='c'}
a = [ "a", "b", "c" ]
a.each {|x| print x, " -- " } => "a -- b -- c --"
遍历索引
each_index
对数组的每个元素按索引进行迭代操作
a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }=> "0 -- 1 -- 2 --"
判断空
empty?
判断数组是否为空，为空则返回真
[].empty?=> true
判断相等
eql！
比较两数组是否相等
["a","b","c"].eql?(["a","b","c"]) => true
填充
fill
填充数组
["a","b","c","d"].fill("x") => ["x","x","x","x"]
["a","b","c","d"].fill("z", 2, 2) => ["x", "x", "z", "z"]
返首
first
返回数组的首元素。若没有首元素则返回nil
[ "q", "r", "s", "t" ].first => "q"
返尾
last
返回数组末尾的元素。若数组为空时，返回nil
["w","x","y","z"].last => "z"
判断包含
include?
判断数组中是否包含元素
a = [ "a", "b", "c" ]
a.include?("b") => true
a.include?("z") => false
查索引
index
返回数组中第一个==val的元素的位置
a = [ "a", "b", "c" ]
a.index("b") => 1
a.index("z") => nil
按索引返
indexes
以数组形式返回其索引值与各参数值相等的元素
a = [ "a", "b", "c", "d", "e", "f", "g" ]
a.indexes(0, 2, 4) => ["a", "c", "e"]
a.indexes( 2, 4, 12)=> [ "c", "e", nil]
插入
insert
在索引为nth的元素前面插入第2参数以后的值
ary = %w(foo bar baz)
ary.insert 2,'a','b'
p ary => ["foo", "bar", "a", "b", "baz"]
加入间隔
join
将数组元素按一定的分隔符连接起来
[ "a", "b", "c" ].join=> "abc"
[ "a", "b", "c" ].join("-") => "a-b-c"
个数
length
尺寸
size
返回数组长度。若数组为空则返回0
[1,2,3].length => 3
[1,2,3].size => 3
取多个元素(子集)
nitems
返回非nil元素的个数
[ 1, nil, 3, nil, 5 ].nitems => 3
弹出
pop
删除末尾元素并返回它。若数组为空则返回nil
a = [ "a", "m", "z" ]
a.pop => "z"
p a => ["a", "m"]
压入
push
添加新元素
["a","b"].push(['1','2'])=>["a", "b", ["1", "2"]]
rassoc
遍历数组每个元素（元素必须是数组），匹配索引为1的值是否与查找的字符相等，返回第一个相等的元素
a = [[15,1], [25,2], [35,2]]
p a.rassoc(2) => [25, 2]
替换replace
替换数组元素
a = ["a","b"]
a.replace(["x","y","z"])
p a =>["x", "y", "z"]
反转reverse
reverse！
将所有元素以逆序重新排列生成新数组并返回它
["a","b","c" ].reverse=> ["c", "b", "a"]
右索引rindex
返回最后一个值相等的元素的索引值
a = [ "a","b","b","b","c"]
a.rindex("b") => 3
去首shift
删除数组的首元素并返回它。剩余元素依次提前。若数组为空返回nil
args = ["-m","-q","filename"]
args.shift => "-m"
args => ["-q", "filename"]
排序sort
sort!
从小到大排序
a = [ "d", "a", "e", "c", "b" ]
a.sort => ["a", "b", "c", "d", "e"]
去重uniq
uniq！
删除数组中的重复元素后生成新数组并返回它
a = [ "a", "a", "b", "b", "c" ]
a.uniq => ["a", "b", "c"]
从头插入unshift
在数组第一个元素前添加元素
a = [ "b", "c", "d" ]
a.unshift("a") => ["a", "b", "c", "d"]
转字符串to_s
将数组的所有元素连接成字符串
["a","e","i","o"].to_s => "aeio"
展平flatten
二维数组变一维