#一、数组引用
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