ruby array

@HASH 

# 两个arrays合成一个hash, 一个做keys, 一个做values. 

    ruby>$ hash = Hash[array_1.zip(array_2)]

    再比如，给定一个array，把它转成一个hash，使得key值为array的元素(假设两两不同)，value为index：

    ruby>$ hash = Hash[array.zip(0..array.length)]

@ 打印三剑客

    (1) puts会识别双引号内的转义符，并自动换行

     (2) p不会识别双引号内的转义符，并自动换行

    (3) print会识别双引号内的转义符，不自动换行

 

 

@Array. 

数组的索引从 0 开始，这与 C 或 Java 中一样。一个负数的索相对于数组的末尾计数的，也就是说，索引为 -1 表示数组的最后一个元素，-2 表示数组中的倒数第二个元素，依此类推。

多种方法创建数组：

    # 创建空数组 arr = Array.new

    # 指定大小数组 arr = Array.new(20)  # 大小可扩展

    # 创建并初始化数组 array = Array.new(3, 'abc') # ['abc', 'abc', 'abc']

    # 使用还有new的block  arr = Array.new(10) {|e| e = e ** 2}

    # 使用array中括号创建 arr = Array.[](1, 3, 5, 7) 或者直接 arr = Array(1, 3, 5, 7) 

    # 指定范围创建 arr = Array(0 .. 10)  /  arr = Array('a' .. 'i')

    # 多给arrays. arr = Array.new(3) { Array.new(3) }

 

关键词

    # first  / last / 

    # take (3) 返回前3个元素

    # drop(3) 丢掉前3个元素 

    # length = size = count 大小

    # empty? 判空

    # push = << / unshift / shift / pop 

    # insert (3, 'a') 指定位置塞进去元素， 可以塞多个元素 arr.insert (3, 'a', 'b', 'c') 

    # delete('a') 删除所有为'a'的元素 

    # compact (compact!) 移除空元素 nil （区别在于compact 不改arr本身，compact!则改变）

    # uniq (uniq!) 清除重复元素

    # reverse (reverse!) 逆转array

    # clear: remove all elements 

   

    # delete_if (|item| block}，删除满足条件的元素，array发生改变 

 

 

陷阱：

    # second_arr = Array.new(firstarray) 这时候二者是独立的，指向不同的object 

    # create hash的array时，用 a = Array.new(3, Hash.new) 方法create的所有hash都指向同一个object, 改变其中一个就会改变另外一个。这种结构存在的意义只能是：多重copy。如果想使不同位置的hash相互独立，用 a = Array.new(2){Hash.new} 创建。

    # to decide whether an object is an array:  if tmp = Array.try_convert(a) do xxx .

    

操作：

    # arra + arrb / -  可用于合并，移除array. 

    # concat 组合array. a.concat(b)  # 元素可重复

 

@ combination(k) 取k个元素进行组合，保持元素在array中的先后顺序

     permutation(k)， 不保持顺序 

    repeated_combination / repeated_permutation 

 

@ count 的用法 

1. 没有参数，返回size
2. 存在一个参数，返回元素个数 a = [1, 2, 3, 4, 3] a.count(3) = 2
3. 给定一个block，返回满足block内条件的元素个数  a.count { |x| x > 1}

 

@ dig

    从嵌套结构中挖出元素，为了统一格式的方便。比如 a = [1, [2, [3, 4]]] a.dig(1, 1, 1) = 4

    a = [42, 'a', {:foo => [10, 24]}]  / a.dig(2, :foo, 1) = 24

 

@ drop_while {|obj| block}

 

@ each & each_index 

   前者对self中的每个元素调用block，后者将block传递给每一个index。如果没有指定block，则返回一个Enumerator.  e.g., a = ['a', 'b', 'c'] / a.each_index {|x| p x, ' - '} # 1 - 2 - 3 - 

 

@ flatten (flatten!)多维展开成一维

 

@ includes? 是否包含元素

 

@ product 笛卡尔乘积 [1, 2].product([4, 5]) = [[1, 4], [1, 5], [2, 4], [2, 5]]   [1, 2].product() = [[1], [2]] 

 

@ rotate(rotate!) : rotate(2) 前两个元素甩到尾部；rotate(-2) 后两个元素调到前面 

 

@ sample 随机取样 

    a = (0 .. 10)

    a.sample : 随机取出一个元素

    a.sample(3) 随机取出一个个数为3的子array

 

@ select {|item| block} 按条件选择 a.select{|n| n.even?}

    a = ['a', 'b', 'c', 'o'] a.select{|e| e =~ /[aeiou]/} 

    select!{}  移除不满足条件的元素，同keep_if

 

@ sort 可以按Perl的方法进行排序，这里用到了飞船符号 <=> .  比如： a = [‘b’, ‘a’, ‘e’] / a.sort{|x, y| y <=> x} 则按字母从大到小排序 

 

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/not-found-404/p/8297873.html