一、Array的用法
1.新建数组
ary = [1, "two", 3.0] #=> [1, "two", 3.0]ary = Array.new#=> []Array.new(3) #=> [nil, nil, nil]Array.new(3, true) #=> [true, true, true]Array.new(4) { Hash.new } #=> [{}, {}, {}, {}]empty_table = Array.new(3) { Array.new(3) } #=> [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]Array({:a => "a", :b => "b"}) #=> [[:a, "a"], [:b, "b"]]2.元素访问
arr = [1, 2, 3, 4, 5, 6] arr[2] #=> 3arr[100] #=> nil arr[-3] #=> 4 arr[2, 3] #=> [3, 4, 5] arr[1..4] #=> [2, 3, 4, 5]arr.at(0) #=> 1arr = ['a', 'b', 'c', 'd', 'e', 'f'] arr.fetch(100) #=> IndexError: index 100 outside of array bounds: -6...6 arr.fetch(100, "oops") #=> "oops" arr.first #=> 1 arr.last #=> 6arr.take(3) #=> [1, 2, 3]arr.drop(3) #=> [4, 5, 6]
3.获取数组信息
browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE']
browsers.length #=> 5browsers.count #=> 5browsers.empty? #=> falsebrowsers.include?('Konqueror') #=> false4.向数组添加元素
arr = [1, 2, 3, 4]
arr.push(5) #=> [1, 2, 3, 4, 5]arr <<6 #=> [1, 2, 3, 4, 5, 6]arr.unshift(0) #=> [0, 1, 2, 3, 4, 5, 6]a = [ "b", "c", "d" ]
a.unshift("a") #=> ["a", "b", "c", "d"] a.unshift(1, 2) #=> [ 1, 2, "a", "b", "c", "d"]arr.insert(3, 'apple') #=> [0, 1, 2, 'apple', 3, 4, 5, 6]arr.insert(3, 'orange', 'pear', 'grapefruit') #=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]5.从数组删除元素
arr = [1, 2, 3, 4, 5, 6]
arr.pop #=> 6arr #=> [1, 2, 3, 4, 5] arr.pop(2) #=>[4,5] arr #=>[1,2,3] arr.shift #=> 1 arr #=> [2, 3, 4, 5] arr.delete_at(2) #=> 4 arr #=> [2, 3, 5] arr = [1, 2, 2, 3]
arr.delete(2) #=> [1, 3]a = [ "a", "b", "b", "b", "c" ]
a.delete("b") #=> "b" a #=> ["a", "c"] a.delete("z") #=> nil a.delete("z") { "not found" } #=> "not found"arr = ['foo', 0, nil, 'bar', 7, 'baz', nil]
arr.compact #=> ['foo', 0, 'bar', 7, 'baz'] arr #=> ['foo', 0, nil, 'bar', 7, 'baz', nil]arr.compact! #=> ['foo', 0, 'bar', 7, 'baz'] arr #=> ['foo', 0, 'bar', 7, 'baz']arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]a = [ "a", "b", "c" ]
a.delete_if {|x| x >= "b" } #=> ["a"]a = [ "a", "b", "c" ]
a.slice!(1) #=> "b"a #=> ["a", "c"]a.slice!(-1) #=> "c"a #=> ["a"] a.slice!(100) *#=> nila #=> ["a"]6.遍历数组
arr = [1, 2, 3, 4, 5]
arr.each { |a| printa -= 10, " " } # prints: -9 -8 -7 -6 -5#=> [1, 2, 3, 4, 5]words = %w[rats live on no evil star]str = ""words.reverse_each { |word| str += "#{word.reverse} " } str#=> "rats live on no evil star "arr.map { |a| 2*a } #=> [2, 4, 6, 8, 10]arr#=> [1, 2, 3, 4, 5]arr.map! { |a| a**2 } #=> [1, 4, 9, 16, 25]arr#=> [1, 4, 9, 16, 25]7.从数组选择元素
arr = [1, 2, 3, 4, 5, 6]
arr.select { |a| a > 3 } #=> [4, 5, 6]arr.reject { |a| a < 3 } #=> [3, 4, 5, 6]arr.reject { |a| a == 3 } #=> [1, 2, 4, 5, 6]arr.drop_while { |a| a < 4 } #=> [4, 5, 6]arr#=> [1, 2, 3, 4, 5, 6]arr.delete_if { |a| a < 4 } #=> [4, 5, 6]arr#=> [4, 5, 6]arr = [1, 2, 3, 4, 5, 6]
arr.keep_if { |a| a < 4 } #=> [1, 2, 3]arr#=> [1, 2, 3]8.获取两个数组相同的元素
[ 1, 1, 3, 5 ] & [ 1, 2, 3 ] #=> [ 1, 3 ][ 'a', 'b', 'b', 'z' ] & [ 'a', 'b', 'c' ] #=> [ 'a', 'b' ]
9.数组成倍夸张
[ 1, 2, 3 ] * 3 #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ][ 1, 2, 3 ] * "," #=> "1,2,3" 同: [ 1, 2, 3 ].join(',')10.数组相加
[ 1, 2, 3 ] + [ 4, 5 ] #=> [ 1, 2, 3, 4, 5 ]a = [ "a", "b", "c" ] a + [ "d", "e", "f" ] a #=> [ "a", "b", "c", "d", "e", "f" ]
11.数组相减
[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]
12.数组追加
[ 1, 2 ] << "c" << "d" << [ 3, 4 ]#=> [ 1, 2, "c", "d", [ 3, 4 ] ][ "a", "b" ].concat( ["c", "d"] ) #=> [ "a", "b", "c", "d" ] a = [ 1, 2, 3 ] a.concat( [ 4, 5 ] ) a #=> [ 1, 2, 3, 4, 5 ]
13.数组比较
[ "a", "a", "c" ] <=> [ "a", "b", "c" ] #=> -1[ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ]#=> +1[ "a", "c" ]== [ "a", "c", 7 ] #=> false [ "a", "c", 7 ] == [ "a", "c", 7 ] #=> true [ "a", "c", 7 ] == [ "a", "d", "f" ] #=> false
14.获取数组中的元素
a = [ "a", "b", "c", "d", "e" ] a[2] + a[0] + a[1] #=> "cab" a[6] #=> nil a[1, 2] #=> [ "b", "c" ] a[1..3] #=> [ "b", "c", "d" ] a[4..7] #=> [ "e" ] a[6..10] #=> nil a[-3, 3] #=> [ "c", "d", "e" ] # special cases a[5] #=> nil a[6, 1] #=> nil a[5, 1] #=> [] a[5..10] #=> []
15.数组赋值
a = Array.new a[4] = "4"; #=> [nil, nil, nil, nil, "4"] a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"] a[1..2] = [ 1, 2 ] #=> ["a", 1, 2, nil, "4"] a[0, 2] = "?" #=> ["?", 2, nil, "4"] a[0..2] = "A" #=> ["A", "4"] a[-1] = "Z" #=> ["A", "Z"] a[1..-1] = nil #=> ["A", nil] a[1..-1] = [] #=> ["A"] a[0, 0] = [ 1, 2 ] #=> [1, 2, "A"] a[3, 0] = "B" #=> [1, 2, "A", "B"]
16.计算字符串中自身缩写集
require 'abbrev' %w{ car cone }.abbrev #=> {"car"=>"car", "ca"=>"car", "cone"=>"cone", "con"=>"cone", "co"=>"cone"}%w{ number cone }.abbrev#=> {"number"=>"number", "numbe"=>"number", "numb"=>"number", "num"=>"number", "nu"=>"number", "n"=>"number", "cone"=>"cone", "con"=>"cone", "co"=>"cone", "c"=>"cone"}%w{ fast boat day }.abbrev(/^.a/) #=> {"fast"=>"fast", "fas"=>"fast", "fa"=>"fast", "day"=>"day", "da"=>"day"}17.查找二维数组首元素匹配的数组
s1 = [ "colors", "red", "blue", "green" ]
s2 = [ "letters", "a", "b", "c" ]
s3 = "foo" a = [ s1, s2, s3 ]
a.assoc("letters") #=> [ "letters", "a", "b", "c" ] a.assoc("foo") #=> nila.assoc("a") #=> nil18.清空数组
a = [ "a", "b", "c", "d", "e" ] a.clear #=> [ ]
19.数组元素调整
a = [ "a", "b", "c", "d" ]
a.map { |x| x + "!" } #=> ["a!", "b!", "c!", "d!"] a #=> ["a", "b", "c", "d"]a = [ "a", "b", "c", "d" ]
a.map! {|x| x + "!" }
a #=> [ "a!", "b!", "c!", "d!" ]20.一维数组转多维数组
a = [1, 2, 3, 4] a.combination(1).to_a #=> [[1],[2],[3],[4]] a.combination(2).to_a #=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]] a.combination(3).to_a #=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]] a.combination(4).to_a #=> [[1,2,3,4]] a.combination(0).to_a #=> [[]] # one combination of length 0 a.combination(5).to_a #=> [] # no combinations of length 5
21.去除数组中的nil元素
[ "a", nil, "b", nil, "c", nil ].compact #=> [ "a", "b", "c" ][ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ] [ "a", "b", "c" ].compact! #=> nil
22.数组统计
ary = [1, 2, 4, 2] ary.count #=> 4 ary.count(2) #=> 2 ary.count { |x| x%2 == 0 } #=> 323.数组循环
n次a = ["a", "b", "c"]
a.cycle { |x| puts x } # print, a, b, c, a, b, c,.. forever. a.cycle(2) { |x| puts x } # print, a, b, c, a, b, c.24.数组为空判断
[].empty? #=> true
25.改变数组元素
a = [ "a", "b", "c", "d" ]
a.fill("x") #=> ["x", "x", "x", "x"] a.fill("z", 2, 2) #=> ["x", "x", "z", "z"] a.fill("y", 0..1) #=> ["y", "y", "z", "z"] a.fill { |i| i*i } #=> [0, 1, 4, 9] a.fill(-2) { |i| i*i*i } #=> [0, 1, 8, 27]26.定位指定元素的位置
a = [ "a", "b", "c" ]
a.index("b") #=> 1 a.index("z") #=> nil a.index { |x| x == "b" } #=> 127.获取数组前n个元素
a = [ "q", "r", "s", "t" ] a.first #=> "q" a.first(2) #=> ["q", "r"]
28.多维数组向低维数组转换
s = [ 1, 2, 3 ] #=> [1, 2, 3] t = [ 4, 5, 6, [7, 8] ] #=> [4, 5, 6, [7, 8]] a = [ s, t, 9, 10 ] #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10] a.flatten #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] a = [ 1, 2, [3, [4, 5] ] ] a.flatten(1) #=> [1, 2, 3, [4, 5]]a = [ 1, 2, [3, [4, 5] ] ] a.flatten! #=> [1, 2, 3, 4, 5] a.flatten! #=> nil a #=> [1, 2, 3, 4, 5] a = [ 1, 2, [3, [4, 5] ] ] a.flatten!(1) #=> [1, 2, 3, [4, 5]]
29.数组替换
a = [ "a", "b", "c", "d", "e" ] a.replace([ "x", "y", "z" ]) #=> ["x", "y", "z"] a #=> ["x", "y", "z"]
30.插入元素到数组指定位置
a = %w{ a b c d } a.insert(2, 99) #=> ["a", "b", 99, "c", "d"] a.insert(-2, 1, 2, 3) #=> ["a", "b", 99, "c", 1, 2, 3, "d"]31.数组元素拼接为指定格式字符串
[ "a", "b", "c" ].join #=> "abc" [ "a", "b", "c" ].join("-") #=> "a-b-c"32.获取数组后n个元素
a = [ "w", "x", "y", "z" ] a.last #=> "z" a.last(2) *#=> ["y", "z"]*
33.数组元素反转
[ "a", "b", "c" ].reverse #=> ["c", "b", "a"] [ 1 ].reverse #=> [1]a = [ "a", "b", "c" ] a.reverse! #=> ["c", "b", "a"] a #=> ["c", "b", "a"]
34.数组从后向前循环
a = [ "a", "b", "c" ] a.reverse_each {|x| print x, " " } #=> c b a35.定位数组元素最后一个出现的位置
a = [ "a", "b", "b", "b", "c" ]
a.rindex("b") #=> 3 a.rindex("z") #=> nil a.rindex { |x| x == "b" } #=> 336.从一个数组随机去n个元素
a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] a.sample #=> 7 a.sample(4) #=> [6, 4, 2, 5]
37.随机打乱数组元素
a = [ 1, 2, 3 ] #=> [1, 2, 3] a.shuffle #=> [2, 3, 1]a.shuffle(random: Random.new(1)) #=> [1, 3, 2]
38.数组排序
a = [ "d", "a", "e", "c", "b" ]
a.sort #=> ["a", "b", "c", "d", "e"] #升序排序a.sort { |x,y| y <=> x } #=> ["e", "d", "c", "b", "a"] #降序排序a = [ "d", "a", "e", "c", "b" ]
a.sort! #=> ["a", "b", "c", "d", "e"] a.sort! { |x,y| y <=> x } #=> ["e", "d", "c", "b", "a"]39.二维数组行列倒转
a = [[1,2], [3,4], [5,6]] a.transpose #=> [[1, 3, 5], [2, 4, 6]]
40.数组去重
a = [ "a", "a", "b", "b", "c" ]
a.uniq # => ["a", "b", "c"] b = [["student","sam"], ["student","george"], ["teacher","matz"]]
b.uniq { |s| s.first } # => [["student", "sam"], ["teacher", "matz"]]a = [ "a", "a", "b", "b", "c" ] a.uniq! # => ["a", "b", "c"]b = [ "a", "b", "c" ] b.uniq! # => nilc = [["student","sam"], ["student","george"], ["teacher","matz"]]
c.uniq! { |s| s.first } # => [["student", "sam"], ["teacher", "matz"]]41.一次获取数组不同位置的元素
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, -2, -2, -7) # => ["f", "e", "e", nil] a.values_at(4..6, 3...6) # => ["e", "f", nil, "d", "e", "f"]42.多个一维数组组成二维矩阵
a = [ 4, 5, 6 ] b = [ 7, 8, 9 ] [1, 2, 3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]][1, 2].zip(a, b) #=> [[1, 4, 7], [2, 5, 8]] a.zip([1, 2], [8]) #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]
43.合并两个数组并且去重
[ "a", "b", "c" ] | [ "c", "d", "a" ] #=> [ "a", "b", "c", "d" ]
44.combination
a= [1,2,3,4]a.combination(1).to_a#=> [[1],[2],[3],[4]]a.combination(2).to_a#=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]a.combination(3).to_a#=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]a.combination(4).to_a#=> [[1,2,3,4]]a.combination(0).to_a#=> [[]] # one combination of length 0a.combination(5).to_a#=> [] # no combinations of length 5
coerce
1.coerce(2) # => [2, 1] 1.coerce(2.3) # => [2.3, 1.0] (4.5).coerce(2.3) # => [2.3, 4.5] (4.5).coerce(2) # => [2.0, 4.5]
"%05d" % 123 #=> "00123""%-5s: %08x" % [ "ID", self.object_id ] #=> "ID : 200e14d6""foo = %{foo}" % { :foo => 'bar' } #=> "foo = bar"2.复制字符串
"Ho! " * 3 #=> "Ho! Ho! Ho! ""Ho! " * 0 #=> ""
3.字符串拼接
"Hello from " + self.to_s #=> "Hello from main"a = "hello "a << "world" #=> "hello world"a.concat(33) #=> "hello world!"
4.字符串比较
"abcdef" <=> "abcde" #=> 1"abcdef" <=> "abcdef" #=> 0"abcdef" <=> "abcdefg" #=> -1"abcdef" <=> "ABCDEF" #=> 1"abcdef".casecmp("abcde") #=> 1 "aBcDeF".casecmp("abcdef") #=> 0"abcdef".casecmp("abcdefg") #=> -1"abcdef".casecmp("ABCDEF") #=> 05.获取子字符串
a = "hello there"a[1] #=> "e" a[2, 3] #=> "llo"a[2..3] #=> "ll"a[-3, 2] #=> "er"a[7..-2] #=> "her"a[-4..-2] #=> "her"a[-2..-4] #=> ""a[11, 0] #=> ""a[11] #=> nila[12, 0] #=> nila[12..-1] #=> nila[/[aeiou](.)\1/] #=> "ell"a[/[aeiou](.)\1/, 0] #=> "ell"a[/[aeiou](.)\1/, 1] #=> "l"a[/[aeiou](.)\1/, 2] #=> nila[/(?[aeiou])(?[^aeiou])/, "non_vowel"] #=> "l"a[/(?[aeiou])(?[^aeiou])/, "vowel"] #=> "e"a["lo"] #=> "lo"a["bye"] #=> nil
6.判断字符串是否只有ASCII字符
"abc".force_encoding("UTF-8").ascii_only? #=> true "abc\u{6666}".force_encoding("UTF-8").ascii_only? #=> false7.统计字符串字节长度
"\x80\u3042".bytesize #=> 4 "hello".bytesize #=> 5
8.首字母大写
"hello".capitalize #=> "Hello" "HELLO".capitalize #=> "Hello" "123ABC".capitalize #=> "123abc"
9.字符串居中
"hello".center(4) #=> "hello""hello".center(20) #=> " hello " "hello".center(20, '123') #=> "1231231hello12312312"
10.去除字符串尾部换行符或者指定字符
"hello".chomp #=> "hello" "hello\n".chomp #=> "hello" "hello\r\n".chomp #=> "hello" "hello\n\r".chomp #=> "hello\n" "hello\r".chomp #=> "hello" "hello \n there".chomp #=> "hello \n there" "hello".chomp("llo") #=> "he"11.去除字符串尾部最后一个字符
"string\r\n".chop #=> "string""string\n\r".chop #=> "string\n""string\n".chop #=> "string""string".chop #=> "strin""x".chop.chop #=> ""
12.获取字符串第一个字符
a = "abcde" a.chr #=> "a"
13.清空字符
a = "abcde" a.clear #=> ""
14.统计字符串指定字符出现的个数
a = "hello world" a.count "lo" #=> 5a.count "lo", "o" #=> 2a.count "hello", "^l" #=> 4a.count "ej-m" #=> 4"hello^world".count "\\^aeiou" #=> 4"hello-world".count "a\\-eo" #=> 4c = "hello world\\r\\n"c.count "\\" #=> 2c.count "\\A" #=> 0c.count "X-\\w" #=> 3
15.删除字符串指定字符
"hello".delete "l","lo" #=> "heo""hello".delete "lo" #=> "he""hello".delete "aeiou", "^e" #=> "hell""hello".delete "ej-m" #=> "ho"
16.字符串小写
"hEllO".downcase #=> "hello"
17.遍历字符串
"hello".each_char {|c| print c, ' ' }18.判断字符串长度是否为
"hello".empty? #=> false " ".empty? #=> false "".empty? #=> true
19.替换字符串指定字符
"hello".gsub(/[aeiou]/, '*') #=> "h*ll*""hello".gsub(/([aeiou])/, '<\1>') #=> "hll""hello".gsub(/./) {|s| s.ord.to_s + ' '} #=> "104 101 108 108 111 ""hello".gsub(/(?[aeiou])/, '{\k}') #=> "h{e}ll{o}"'hello'.gsub(/[eo]/, 'e' => 3, 'o' => '*') #=> "h3ll*"19-01.gsub案例（AaaBaa替换为aaa_baa）
"HelloWorld".gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase#=> "hello_world""World".gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase#=> "world"20.判断字符串是否包含指定字符串
"hello".include? "lo" #=> true"hello".include? "ol" #=> false"hello".include? ?h #=> true
21.定位指定字符在字符串中的位置第一次出现的位置
"hello".index('e') #=> 1"hello".index('lo') #=> 3"hello".index('a') #=> nil"hello".index(?e) #=> 1"hello".index(/[aeiou]/, -3) #=> 4最后一次出现的位置"hello".rindex('e') #=> 1
"hello".rindex('l') #=> 3"hello".rindex('a') #=> nil"hello".rindex(?e) #=> 1"hello".rindex(/[aeiou]/, -2) #=> 122.字符串替换
s = "hello" #=> "hello"s.replace "world" #=> "world"
23.插入字符到指定位置
"abcd".insert(0, 'X') #=> "Xabcd""abcd".insert(3, 'X') #=> "abcXd""abcd".insert(4, 'X') #=> "abcdX""abcd".insert(-3, 'X') #=> "abXcd""abcd".insert(-1, 'X') #=> "abcdX"
24.字符串对齐左对齐
"hello".ljust(4) #=> "hello" "hello".ljust(20) #=> "hello " "hello".ljust(20, '1234') #=> "hello123412341234123"右对齐"hello".rjust(4) #=> "hello" "hello".rjust(20) #=> " hello" "hello".rjust(20, '1234') #=> "123412341234123hello"
25.去除字符串空格
" hello ".lstrip #=> "hello " "hello".lstrip #=> "hello"" hello ".rstrip #=> " hello" "hello".rstrip #=> "hello"" hello ".strip #=> "hello" "\tgoodbye\r\n".strip #=> "goodbye"
26.字符串匹配
'hello'.match('(.)\1') #=> #'hello'.match('(.)\1')[0] #=> "ll" 'hello'.match(/(.)\1/)[0] #=> "ll" 'hello'.match('xx') #=> nil27.字符串加一
"abcd".succ #=> "abce""THX1138".succ #=> "THX1139""<>".succ #=> "<>""1999zzz".succ #=> "2000aaa""ZZZ9999".succ #=> "AAAA0000""***".succ #=> "**+"
28.获取字符指定ASCII码值
"a".ord #=> 97
29.分割字符串到指定数组
str.partition(sep) [head, sep, tail]
str.partition(regexp) [head, match, tail]"hello".partition("l") #=> ["he", "l", "lo"]"hello".partition("x") #=> ["hello", "", ""]"hello".partition(/.l/) #=> ["h", "el", "lo"]"hello".rpartition("l") #=> ["hel", "l", "o"]"hello".rpartition("x") #=> ["", "", "hello"]"hello".rpartition(/.l/) #=> ["he", "ll", "o"]30.追加字符串到指定字符串最前面
a = "world" a.prepend("hello ") #=> "hello world" a #=> "hello world"31.反转字符串
"stressed".reverse #=> "desserts"
32.分割字符串
" now's the time".split #=> ["now's", "the", "time"] " now's the time".split(' ') #=> ["now's", "the", "time"] " now's the time".split(/ /) #=> ["", "now's", "", "the", "time"]"1, 2.34,56, 7".split(%r{,\s*}) #=> ["1", "2.34", "56", "7"] "hello".split(//) #=> ["h", "e", "l", "l", "o"] "hello".split(//, 3) #=> ["h", "e", "llo"] "hi mom".split(%r{\s*}) #=> ["h", "i", "m", "o", "m"] "mellow yellow".split("ello") #=> ["m", "w y", "w"] "1,2,,3,4,,".split(',') #=> ["1", "2", "", "3", "4"] "1,2,,3,4,,".split(',', 4) #=> ["1", "2", "", "3,4,,"] "1,2,,3,4,,".split(',', -4) #=> ["1", "2", "", "3", "4", "", ""] "".split(',', -1)* #=> []*"World".split('r')[0]#=> "Wo""World".split('r')[1]#=> "ld"33.去除字符串中重复的字符
"yellow moon".squeeze #=> "yelow mon" " now is the".squeeze(" ") #=> " now is the" "putters shoot balls".squeeze("m-z") #=> "puters shot balls"34.大小写互换
"Hello".swapcase #=> "hELLO""cYbEr_PuNk11".swapcase #=> "CyBeR_pUnK11"
35.字符串转大写
"hEllO".upcase #=> "HELLO"
36.字符串循环
"a8".upto("b6") {|s| print s, ' ' } #=> a8 a9 b0 b1 b2 b3 b4 b5 b6"9".upto("11").to_a #=> ["9", "10", "11"] "25".upto("5").to_a #=> [] "07".upto("11").to_a #=> ["07", "08", "09", "10", "11"]37.判断字符串编码是否正确
"\xc2\xa1".force_encoding("UTF-8").valid_encoding? #=> true "\xc2".force_encoding("UTF-8").valid_encoding? #=> false "\x80".force_encoding("UTF-8").valid_encoding? #=> false三、Ruby中Enumerable#inject用法示范
Enumerable#inject是Ruby核心库中的一个简洁而且强大的API，今天读到一段简洁的代码之后，对这个API产生了浓厚的兴趣，索性搜寻一下资料，总结一下它的用法。
代码如下：
Java代码
def text_at(*args)
args.inject(@feed) { |s, r| s.send(:at, r)}.inner_text
end这段代码完成的功能是：取出XML文件中某子元素的文本内容，它是用nokogiri库来完成这个功能的。关于Nokogiri库API（at(), inner_text()）的细节我们不谈，只是用这段代码来引起你对inject的兴趣，现在我们来看inject的用法。
Enumerable#inject是很多Ruby高手喜欢的API，因此将来读Ruby也会经常遇到，即使有的用法不能完全理解，也要先混个脸熟，使用场景见多了就自然理解了。
数字求和
Inject最常见的用法就是这一个了，假定你有一个内容为数字的数组，你可以像下面这样对它求和：
Ruby代码
irb(main):001:0> [1, 2, 3, 4, 5].inject(0) { |sum, e| sum + e }
=> 15或者像这样：
Ruby代码
irb(main):002:0> (1..5).inject(0) { |sum, e| sum + e }
=> 15用区间或者数组在这里没有分别，Ruby会自动转换。Inject在这里接受一个方法参数和一个block. 对数组中的每一个元素，block都执行一次。第一次执行block的时候，inject接收的方法参数被作为block的第一个参数，而block的第二个参数则是数组的第一个元素。第二次执行block的时候，情况就有了变化，这也是inject神奇的地方。这时候block的第一个参数则是block上一次执行的返回值（block的最后一个表达式），第二个参数则是数组的第二个元素，后面的三次执行方式与第二次相同，这样我们就计算出了数组元素之和。事实上，上面的代码还可以更简洁一些：
Ruby代码
irb(main):006:0> [1, 2, 3, 4, 5].inject { |sum, e| sum + e }
=> 15这段代码可以计算出相同结果的原因是：inject的方法参数是可选的，如果不提供的话，Ruby默认将数组的第一个元素作为block第一次执行时候的第一个参数，在这种情况下，block一共需要执行4次，比传入默认参数的形式少执行一次。
转换数据结构
2.1生成Hash：
Java代码
hash = [[:first_name, 'Shane'], [:last_name, 'Harvie']].inject({}) do |result, element|
result[element.first] = element.last
result
end当然这种用法也有别的形式，并不一定需要用到inject，比如：
Java代码
Hash[*[[:first_name, 'Shane'], [:last_name, 'Harvie']].flatten]
可以达到相同目的而代码更简洁。
2.2 过滤数组：
Ruby代码
arr = [1, 2, 3, 4, 5, 6].inject([]) do |r, e| r << e.to_s if e % 2 == 0 rend
当然这种用法也有不使用inject的等价方式：
Java代码
[1, 2, 3, 4, 5, 6].select { |e| e % 2 == 0 }.collect { |e| e.to_s } # => ["2", "4", "6"]具体用哪一种就是萝卜青菜，各有所爱了。
更高级的用法
先看一段代码：
Ruby代码
class Recorder # undefine any instance methods except methods start from __ # and inspect/to_str/object_id instance_methods.each do |meth| undef_method meth unless meth =~ /^(__|inspect|to_str)|object_id/ end # store messages sent to the Recorder object # that's why it's called Recorder def method_missing(sym, *args) messages << [sym, args] self end # getter of instance variable messages def messages @messages ||= [] endend
代码中比较难懂的部分已经加了注释，类Recorder完成的功能是记录所有发送给它对象的消息（Ruby中对象调用通常称作向对象发送消息）。下面我们再打开类Recorder，定义另一方法来展示这些保存的消息：
Ruby代码
class Recorder def play_for(obj) messages.inject(obj) do |result, msg| result.send msg.first, *msg.last end endend
在这个方法中，我们用到了inject, 它向传入的对象obj调用保存的消息，并传入之前调用者传入的所有参数。下面的代码展现了它的用法：
Ruby代码
recorder = Recorder.new recorder.methods.sort recorder.play_for(String)
它实现了对String对象（你应该可以想起来，Ruby的类也是对象）调用#methods(), 然后对#methods返回结果调用#sort().
其实上面这个Recorder示例和本文开头的那个范例原理相同，前一个调用可以响应第一个消息，返回的结果则分别可以响应接下来的消息，对比这两个示例可以对Enumerable#inject的强大之处有所体会。
参考：http://blog.jayfields.com/2008/03/ruby-inject.html
作者：zhaoyshine
链接：https://www.jianshu.com/p/3eeac5fb2884
随时随地看视频
