`
小嗷喏
  • 浏览: 52522 次
  • 性别: Icon_minigender_1
  • 来自: 石家庄
社区版块
存档分类
最新评论

Ruby Array

阅读更多

   1. 数组的创建:

array = [1, 2, "3", "4"] 或者
array = Array.new
array = Array.new(6)        #创建[nil, nil, nil, nil, nil, nil]
array = Array.new(6, "a")   #创建["a", "a", "a", "a", "a", "a"]

   也可以使用"%w"方法专门用来创建字符串数组:

array = %w(a b c d) #使用空格作为元素的分隔符。返回值["a", "b", "c", "d"]

 

   2.通过索引存取数组的值, 在Ruby中,数组索引可以是正整数(从前到后,从0开始)也可以是负整数

   (从后到前,从-1开始)还可以是范围(Range):

array = [1, 2, 3, 4, 5, 6]
puts array[0]     # =>1
puts array[0, 2]  # =>1, 2
puts array[0..2]  #=>[1, 2, 3]
puts array[0...2] #=>[1, 2]
puts array[-2, 2] #=>[5, 6] 

#array[-2, 2]:前一个整数-2表示开始的索引,后面一个整数2表示数量

 

   3. +  (串联方法)简单的将两个数组连接在一起, 不删除重复元素。

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

 

   4. -  (数组差集) 从第一个数组中删除所有出现在第二个数组中的元素。

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

 

   5. & (数组交集) 取两个数组中都有的元素, 但只取一个, 不重复取。

p [1, 1, 3, 5] & [1, 2, 3]  #=>[1, 3] 

 

   6. << (追加元素) 在数组末尾添加新元素, 也不管重复不重复。

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

 

   7. | (数组并集) 取两个数组中所有元素组成的集合,删除重复元素。

p [1, 2, 3, 4] | [1, 2, 6] #=>[1, 2, 3, 4, 6]

 

   8. * (重复数组)  将数组内容重复多次后生成一个新数组并返回该数组。

     a. 如果 * 后面跟的是数字n, 将原先数组中的所有元素重复n次, 串联起来。 

p [1, 2, 3] * 3  #=> [1, 2, 3, 1, 2, 3, 1, 2, 3]

 

     b.如果 * 后面跟的是字符串,就相当于 array.join(string)

p [1, 2, 3] * ","  #=> "1,2,3"

 

   9. ==  用来比较两个数组中的各个元素

p ["a", "b"] == [”a", "b", 8]  #=> false
p [1, 2, 3] == [1, 2, "3"]  #=> false
p [1, 2, 3] == [ 1, 2, 3] #=> true

 

   10. <=> 当两个数组进行比较时,会把两个数组相同索引(从0开始)上的值拿来比较,如:

p [0,10,20]<=> [0,20,20]    #=> -1 因为当索引为1时, 10 < 20

 

   另外,比较的两个数组的元素是字符串,那么就比较它们的ASCII;如果一个数组比另一个长且其它元素都相同,那么数组长的‘大’。然而,如果一个短数组里面的一个元素比另一个长数组里面的同位置的元素大,则认为短数组‘大’。

p [1, 2, 3, 4, 5] <=> [1, 2, 3, 4, 5] #=> 0
p [1, 2, 3, 4] <=> [1, 2, 3, 4, 5] #=> -1
p [1, 2, 3, 5] <=> [1, 2, 3, 4] #=> 1
p [10,  20, 30] <=> [1, 2, 3, 5] #=> 1
p [1, 2] <=> [2, 1] #=> -1
p ["an", "b"] <=> ["An", 'B'] #=> -1
p ["an", "b"] - [1 ,2] #=> nil

 

   11. assoc(key) 对数组中的元素数组进行检索,若某元素数组的首元素与key相等时就返回该元素数组。使用==操作符进行比较。若没有符合条件的元素数组就返回nil。

array = [[1, 20], [2, 25], [3, 30]]
p array.assoc(2)           # => [2, 25]
p array.assoc(100)         # => nil
p array.assoc(15)          # => nil

 

   12. rassoc(obj)假定array是数组中的元素数组,若首次发现元素数组中索引为1的元素与obj相等时就返回该元素。使用==操作符进行比较。若没有符合条件的元素数组则返回nil

array = [[15,1], [25,2], [35,3]]
p array.rassoc(2)    # => [25, 2]

 

   13. at(pos)返回位于pos的数组元素。与self[pos]相同。

array = [ "a", "b", "c", "d", "e" ] 
p array.at(0) # => "a" 
p array.at(-1) # => "e" 
p array.at(5) # => nil 

   

   14. clear 删除数组中的所有元素。

array = [ "a", "b", "c", "d", "e" ] 
p array.clear # => [] 

   

    15. collect! {|item| ..} 对数组中的每一个元素进行遍历,block中对元素的操作将改变元素的值。

array = [ "a", "b", "c", "d" ] 
array.collect! {|x| x + "$" } # => ["a$", "b$", "c$", "d$"] 
p array # => ["a$", "b$", "c$", "d$"] 

  

   16. map! {|item| ..} 依次将数组的各个元素传给块进行计算,然后以计算结果来替换该数组元素。

array = [1, 2, 3]
array.map! {|i| i * 3 }
p array   #=> [3, 6, 9]

   

   17.compact 删除数组中所有值为nil的元素,也即压缩数组。

p [ "a", nil, "b", nil, "c", nil ].compact # => ["a", "b", "c"] 

   

   18.compact! compact从array中删除值为nil的元素后生成新数组并返回它。compact!是具有破坏性的,若对原数组进行了改动就返回array,若没有进行改动则返回nil。

array = [1, nil, 2, nil, 3, nil]
p array.compact   #=> [1, 2, 3]
p array           #=> [1, nil, 2, nil, 3, nil]
array.compact!
p array           #=> [1, 2, 3]
p array.compact!  #=> nil

 

   19. concat  将第二个数组中的元素添加在第一个数组末尾,组成新数组。

array = [1, 2]
a     = [3, 4]
array.concat(a)
p array  #=>[1, 2, 4, 5]
p a      #=>[3, 4]

 

   20. count  计算数组中等于某个值的元素有几个。

p [1, 2, 3, 4].count(3) # => 1 
p [1, 2, 3,3, 4].count(3) # => 2 
p [1, 2, 3, 4].count {|obj| obj > 2 } # => 2 

 

   21. delete(val) 和  delete(val) { . . . } 使用==来分别比较val与每个数组元素,若相等则删除该元素。若发现了与val相等的元素就返回val。若没有发现与val相等的元素则返回nil,若指定了块的话就对块进行计算并返回结果。

array = [1, 2, 3, 2, 1]
p array.delete(2)       #=> 2
p array                 #=> [1, 3, 1]

# 若向无块的参数传递了 nil 时,则无法从其返回值中判断
# 到底有没有进行删除
ary = [nil,nil,nil]
p ary.delete(nil)       #=> nil
p ary                   #=> []
p ary.delete(nil)       #=> nil

p a = [ "a", "b", "b", "b", "c" ] 
p a.delete("b")  # => "b" 
p a                   # => ["a", "c"] 
p a.delete("z")  # => nil 
p a.delete("z") { "not found" }  # => "not found" 

 

   22.  delete_at(pos) 删除pos所指位置的元素并返回它。若pos超出数组范围则返回nil。与at一样,可以使用负的索引从尾部起指定元素。

array = [0, 1, 2, 3, 4]
array.delete_at(2)
p array             #=> [0, 1, 3, 4]

 

   23. each {|item| ... } 依次使用每个元素来使用block,返回array。

[1, 2, 3].each do |i|
  puts i
end
#=> 1 2 3

a = [ "a", "b", "c" ] 
a.each {|x| print x, " -- " } 
#=> a -- b -- c --

 

   24. each_index 依次使用每个元素的索引来对块进行计算。

a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }
#=>  0 -- 1 -- 2 -- 

 

   25. empty? 判断数组是否为空。 

[].empty? #=> true
[1, 2].empty? #=>false

 

   26. join 将数组中的元素连接成字符串。如果给定参数,则在每个元素直接加入该参数。

p  [ "a", "b", "c" ].join       # => "abc"
p  [ "a", "b", "c" ].join("-")  # => "a-b-c"  

 

   27. first 返回数组的首元素。若数组为空则返回nil。

         first(n) 将以数组形式返回前n个元素,n必须大于0。

ary =  [0, 1, 2]
p ary.first       #=> 0
p ary.first(0)  #=>[]
p ary.first(1)  #=>[0]
p ary.first(2)  #=>[0, 1]
p ary.first(3)  #=>[0, 1, 2]
p ary.first(4)  #=>[0, 1, 2]

 

   28. last 返回数组的最后一个元素。若数组为空则返回nil。

         last(n) 将以数组形式返回倒数n个元素,n必须大于0。

ary =  [0, 1, 2]
p ary.last       #=> 2
p ary.last(0)  #=>[]
p ary.last(1)  #=>[2]
p ary.last(2)  #=>[1, 2]
p ary.last(3)  #=>[0, 1, 2]
p ary.last(4)  #=>[0, 1, 2]

 

   29. lenght  和 size 返回数组的长度,若数组为空则返回 0。

         nitems  返回非nil元素的个数。

p [1, nil, 3, nil, 5].length  # => 5
p [1, nil, 3, nil, 5].nitems  # => 3
 

   30. pop 删除末尾元素并返回删除元素。若数组为空则返回nil。

a = %w{ f r a b j o u s } 
p a.pop      # => "s" 
p a             # => ["f", "r", "a", "b", "j", "o", "u"] 
p a.pop(3) # => ["j", "o", "u"] 
p a            # =>  ["f", "r", "a", "b"] 
 

   31. push 在数组末尾插入元素。

a = [ "a", "b", "c" ] 
p a.push("d", "e", "f")   # => ["a", "b", "c", "d", "e", "f"] 

array = [1, 2, 3]
array.push(4)
array.push( [5, 6] )
array.push(7, 8)
p array          # => [1, 2, 3, 4, [5, 6], 7, 8]

 

   32. unshift 在数组头部加入元素,原数组元素往后移。

a = [ "b", "c", "d" ] 
p a.unshift("a")   # => ["a", "b", "c", "d"]  
p a.unshift(1, 2)  # => [1, 2, "a", "b", "c", "d"] 
p a.unshift([0])   # =>  [[0], 1, 2, "a", "b", "c", "d"]
 

   33. shift 从头部删除数组元素,并返回被删除的元素。 若数组为空则返回nil。

array = [ "a", "b", "b", "c" ] 
p array.shift      # => "a" 
p array.shift(2) # => ["b", "b"] 
p array             # => ["c"] 

 

   34. replace 用新数组替换旧数组。

a = [1, 2, 3]
a.replace [4, 5, 6, 7]
p a                 #=> [4, 5, 6, 7]

 

   35. reverse  reverse! reverse_each {|item| ... } 

        reverse 将所有元素以逆序重新排列生成新数组并返回它。reverse!的逆序排列过程具有破环性。

        reverse_each {|item| ... }  对各个元素以逆序对块进行计算。返回array。

p [1, 2, 3].reverse #=>[3, 2, 1]
p [1].reverse!   #=>[1]
p [1, 2, 3].reverese_each{|i| p i }

 #=> 3 
     2
     1

 

   36. rindex(value) 返回最后一个== val的元素的索引值。若没有符合条件的元素时返回nil。

p [1, 0, 0, 1, 0].rindex(1)   #=> 3
p [1, 0, 0, 0, 0].rindex(1)   #=> 0
p [0, 0, 0, 0, 0].rindex(1)   #=> nil

 

   37. shuffle 将原数组随机打乱。

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

 

   38. sort 对数组进行排序,返回排序好的数组。

a = [ "d", "a", "e", "c", "b" ] 
a.sort! # => ["a", "b", "c", "d", "e"] 
a # => ["a", "b", "c", "d", "e"] 
 

 

   39.values_at 一次取回多个索引位置的值。

p a = %w{ a b c d e f } #=> ["a", "b", "c", "d", "e", "f"] 
p a.values_at(1, 3, 5) # => ["b", "d", "f"] 
p a.values_at(1, 3, 5, 7) # => ["b", "d", "f", nil] 
p a.values_at(-1, -3, -5, -7) # => ["f", "d", "b", nil] 
p a.values_at(1..3, 2...5) # => ["b", "c", "d", "c", "d", "e"] 
 

 

   40. uniq 返回数组中不同的元素。原数组不变。

a = [ "a", "a", "b", "b", "c" ] 
p a.uniq # => ["a", "b", "c"] 
p a #=> [ "a", "a", "b", "b", "c" ] 
 

 

   参考:http://fujinbing.iteye.com/blog/1126232

             http://www.kuqin.com/rubycndocument/man/built-in-class/class_object_array.html

             http://www.cnblogs.com/puresoul/archive/2011/10/20/2218690.html
  

 

  

 

 
分享到:
评论

相关推荐

    Ruby的迭代之道:each与map的较量

    ### Ruby 的迭代之道:`each`与`map`的较量 #### Ruby 语言简介 Ruby 是一种高级的、面向对象的编程语言,由日本开发者松本行弘(Yukihiro "Matz" Matsumoto)于 1995 年创建。其设计目标旨在实现简单、自然且强大...

    Ruby冒泡排序的案例

    - `array[j], array[j+1] = array[j+1], array[j]`: 这是一行简洁的Ruby语法,用于交换两个变量的值。 5. **优化**: - `swapped`变量用于优化冒泡排序的过程。如果在某一轮遍历中没有发生任何交换,这意味着数组...

    Ruby语言教程和经典案例

    ### Ruby语言教程和经典案例详解 #### Ruby语言基础语法教程 **1. 变量和数据类型** 在Ruby中,变量声明相对灵活,通常无需显式地使用`var`关键字,可以直接通过赋值来声明变量。例如: ```ruby name = "Alice" ...

    Ruby程序设计(简洁清新的教程)

    Ruby提供了一系列内置的数据类型,如数组(Array)、哈希(Hash)、数字(Number)、字符串(String)等。 **4.1 Array** 数组用于存储多个有序的元素,可以通过索引来访问这些元素: ```ruby arr = [1, 2, 3] ...

    RUBY基础入门指南

    ### RUBY基础入门指南 #### 一、Ruby语言概述 **1.1 Ruby的历史** Ruby是一种面向对象的脚本语言,由日本人松本行弘(Yukihiro Matsumoto)于1995年开始开发。它结合了Perl的灵活性、Smalltalk的强大功能以及Ada...

    ruby-使用ruby实现的排序算法-sorting.zip

    Ruby实现相对复杂,一般会使用`Array#heapify`方法。 7. 归并排序 `merge_sort` 归并排序也是一种分治策略,它将数组分成两半,分别排序,然后合并。Ruby中可以使用递归实现: ```ruby def merge_sort(array) ...

    Ruby创建数组方法总结

    程序经常需要管理变量集合。例如,管理日历的程序必须有一周的天数列表。每天必须存储在一个变量中,它们的列表可以存储在一个数组变量中。通过这个数组变量,您可以访问.../usr/bin/env ruby array = Array.new 3.time

    Ruby资源ruby-v3.1.1.zip

    6. **弃用警告**:Ruby 3.1对一些即将废弃的功能发出警告,为向未来版本过渡做好准备,比如`Array#bsearch`的旧实现。 7. **兼容性增强**:Ruby 3.1对其他语言的兼容性进行了增强,比如改进了与C++的互操作性。 8....

    array-chapter

    ruby array_count.rb 要重新运行此命令,可以使用UP和DOWN箭头键查看在终端中运行的命令的历史记录。 大批 array_element_square.rb 打印用户输入的倒数第二个数字的平方。 预期的输出将类似于: "Enter at least ...

    Ruby中的block代码块学习教程

    Ruby中的代码块(block)是语言的核心特性之一,它允许开发者定义可执行的代码段,并在需要的时候通过`yield`关键字调用。代码块通常由`{}`或`do...end`包围,它们不是独立的类,但可以转换为`Proc`类的对象。对于初学...

    Ruby编程Ruby Programming

    - 数组(Array) - 哈希(Hash) - 数字(Numeric) - 布尔值(Boolean) #### 2.2 控制结构 - **条件语句**:`if`、`elsif`、`else` - **循环结构**:`for`、`while`、`until` - **流程控制**:`break`、`next...

    ruby官方chm文档

    例如,它会详细介绍如何创建和使用类、继承机制、模块混入、块和 Proc 对象,以及符号(Symbol)、字符串(String)、数组(Array)、哈希(Hash)等基本数据类型的使用。核心库的理解对于掌握Ruby语言至关重要。 ...

    ruby语法基础教程及Ruby教程中文版和安装文件

    Ruby支持多种数据类型,包括整数(Integer)、浮点数(Float)、字符串(String)、布尔值(Boolean)和数组(Array)。例如: ```ruby # 整数 num = 123 # 浮点数 decimal = 3.14 # 字符串 greeting = "你好,...

    ruby中文手册 chm

    这部分通常是对Ruby内置类库、方法、语法的详细参考,涵盖了标准库的所有模块和类,比如Array、Hash、String等。它提供了每个方法的用法、参数和返回值,是开发者在编写代码时查找特定功能或方法的重要资源。 3. *...

    绿化ruby193

    它包含了各种内置模块和类,如`Array`、`String`、`Hash`等,以及一些实用工具,如`irb`(交互式Ruby shell)和`rdoc`(用于生成API文档的工具)。 绿化Ruby193的过程通常涉及以下步骤: 1. 下载Ruby193的完整源码或预...

    ruby2.1.6安装文件

    6. **数组和哈希的改进**:这一版本中,数组和哈希的创建与操作得到了优化,如`Array#bsearch`和`Hash#slice`等方法的添加,使得数据操作更加便捷。 7. **Ruby调试器改进**:内置的调试工具如`pry`和`byebug`在Ruby...

    ruby实用函数和实例

    Ruby还包含了一些其他重要的实用函数,如Array和Hash的内置方法。Array类提供了如`map`, `each`, `select`等方法,用于迭代和操作数组元素。Hash类允许键值对存储,其方法如`fetch`, `merge`, `keys`, `values`等能...

    learning-ruby.

    此外,Ruby还有数组(Array)和哈希(Hash)等复合数据类型。 2. **控制结构**:Ruby中的控制结构包括条件语句(如if/else,case/when)、循环(如for,while,until,each)以及流程控制语句(如break, next, ...

    ruby中文文档中心资料

    Ruby的标准库非常丰富,提供了许多内置的模块和类,如File用于文件操作,Array和Hash提供数据结构支持,Net模块用于网络编程,如HTTP请求,Socket编程等。除此之外,Ruby的Gem生态系统是其强大之处,包含了数万个第...

Global site tag (gtag.js) - Google Analytics