arr1.min arr1.length arr1.size

方式2：
irb(main):001:0> x = Array.new
=> []

irb(main):002:0> x = Array.new(3)
=> [nil, nil, nil]

irb(main):003:0> x = Array.new(3,"a")
=> ["a", "a", "a"]
上述第一个创建空数组，第二个创建预设SIZE的数组，第三个创建预设SIZE和值的数组。
跟Hash一样，第三种方法填充的预设值，都指向同一个目标。
任何一个位置的目标改变了，都影响所有元素的值：

2、数组操作

arr3[4] = '5'                    #此时arr3[3]默认尾nil
arr3.delete_at(3)                #删除指定下标的元素
arr3[2] = ["3a","3b","3c"]       #可以这样来做
arr3.delete(["3a","3b","3c"])    #可以删除上面添加的
arr3.push('6')                   #插入元素
arr3.insert(3,"b")               #在指定位置插入新元素
arr3<<"f"<<2                     #从左至右一次加入元素
arr3.pop                         #删除尾元素
arr3.shift                       #删除首元素
arr3.clear                       #清空数组

pop方法表示从尾部删除元素，shift表示从首部删除元素：
对应的有unshift方法，表示从首部添加元素：
数组有push和<<方法，表示添加元素到数组尾部

3. 数组的类型转换？

数组可以转换成串，使用to_s或者join方法：
irb(main):001:0> x=[1,2,3,4]
=> [1, 2, 3, 4]
irb(main):002:0> x.to_s
=> "1234"
irb(main):003:0> x.join "-"
=> "1-2-3-4"
串也可以转换成数组：
irb(main):012:0> str="1 2 3 4"
=> "1 2 3 4"
irb(main):013:0> str.to_a
=> ["1 2 3 4"]
这可能不是你想要的，那么执行：
irb(main):018:0> str.split(/ /).map {|s| s

4 Hash可以直接转换成二维数组

irb(main):010:0> hash={1=>2,3=>4}
=> {1=>2, 3=>4}
irb(main):011:0> hash.to_a
=> [[1, 2], [3, 4]]

a = [[:a, "apple"], [:b, "bear"]] 需求结果：{:a=>"apple", :b=>"bear"} h = a.inject({}){|dic,i| dic.merge({i[0]=>i[1]})} a.inject({ }) { |h, (k, v)| h[k] = v; h } 方式3：（after ruby2.1:） a.to_h 案例2：（参考空气1.0质量周报） @zm_hash={} zm_data.each do |zm| Rails.logger.info "---zm--#{zm}------" Rails.logger.info "---zm_item_name--#{zm['item_name']}------" Rails.logger.info "---zm_item_vale--#{zm['item_vale']}------" @zm_hash[zm['item_name']] = zm['item_vale']

6、数组运算
aaa = [" aa ",4,5," bb "]
bbb = [4,1,3,2,5]
print aaa + bbb,"\n"        # aa 45 bb 41325
print aaa*2,"\n"        # aa 45 66  aa 45 66
print bbb - aaa            #132
print aaa | bbb,"\n"        # aa 45 bb 132
print aaa & bbb,"\n"        #45
print bbb.sort,"\n"        #12345 排序
print aaa.reverse,"\n"        # bb 54 aa 倒置
print bbb.sort.reverse,"\n"     #54321 降序


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(); }