Ruby语法简要

这两天有空学习下Ruby，如下简单记录Ruby的一些关键信息。

基本语法

==、equal?

== 比较两个变量的值是否相等；equal?比较的是内存地址。和Java恰好相反。

if

if...end
if...elsif...end
if...else...end

条件判断if能够有两种写法，多条语句时：

if condition
	#do something
end

单条语句时：

#do something if condition

case

case when condition1 ... when ...end

case功能相似于c或者java中的switch，可是更强大

i=5
case i
when 1
	puts "1"
when 2...6
	puts "2~5"
end

以上代码会输出2~5。在case中使用操做符“===”比较分支，因为Ruby是彻底面向对象的程序语言，因此根据分支数据的不一样类型===表现出不一样的行为。

while

while...redo...next...break...end

while支持四种打破循环的方法：

• condition 当条件不知足时退出。
• next 等于Java中的continue，结束如下语句直接执行下一次迭代。
• redo 忽略如下语句，可是不进行条件判断再次从头执行本次迭代。
• break 跳出循环

C语言描述：

while (condition) {
label_redo:
   goto label_next;        /* ruby's "next" */
   goto label_break;       /* ruby's "break" */
   goto label_redo;        /* ruby's "redo" */
   ...
   ...
label_next:
}
label_break:
...

for

for...in...

for num in collection
	puts num
end

each

除了使用循环，还能够直接用each对colleciton、array进行迭代

arr=[1,2,3]
arr.each{|num| puts num}

或者是：

arr=[1,2,3]
arr.each do |num|
  num*=2
  puts num
end

做用域级别

说法可能不妥，只是我的理解。从大到小Ruby可分为Module、Class、method、procedure（block）。

Module

• Module不能被继承。
• Module不能实例化。

Ruby官方指明Module有两个用处：一个Module能够用于封装一系列功能相关的函数，好比Math；另外一个则是经过mixin技术实现Ruby class行为的多重继承：

module TALK
  def talk
    puts "talk ... talk .."
  end
end

class Person
  include TALK
end

person=Person.new
person.talk

除此之外，我的以为Module 相似于Java中的Package，实现了Class命名空间的隔离。

Class

和其余面向对象语言中Class的含义同样，是一类对象共同特征的抽象。Class只能单一继承。

在Ruby中class也是一个对象，其父类是Module，全部对象的根父类都是Object。

super关键字可用于继承关系中调用父方法：

Class Person
	def talk
		#...
	end
end

Class SubPerson < Person
	def talk
		super
		#...
	end
end

class_eval关键字能够实现动态的修改、增长class的行为，代码忽略。

Method

method能够在class内外声明，在class外直接声明的method更像脚本语言中的function，而在class中声明的方法则等同于Java语言中的method，能够被class的实例使用。

在method中经过关键字self能够得到方法接受者（receiver）。

除此之外，还有一类特殊的单例方法singleton_method，这里并不是设计模式的单例方法。而是指分配给某个可是实例的方法，如下代码中talk_loudly是personA的singleton_method，由于它只属于personA，其余Person实例是没法得到此特性的。

class Person
	def talk
		#...
	end
end

personA=Person.new
def personA.talk_loudly
	#...
end

Procedure

Ruby中强大的地方还在于能够直接传递代码块（block），在本质上procedure等于block，只是block是匿名的只能被传递一次，重复使用须要屡次书写相同代码；因为Ruby面向对象的特征block也是一个对象，将其赋值给一个变量就成为了procedure能够被重复使用。

block的声明方式能够用do...end(多行)和{}(单行)两种。

yield关键字，要实现each方法的功能，ruby实际上使用了yield关键字，若是一个方法在调用时被隐含传递了block（method(arg) {}），则在方法内调用yield会执行其内容：

def method(name)
	if block_given?
		puts yield name
	else
		puts "Hello, #{name}"
	end
end

#output Hello, gangzz
method("gangzz") 
#output Hey, gangzz
method("gangzz") {|n| puts "Hey, #{n}"}

Singleton_method的几种实现方式

• def关键字

  class Person
    	def talk
    		#...
    	end
    end
  
    personA=Person.new
    def personA.talk_loudly
    	#...
    end

• class<<Instance的方式

  class Person
    	def talk
    		#...
    	end
    end
  
    personA=Person.new
  
    class<< personA
    	def talk_loudly
    	#...
    	end
    end

• instance_eval

  class Person
    	def talk
    		#...
    	end
    end
  
    personA=Person.new
  
    personA.instance_eval "def talk_loudly;#...;end"

Varialbe

Ruby支持四种不一样表示方式的变量：

• $ 全局变量，慎用
• @ 实例变量，做用域为当前实例。
• [a-z] or _ 本地变量，做用域限于方法或者procedure。
• [A-Z] 常量

accessor

读取和修改Class属性的语法糖？

<table border="1"> <tbody> <tr><td><em> Shortcut </em> </td><td> <em> Effect </em> </td></tr> <tr><td> <code> attr_reader :v </code> </td><td> <code> def v; @v; end </code> </td></tr> <tr><td> <code> attr_writer :v </code> </td><td> <code> def v=(value); @v=value; end </code> </td></tr> <tr><td> <code> attr_accessor :v </code> </td><td> <code> attr_reader :v; attr_writer :v </code> </td></tr> <tr><td> <code> attr_accessor :v, :w </code> </td><td> <code> attr_accessor :v; attr_accessor :w </code></td></tr></tbody></table>

Exception

异常的处理，若是运行时参数或状态不正确能够经过raise XXX.new抛出异常，经过如下机制捕获和处理异常。

begin
	#...
rescue
	#...
ensure
	#...

Symbol

经过:name的方式就能够声明一个symbol，和String彻底不一样在一个Ruby程序的执行过程当中相同名字的symbol必然是同一个对象，不管上下文如何变化。Symbol的一个做用是提升效率，由于相比于字符串Symbol仅仅会被建立一次。

http://www.ibm.com/developerworks/cn/opensource/os-cn-rubysbl/index.html