Ruby学习笔记二——数组

 

#一、数组引用

arr=[3,4,5,6,7,8,9]

puts arr[0] #3

puts arr.first #3

puts arr[arr.length-1] #9

puts arr[arr.size-1] #9

puts arr.last #9

puts arr[-1] #9

puts arr[-2] #8

print arr[1..3] ,"/n" #456

print arr[-3,4] ,"/n" #789，从-3开始 ，打印4个元素，这里只有三个

#Ruby的数组大小是动态的，你能够随时增加、删除数组元素。

print arr.join(", "),"/n" #意思是：将数组arr转换成字符串输出，用", "隔开每个元素，并且换行。

#二、数组编辑

arr=[4,5,6]

print arr.join(", "),"/n" #4, 5, 6

arr[4] = "m" #把4号索引位置元素赋值为"m"

print arr.join(", "),"/n" #4, 5, 6, , m

print arr[3] ,"/n" #打印3号索引位置元素 #nil

arr.delete_at(3) #删除3号索引位置元素

print arr.join(", "),"/n" #4, 5, 6, m

arr[2] = ["a","b","c"] #把2号索引位置元素赋值为["a","b","c"]

print arr.join(", "),"/n" #4, 5, a, b, c, m

print arr[2] ,"/n" #打印2号索引位置元素 #abc

arr[0..1] = [7,"h","b"] #把0..1号元素替换为7,"h","b"

puts arr[0];#由输出可见，元素个数加了一个，即替换之后，成了0..2对应7,h,b

puts arr[1];

puts arr[2];

puts arr.size

print arr.join(", "),"/n" #7, h, b, a, b, c, m

arr.push("b" ) #加入元素"b"

print arr.join(", "),"/n" #7, h, b, a, b, c, m, b

arr.delete(["a","b","c"] ) #删除元素["a","b","c"]

print arr.join(", "),"/n" #7, h, b, m, b

arr.delete("b") #删除所有元素"b"

print arr.join(", "),"/n" #7, h, m

arr.insert(3,"d") #在3号索引位置插入元素"d"

print arr.join(", "),"/n" #7, h, m, d

arr<<"f"<<2 #加入元素"f"；加入元素2

print arr.join(", "),"/n" #7, h, m, d, f, 2

arr.pop #删除尾元素

print arr.join(", "),"/n" #7, h, m, d, f

arr.shift #删除首元素

print arr.join(", "),"/n" #h, m, d, f

arr.clear #清空数组arr

print arr.join(", "),"/n"

#三、数组运算

aaaa=[" aa ",4,5," bb "]

bbbb=[4,1,3,2,5]

print aaaa + bbbb ,"/n" # aa 45 bb 41325

print aaaa * 2 ,"/n" # aa 45 bb aa 45 bb

print bbbb - aaaa ,"/n" #132

#并运算；交运算

print aaaa | bbbb ,"/n" # aa 45 bb 132

print aaaa & bbbb ,"/n" #45

#排序；倒置

print bbbb.sort ,"/n" #12345

print aaaa.reverse ,"/n" # bb 54 aa

#四、字符串

str1 = 'this is str1'

str2 = "this is str2"

str3 = %q/this is str3/

str4 = %Q/this is str4/

str5 = <<OK_str

Here is string document, str5

line one;

line two;

line three.

OK

OK_str

puts str3

puts str4

puts str5

str = ' this' + " is"

str += " you"

str << " string" << " ."

puts str*2 # this is you string . this is you string .

puts str[-12,12] #you string .

#ruby E8.2-1.rb

#this is str3

#this is str4

#Here is string document, str5

#line one;

#line two;

#line three.

#OK

#>Exit code: 0

#%q 用来生成单引号字符串；%Q用来生成双引号字符串。%q或者%Q后面跟着的是分隔符，可以是配对的!和!； /和/ ； < >； ( )； [ ] ；{ }；等等。

#str5是一个字符串文档，从 <<和文档结束符的下一行开始，直到遇到一个放置在行首的文档结束符，结束整个字符串文档。

#一个数组可以用join 方法转换成字符串，join( ) 内的参数也是一个字符串，用来分隔数组的每个元素，例如：arr.join(", ")。

#在双引号扩起来的字符串中，不仅可以使用各种转义符，而且可以放置任意的Ruby表达式在 #{ } 之中，这些表达式在使用这个字符串的时候被计算出值，然后放入字符串。

def hello(name)

" Welcome, #{name} !"

end

#五、正则表达式，有所了解，与其它一样。但需要实践去多用

#六、Ruby有代码块和迭代器，迭代器其实前面已经学过，也就是for in之类的。代码块

class Array

  def one_by_one

    for i in 0...size

      yield(self[i] )

    end

    puts

  end

end

arr = [1,3,5,7,9]

arr.one_by_one {|k| print k , ", "} # 1, 3, 5, 7, 9,

arr.one_by_one {|h| print h*h, ", "} # 1, 9, 25, 49, 81,

#七、闭包

#闭包既然是一段代码，也就有自己的状态，属性，作用范围，也就是一个可以通过变量引用的对象，我们称之为过程对象。一个过程对象用proc创建，用call方法来调用。

#先看一个闭包作为参数传递给其它方法的例子；

def method(pr)

  puts pr.call(7)

end

oneProc=proc{|k| k *=3 }

method(oneProc)

#运行结果：

#>ruby E8.4-4.rb

#21

#>Exit code: 0

#八、元编程

#你编写了一个能够生成其它程序的程序，那么，你就在做元编程的工作。

#在4.3 节我们定义了一个Person 类, Person 类中有一个talk 方法，每个Person 类的实例都可以talk。可是现实生活中的人不仅能说话，还能大笑，吃饭，演讲，睡觉......

#如果在定义Person 类的时候，就把“大笑，吃饭，演讲，睡觉......”作为方法写在其中，似乎可行，但是人的行为是捉摸不定的，也是层出不穷的，某个人想“呕吐”，偏偏Person 类没有定义方法“呕吐”，看来只好憋在肚子里了！

#Ruby 语言强大的动态特征，赋予了我们灵活地进行元编程的能力。

require "E9-1"

class Person < MetaPerson

end

person1 = Person.new

person2 = Person.new

person1.sleep #sleep, sleep, sleep...

person1.running #running, running, running...

person1.modify_method("sleep", "puts 'ZZZ...'")

person1.sleep # ZZZ...

person2.sleep # ZZZ...

#在程序中，开始的时候，没有写方法sleep，也没有写方法running，就直接调用了，后来觉得方法sleep的表达不够形象，就修改了sleep的方法体。你可能会认为在程序 E9-1.rb 中写了方法sleep和方法running，是不是这样呢？

#E9-1.rb

class MetaPerson

  def MetaPerson.method_missing(methodName, *args)#凡是未定义方法都照此执行

    name = methodName.to_s

    begin

    #以下一块代码应该元编程代码，凡是未定义方法都照此执行

      class_eval(%Q[

      def #{name}

      puts '#{name}, #{name}, #{name}...'

      end

    ])

    rescue

      super(methodName, *args)

    end

  end

  def method_missing(methodName, *args)

    MetaPerson.method_missing(methodName, *args)

    send(methodName)

  end

  def MetaPerson.modify_method(methodName, methodBody)

    class_eval(%Q[

    def #{methodName}

      #{methodBody}

    end

  ])

  end

  def modify_method(methodName, methodBody)

    MetaPerson.modify_method(methodName, methodBody)

  end

end