Ruby类
类定义
#!/usr/bin/rubyclass Sample def hello puts "Hello Ruby!" endend# 使用上面的类来创建对象object = Sample. newobject.hello注意：无参数的函数调用可以省略()
初始化方法
初始化方法有一个统一的名字叫 initialize
class Customer @@no_of_customers=0 def initialize(id, name, addr) @cust_id=id @cust_name=name @cust_addr=addr endend
Ruby变量
ruby支持5种类型
- 一般小写字母、下划线开头：变量（Variable）。
- $开头：全局变量（Global variable）。
- @开头：实例变量（Instance variable）。
- @@开头：类变量（Class variable）类变量被共享在整个继承链中
- 大写字母开头：常数（Constant）。
变量(就是 局部变量)
变量的打印
变量在打印的时候不能省略 大括号，别的类型变量都可以省略大括号，比如
你这样打印变量是打不出东西的
错误的写法
a=1b=2puts "a: #a"puts "b: #b"打印结果
a: #ab: #b正确的写法
a=1b=2puts "a: #{a}"puts "b: #{b}"打印结果a: 1b: 2
变量的生存周期
变量的生存周期只在方法中，出了方法就没了，所以也只能定义在方法里面，比如
错误的写法
class Test2 a=1 b=2 def printVar() puts "a: #{a}" puts "b: #{b}" endendhellotest = Test2.newhellotest.printVar()输出test.rb:5:in `printVar': undefined local variable or method `a' for #<Test2:0x00000002cf2248> (NameError) from test.rb:10:in `<main>'正确的写法
class Test2 def printVar(a,b) puts "a: #{a}" puts "b: #{b}" endendhellotest = Test2.newhellotest.printVar(1,2)输出a: 1b: 2
变量的传递
简单类型是值拷贝（字符串也是简单对象，这点跟java不一样）class Test2 def testPass(a,b) puts "before add : a: #{a} b: #{b}" addVar(a,b) puts "after add : a: #{a} b: #{b}" end def addVar(a,b) a += 1 b += 2 endendhellotest = Test2.newhellotest.testPass(1,2)输出before add : a: 1 b: 2after add : a: 1 b: 2复杂对象是对象引用
class Obj1 def initialize(a) @a=a end def printVal() puts "a: [email protected]" end def setA(a) @a=a end def getA() return @a endendclass Test2 def testPass() testobj = Obj1.new("hello") a = testobj.getA() puts "before add : a: #{a}" addVar(testobj) a = testobj.getA() puts "after add : a: #{a}" end def addVar(obj) obj.setA(obj.getA() + " world") endendhellotest = Test2.newhellotest.testPass()输出
before add : a: helloafter add : a: hello world
实例变量
实例变量的打印
实例变量的打印是可以省略大括号的，比如 [email protected] 跟 [email protected]} 是一回事
实例变量的生存周期
实例变量只能在 initialize 里面被定义。如果想像在java中这样定义是错误的
class LearnInstanceVar @a=1 def printVar() puts "a: [email protected]}" endendtest1 = LearnInstanceVar.newtest1.printVar输出
$ ruby test.rba:正确的定义
class LearnInstanceVar def initialize(a) @a=a end def printVar() puts "a: [email protected]}" endendtest1 = LearnInstanceVar.new("hello")test1.printVar输出
$ ruby test.rba: hello类似java中的private，但是更严格，连定义的位置都只能放在特定的方法里面
类变量
类变量的打印
类变量的打印是可以省略大括号的，比如 #@@a 跟 #{@@a} 是一回事
类变量的生存周期
- 类变量可以在多个实例之间公用，类似java的 static
- 在类的方法体以外声明
比如这样定义和使用类变量
#!/usr/bin/rubyclass Customer @@no_of_customers=0 def printCus() @@no_of_customers += 1 puts "Total number of customers : #{@@no_of_customers}" endendcust1=Customer.newcust2=Customer.newcust1.printCus()cust2.printCus()全局变量
- 全局变量以$符号打头
- 全局变量可以在类与类之间共享
Ruby 运算符
下面只说ruby比较特殊的一些运算符
比较运算符
== 和 equal？
== 和 equal 跟java中定义的正好相反：
- equal? 是比较两个对象是否是同一个对象
- == 是比较两个对象是否相等
例子
a = "Ruby" # 定义一个字符串对象b = "Ruby" # 虽然和a的内容相同，但是他们是不同的对象a.equal?(b) # false: a和b指向不同的对象a == b # true: 他们的内容是相同的
eq? 是 equal? 的缩写
<=> 联合比较运算符
这是一个神奇的运算符：联合比较运算符。如果第一个操作数等于第二个操作数则返回 0，如果第一个操作数大于第二个操作数则返回 1，如果第一个操作数小于第二个操作数则返回 -1。
=== 三等号
这个运算符更神奇：
通常情况下这中方式与==是一样的，但是在某些特定情况下，===有特殊的含义：
- 在Range中===用于判断等号右边的对象是否包含于等号左边的Range；
- 正则表达式中用于判断一个字符串是否匹配模式，
- Class定义===来判断一个对象是否为类的实例，
- Symbol定义===来判断等号两边的符号对象是否相同。
例子：
(1..10) === 5 # true: 5属于range 1..10/\d+/ === "123" # true: 字符串匹配这个模式String === "s" # true: "s" 是一个字符串类的实例:s === "s" # true
.eql?
如果接收器和参数具有相同的类型和相等的值，则返回 true。比如 1 == 1.0 返回 true，但是 1.eql?(1.0) 返回 false。
并行赋值
a = 10b = 20c = 30可以写成这样
a, b, c = 10, 20, 30于是在java和c中很麻烦的变量交换，在ruby中可以很简单的写成
a, b = b, c这样的代码
a=1b=2c=3a,b=b,cputs "a: #{a}"puts "b: #{b}"puts "c: #{c}"执行结果为$ ruby test.rba: 2b: 3c: 3
范围运算符
- 1..10 创建了一个从1 到10的范围，并且包含10
- 1...10 跟上面那个唯一的不同是不包含10
define? 运算符
我们在别的语言中都见到过如何判断变量是否被定义的方法，比如js的是否等于undefined，和php的isset，ruby专门为这种操作设计了一个运算符叫 define? 这个运算符不仅可以告诉你该变量是否定义还可以告诉你变量的范围
defined? variable # 如果 variable 已经初始化，则为 True
比如
foo = 42defined? foo # => "local-variable"defined? $_ # => "global-variable"defined? bar # => nil（未定义）还可以检测方法是否定义了
defined? method_call # 如果方法已经定义，则为 True
defined? puts # => "method"defined? puts(bar) # => nil（在这里 bar 未定义）defined? unpack # => nil（在这里未定义）
Ruby 点运算符 "." 和双冒号运算符 "::"
请记住：在 Ruby 中，类和方法也可以被当作常量。
您只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。
如果未使用前缀表达式，则默认使用主 Object 类。
您只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。
如果未使用前缀表达式，则默认使用主 Object 类。
例子
MR_COUNT = 0 # 定义在主 Object 类上的常量module Foo MR_COUNT = 0 ::MR_COUNT = 1 # 设置全局计数为 1 MR_COUNT = 2 # 设置局部计数为 2endputs MR_COUNT # 这是全局常量puts Foo::MR_COUNT # 这是 "Foo" 的局部常量