ruby基础之数组（array）类

数组类

建立数组([]、使用Array.new、使用%w)

 e.g. num = [1, 2, 3, 4]

        strs = ["a", "b", "c", "d"]

        a = Array.new  p a  #=>[]

        a = Array.new(5)   p a #=>[nil, nil, nil, nil, nil]

        a = Array.new(5, 0)  p a #=>[0, 0, 0, 0, 0]

       lang = %w(ruby perl python scheme pike rebol)  p  lang  #=>["ruby", "perl", "python", "scheme", "pick", "rebol"]

转化成数组（使用to_a方法、使用字符串split方法）

e.g. color_table = {"black" => "#000000", "white" => "#ffffff"}   p  color_table.to_a   #=>[["black", "#000000"], ["white", "#ffffff"]]

      column = "a,b,c,d"   p column.split(/,/)   #=>["a", "b", "c", "d"]

获取元素（a[n]、 a[n..m]或a[n...m]、 a[n, len]）

a[n]  // 这个不多介绍，负值的情况要注意一下，e.g. alpha = ["a", "b", "c", "d"]  p alpha[-1]  #=> "d"

a[n..m]  // 将数组的元素“a[n]” 至“a[m]” 之间的范围建立新的数组并返回

a[n...m]  // 将数组元素“a[n]” 至 “a[m-1]” 之间的元素建立新的数组并返回

a[n, len] // 从“a[n]”处开始获取len个元素，建立新的数组并返回

除了"[]"这个方法外，还有其他的：

  a.at(n)  // 等同于a[n]

  a.slice(n)  // 等同于a[n]

  a.slice(n..m)  // 等同于a[n..m]

  a.slice(n, len)  // 等同于a[n, len] 

注意：slice 和 slice! 作用是不一样的，slice！会删除掉指定的元素，而slice是获取指定元素

改写元素（[]、 at、 slice）

这些方法，不但能读取元素，还可以用来写入数组的元素

e.g. a[n] = "item" 

其他的不多举例了，自己去看一下，这个比较简单

插入元素（a[n,0]）

a[n, 0] // 在索引n处，换掉0个元素，实际上就是在索引n处插入元素， e.g. alpha = ["a", "b", "c", "d", "e"]  alpha[2, 0] = ["X", "Y"]  p alpha  #=> ["a", "b", "X", "Y", "c", "d", "e"]

以多个索引建立新数组(values_at)

values_at // 指定多个索引，跳着取值，返回新数组。e.g. alpha = %w(a b c d e f)  p alpha.values_at(1, 3, 5)  #=>["b", "d", "f"]

作为集合的数组      

集合的运算是：交集（array = array1 & array2）、 并集（array = array1 | array2）、 补集（由于Array类没有‘全集’的概念，故，没有‘补集’，但是，将一个集合减去另一个集合，做‘差集’运算）

e.g.  ary1 = ["a", "b", "c"]  ary2 = ["b", "c", "d"]  

       p (ary1 & ary2) #=>["b", "c"]    

       p (ary1 | ary2)  #=>["a", "b", "c", "d"]

       p (ary1 - ary2)  #=>["a"]  // 数组ary2里所包含的元素“d” 因为在ary1里并没有，所以也不会留下。

注意：“|”与“+”的差异，当两个数组具有相同元素的时候，“+”返回的数组会出现相同的元素，而“|”则不会。

作为"列表"的数组

这种情况，常用到的方法有：

                  对前端操作                   对末端操作

加入元素         unshift                      push

取出元素           shift                        pop

读取元素           first                         last

以上方法中，pop和shift方法不仅会获取数组的元素，还会从数组里删除该元素。当不希望元素被删除时，我们应该使用first方法和last方法，这两个方法只是读取数据而已

e.g.  a = [1, 2, 3, 4, 5]

p a.first  #=> 1

p a.last   #=> 5

p a #=> [1, 2, 3, 4, 5]

数组的主要方法

a.unshift(item)   // 在数组a前方加入新的元素item

a << item   或者 a.push(item) // <<和push是相同的方法，可以在数组a后方加入新的元素item

a.concat(b) 或者 a + b  // 将数组a与数组b连接起来。但是concat是破坏性的方法，而“+”则会返回新的数组

 

 破坏性的方法

   e.g.   a = [1, 2, 3, 4]

           b = a

           p b.pop  #=> 4

           p b.pop  #=> 3

           p b.pop  #=> 2

           p a       #=> 1

           p b       #=>1

使用pop方法删除数据的时候，变量a所代表的数组元素被删除，由“1， 2， 3， 4”变为“1”，同时变量b所代表的数组元素也被删除。这是因为，在执行“b=a”的时候，并没有将a的内容拷贝给b，而是a和b都共同指向一个对象。

 从数组中删除数据

  a.compact  与 a.compact!  从数组a中删除nil元素。“compact” 会建立新的数组，而“compact！”会直接改写原来的数组。compact！方法在删除nil以后会返回对象a；但什么都没有删除的时候，会返回nil。

  a.delete(x) // 从数组a中删除元素x，返回的是被删除的元素。e.g. a = [1, 2, 3, 2, 1]  a.delete(2)  p a  #=> [1, 3, 1]

  a.delete_at(n) // 从数组a中删除索引n处的元素，返回的是被删除的元素。e.g. a = [1, 2, 3, 2, 1]  a.delete_at(2)  p a  #=> [1, 2, 2, 1]

由于时间的关系，还有很多方法没有介绍，大家可以去查找文档，有很多方法的，都很实用。

 

  

 

 

 

 

 

 

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/hello-ruby/archive/2013/04/24/3039654.html