Ruby入门介绍
人气:0想了解Ruby入门介绍的相关内容吗,在本文为您仔细讲解的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Ruby入门介绍,下面大家一起来学习吧。
一、方法Ruby 的方法定义允许为参数设置默认值,不过在带有默认值的参数后面不能出现不带有默认值的参数(允许 * 和 &),也就是说下面的方法定义是不被允许的,解释时会出现 parse error。 还有一点与 C# 不同的是,方法定义不能出现在方法调用的后面。
# parse error def Display(args1="proshea", args2) end # 允许 def Display(args1="proshea", *args2) end # 允许 def Display(args1="proshea", &args) end Show() # 出现在 Show 调用之后是错误的 def Show end
Ruby 也支持 C# params 这样的参数功能, 只是 Ruby 用 * 标识罢了。
def Display(*args) print %Q~#{args.join("-")}~ end # proshea-32-WinForm Display("proshea", 32, "WinForm")
同样的, Ruby 也有类似于 C# delegate 的应用,只是更简单,直接用 & 来表示,并且 Ruby 用一个称为 yield 的关键字来知会解释器执行传入的代码块或者说 Proc object(过程对象?)。
1def Display(&block) 2 if block_given? 3 yield(block) 4 else 5 print %Q~没有传入过程对象~ 6 end 7end 8 9def Show() 10 print %Q~Show 方法调用~ 11end 12 13# 没有传入过程对象 14Display() 15# 在 Display 内部调用 Show 方法 16# 注意起始大括号仍然只能和方法名在同一行 17Display(){ 18 Show() 19}
block_given? 是被定义在内部模块 Kernel 当中的方法,用以表明是否传入了 Proc object。之后,Ruby 用 yield 通知解释器执行传入的 Proc。过程对象也可以带有参数,不同于普通方法的是过程对象的参数是位于一组 | | 之中。可以使用 Proc object 的 call 方法来调用带参数的过程对象。
1class Employee 2 def initialize(username, age, &block) 3 @username, @age, @block = username, age, block 4 end 5 6 def Display(txt) 7 # 虽然 @block 是个实例变量,但在此处一定要加上大括号 8 print "#{@block.call(txt)}: #@username-#@age" 9 end 10end 11 12emp = Employee.new("proshea", 32){ 13 |txt| 14 txt 15} 16emp.Display("context")
1
二、BEGIN & END
BEGIN 块
BEGIN 块中的代码在所有代码执行之前执行,Ruby 允许设置多个 BEGIN 块并按出现的顺序执行块中的代码。C# 程序员注意下面的代码
上面的代码看上去很美吧,可惜的是上面的代码段会出现 parse error,正确的代码应该是
正如上面的代码段所呈现的,只有当起始大括号和 BEGIN 标识符位于同一行时块内的代码才能得到正确的执行。同时 BEGIN 块也不受任何控制结构的影响,因为只要出现 BEGIN 块就会得到执行并且只执行一次。
基于只要现出 BEGIN 就会得到执行和 BEGIN 在所有代码执行之前执行的原则,即使 BEGIN 块前出现了代码,该代码仍然会等待 BEGIN 块执行之后再执行。比如下面的代码段输出结果仍然是 OnInit - OnLoad - Running。
END 块
END 块与 BEGIN 块相反,在所有代码执行之后执行,多个 END 块时最先出现的 END 块最后执行。除此之外,END 块虽然不受 while 的影响,但是可能通过 if 来控制 END 块的执行与否。比如下面代码的输出结果就是 Start - Load - Unload。
三、变量和常量
局部变量
以小写字母或下划线开头的标识符在 Ruby 中即为局部变量(如果引用未被声明的标识符则会被解释成无参数的方法调用)。
虽然 val 未被赋值,但声明还是有效的,此时 val 的值是 nil(相当于 C# 中的 null)。
实例变量
所有实例变量都是 @ 字符打头的标识符,未被初始化的实例变量值为 nil。
类变量
以 @@ 开头的标识符是类变量。在 module 中定义的模块变量能够被所有包含该 module 的类访问。
全局变量
全局变量无需声明,所有以 $ 开始的标识符都是全局变量,能够在程序的任何地方引用它,未赋值的全局变量值为 nil。
伪变量
在 Ruby 中有一种被称为伪变量的标识符,伪变量有一点像环境变量,同时它也是只读的。
常量
以大写字母打头的标识符是常量,对常量进行二次赋值解释器会提示警告,而引用未被赋值的常量实抛出 NameError 异常。在类、模块外部定义的常量属于 Object,可以使用“::常量名”引用属于 Object 的常量,以“模块名/类名::常量名”的形式引用外部的常量。
当引用模块和类中同名的常量时,优先引用嵌套树外侧的常量, Object 的优先度最低,不过我建议大家尽量不使用同名常量。
四、嵌入字符串
在 Ruby 中我非常喜欢的一个功能就是嵌入字符串,所谓嵌入就是指直接将变量写入引号的形式,这样做的好处是直观和节约了连字符出现的频率。比如在 C# 中我们可以编写下面的代码。
但在 Ruby 中可以采用嵌入字符串的形式来节约一些代码(我想这里正体现了 Ruby 的优雅)。
嵌入字符串的形式是非常简单的,只需将变量名放到 # 字符后面的大括号中就可以了。而对于类变量、成员变量和全局变量来说,甚至可以连大括号也可以省略掉(伪变量则不能省略大括号)。
Ruby 的嵌入字符串只能在双引号中使用,因为解释器会原样输出单引号中的内容。Ruby 的单引号就有点 C# 中的 @"" 的感觉。
% 呈现
Ruby 的另一个酷酷的功能就是 % 呈现方法,这是一种替代引号或其它分隔字符的表示方法。下面第一句直接在双引号内插入双引号是错误的,但使用 % 呈现后就可以直接在字符串内插入双引号了。
在 % 呈现中,Q 是呈现标识、! 是呈现分隔符。呈现标识声明替代哪种分隔字符,! 则是一个自定义的分隔符。呈现分隔符只要前后一致就可以了,但不能选择字母和 < 字符做为呈现分隔符。如果要在呈现方法中插入呈现字符就必须使用 \ 字符。
% 呈现列表
%Q 替代双引号 => %Q#Ruby "% 呈现"# 等同于 "Ruby \"% 呈现\""
%q 替代单引号
%r 替代正则表达式 => %r#([\d\w/])*# 等同于 /([\d\w\/)*/
%s 使嵌入字符串、符号失效 => print %s@#{__LINE__}@ 原样输出
%w 替代字符串数组
五、正则表达式之反向引用
Ruby 和 Perl 一样,对正则表达式的天然支持都是它们的优势所在,懂得 Perl 的朋友可以看出,Ruby 的正则表达式很多地方和 Perl 都是如出一辙的。
反向引用就是引用正则表达式中被括号括起来的模式,下面两行的模式就是相同的,只是第二句采用了反向引用的形式。
需要注意的是反向引用的括号必须位于引用位置的左边。另外,如果在反向引用之后想要紧接着匹配一个数字,那么必须把反向引用表达式括起来。
二、BEGIN & END
BEGIN 块
BEGIN 块中的代码在所有代码执行之前执行,Ruby 允许设置多个 BEGIN 块并按出现的顺序执行块中的代码。C# 程序员注意下面的代码
BEGIN { print "OnInit(object sender, EventArgs args)\n" } BEGIN { print "OnLoad(object sender, EventArgs args)\n" } print "Running"
BEGIN{ print "OnInit(object sender, EventArgs args)\n" } BEGIN{ print "OnLoad(object sender, EventArgs args)\n" } print "Running"
1i = 0 2while i < 10 3 # 虽然处理循环结构中,但 BEGIN 块内的代码仍然只执行一次 4 BEGIN{ 5 print "OnInit(object sender, EventArgs args)\n" 6 } 7 i += 1 8end 9 10if false 11 # BEGIN 完全不受 if 的影响,只要出现 BEGIN 块就会得到执行 12 BEGIN{ 13 print "OnLoad(object sender, EventArgs args)\n" 14 } 15end 16 17print "Running"
print "OnLoad(object sender, EventArgs args)\n" BEGIN{ print "OnInit(object sender, EventArgs args)\n" } print "Running"
END 块与 BEGIN 块相反,在所有代码执行之后执行,多个 END 块时最先出现的 END 块最后执行。除此之外,END 块虽然不受 while 的影响,但是可能通过 if 来控制 END 块的执行与否。比如下面代码的输出结果就是 Start - Load - Unload。
if false END{ # 永远不输出 print "Init" } end END{ # 最后输出 print "Unload\n" } END{ # 先于 Unload 输出 print "Load\n" } # 最先输出 print "Start\n"
三、变量和常量
局部变量
以小写字母或下划线开头的标识符在 Ruby 中即为局部变量(如果引用未被声明的标识符则会被解释成无参数的方法调用)。
val = 5 if false
实例变量
所有实例变量都是 @ 字符打头的标识符,未被初始化的实例变量值为 nil。
class Employee @empId end
以 @@ 开头的标识符是类变量。在 module 中定义的模块变量能够被所有包含该 module 的类访问。
1module Company 2 @@companyName = "Hello Ruby." 3 4 class Employee 5 def display 6 print "#@companyName" 7 end 8 end 9 10 class Department 11 def display 12 print "#@companyName" 13 end 14 end 15end
全局变量无需声明,所有以 $ 开始的标识符都是全局变量,能够在程序的任何地方引用它,未赋值的全局变量值为 nil。
1module Company 2 class Employee 3 def display 4 # nil 5 print "#$companyName" 6 $companyName = "Hello Ruby." 7 end 8 end 9 10 class Department 11 def display 12 # Hello Ruby. 13 print "#$companyName" 14 end 15 end 16end
在 Ruby 中有一种被称为伪变量的标识符,伪变量有一点像环境变量,同时它也是只读的。
# 当前方法的执行主体 print "#{self}" # NilClass类的唯一实例 print "#{nil}" # TrueClass 类的唯一实例 print "#{true}" # FalseClass 类的唯一实例 print "#{false}" # 当前源文件名 print "#{__FILE__}" # 当前源文件中的行号 print "#{__LINE__}"
以大写字母打头的标识符是常量,对常量进行二次赋值解释器会提示警告,而引用未被赋值的常量实抛出 NameError 异常。在类、模块外部定义的常量属于 Object,可以使用“::常量名”引用属于 Object 的常量,以“模块名/类名::常量名”的形式引用外部的常量。
1# 属于 Object 的常量 2GroupName = "心守家园" 3 4module Site 5 SiteUrl = "http://www.you2v.com" 6 7 class Sichuan 8 Add = "凉山" 9 # 引用属于 Object 的常量 10 print "#{::GroupName}" 11 end 12end 13 14# 直接引用类名、模块名 15# 引用属于 Object 的模块时可以省略“::” 16print "#{::Site}\n#{Site::Sichuan}" 17# 属于模块的常量 18print "#{Site::SiteUrl}" 19# 属于类的常量 20print "#{Site::Sichuan::Add}"
四、嵌入字符串
在 Ruby 中我非常喜欢的一个功能就是嵌入字符串,所谓嵌入就是指直接将变量写入引号的形式,这样做的好处是直观和节约了连字符出现的频率。比如在 C# 中我们可以编写下面的代码。
string val = "value"; string printVal = "value: " + val; // 或者 string printVal = String.Format("value: {0}", val);
val = "Value" printVal = "value: #{val}"
1module Company 2 class Employee 3 # 类变量 4 @@companyName = ".org" 5 # 成员变量 6 @empId 7 8 def setEmpId(val) 9 @empId = val 10 end 11 12 def display() 13 # 省略了大括号 14 print "Company: #@@companyName\n" 15 print "Employee ID: #@empId\n" 16 # 伪变量不能省略大括号 17 print "lines: #{__LINE__}\n" 18 end 19 end 20end 21 22emp = Company::Employee.new 23emp.setEmpId("001") 24emp.display
# 原样输出 # Company: #@@companyName print 'Company: #@@companyName' # 原样输出(包括空格和换行) print ' Company: .org Employee Id: unknow
Ruby 的另一个酷酷的功能就是 % 呈现方法,这是一种替代引号或其它分隔字符的表示方法。下面第一句直接在双引号内插入双引号是错误的,但使用 % 呈现后就可以直接在字符串内插入双引号了。
# 错误 print "Ruby "% 呈现法"" # 应用 % 呈现方法 print %Q#Ruby "% 呈现"#
# 正确 print %Q~Ruby "% 呈现"~ print %Q.Ruby "% 呈现". print %Q*Ruby "% 呈现"* # 在 % 呈现中插入呈现分隔符 print %Q*\* Ruby "% 呈现"* # 错误 print %Q** Ruby "% 呈现"* print %QbRuby "% 呈现"b print %Q<Ruby "% 呈现"<
%Q 替代双引号 => %Q#Ruby "% 呈现"# 等同于 "Ruby \"% 呈现\""
%q 替代单引号
%r 替代正则表达式 => %r#([\d\w/])*# 等同于 /([\d\w\/)*/
%s 使嵌入字符串、符号失效 => print %s@#{__LINE__}@ 原样输出
%w 替代字符串数组
五、正则表达式之反向引用
Ruby 和 Perl 一样,对正则表达式的天然支持都是它们的优势所在,懂得 Perl 的朋友可以看出,Ruby 的正则表达式很多地方和 Perl 都是如出一辙的。
反向引用就是引用正则表达式中被括号括起来的模式,下面两行的模式就是相同的,只是第二句采用了反向引用的形式。
pat1 = /([\d\w])-([\d\w])/ pat2 = /([\d\w])-\1/
pat1 = /([\d\w])-(\1)0/ pat2 = /([\d\w])-\10/ # 0 print pat1 =~ "1-10" # nil print pat2 =~ "1-10"
加载全部内容