Ruby边学边记
该篇主要描述类
Ruby定义一个类
#!/usr/bin/ruby -w
class Customer
@@no_of_customer = 0
def hello(id ,name ,addr)
@cust_id = id
@cust_name = name
@cust_addr = addr
end
end
- 以@@开始的是类变量
- 以@开始的是实例变量
- 以$开始的是全局变量
- 以小写或者是_开头的是局部变量
创建类的对象
1.对象
类中定义的方法称为类的成员函数。使用new关键字穿件类的对象
如下：
#!/usr/bin/ruby -w
class Customer
def hello
puts "Hello World"
end
end
cust1 = Customer.new
#new 前面也可以有一个空格
cust2 = Customer. new
cust1.hello
cust2.hello
2.initialize方法
initialize函数是类初始化函数，创建对象时会自动调用，并可以通过new 传递参数给initialize方法
#!/usr/bin/ruby -w
class Customer
@@no_of_customer = 0
def initialize(name)
@cust_name = name
end
def hello
puts "Hello #{cust_name}"
end
end
cust = Customer.new("Nick")
cust.hello
全局变量
1.刚刚已经说过，以$开头的是全局变量，能够跨类使用
#!/usr/bin/ruby
$global_var = 10 #定义全局变量
class Class1
def print_global
puts "Global variable in Class1 is #$global_var."
#通过在变量或常量的前面放置"#"，可以实现对任何变量或常量的访问
end
end
class Class2
def print_global
puts "Global variable in Class2 is #$global_var."
end
end
class1obj = Class1.new #创建一个对象
class1obj.print_global #对象调用成员函数，成员函数调用全局变量
class2obj = Class2.new
class2obj.print_global
实例变量
以@开头；实例变量可以跨任何特定的实例或对象中的方法
例如：
#!/usr/bin/ruby #文件名为cust.rb
class Customer
def initialize(id, name, addr)
@cust_id=id #定义一个cust_id实例变量
@cust_name=name
@cust_addr=addr
end
def display_details()
puts "Customer id #@cust_id"
puts "Customer name #@cust_name"
puts "Customer address #@cust_addr"
#访问实例变量
end
end
类变量
以@@开头，而且需要初始化之后才能在方法定义中使用；类变量属于类，是类的一个属性，同时类变量可以跨不同的对象使用
#!/usr/bin/ruby #文件名为class_var.rb
class Customer
@@no_of_customers=0
def initialize(id, name, addr)
@cust_id=id
@cust_name=name
@cust_addr=addr
end
def display_details()
puts "Customer id #@cust_id"
puts "Customer name #@cust_name"
puts "Customer address #@cust_addr"
end
def total_no_of_customers()
@@no_of_customers += 1
puts "Total number of customers: #@@no_of_customers"
end
end
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")
cust1.total_no_of_customers()
cust2.total_no_of_customers()
局部变量
局部变量是在方法中定义的变量，在方法外不可定义； 局部变量是以小写字母或者下划线 _ 开头的。
就如同上面方法中的id, name, addr
类中的方法
如果你学习过 Java，那么你肯定对私有 (private) 和公有 (public) 不会陌生。
同样 Ruby 也是有 private 和 public 的，而且当方法定义在类定义外时则该方法默认被标记为 private，若在类定义中那么默认标记为 public。
#!/usr/bin/ruby #文件名为class_fun.rb
class Class_fun #创建一个Class_fun类
def fun1
puts "This is the first test for class."
end
def fun2
puts "This is the second test for class."
end #类中包括两个成员函数
end
test1 = Class_fun.new
test2 = Class_fun.new #创建类Class_fun的两个对象
test1.fun1 #对象调用类的成员函数
test2.fun2
代码块
- 什么是代码块？
块就是由大量代码组成；
代码包含在大括号do...end 内；块只能跟在方法调用之后，例如你的代码块称为block_test，那就必须定义一个block_test相同名字的方法来调用代码块
- yield语句
在方法内部，yield的作用是占位，当执行到yield时就是执行代码块中的内容；|x|是在代码块中使用的，用于接受
例如：
#!/usr/bin/ruby
def block_test
puts "You are in the method"
yield #执行代码块
puts "You are again back to the method"
yield #执行代码块
end
block_test {puts "You are in the block"}
结果：
- BEGIN和end 块
BEGIN 和 END 块分别定义程序被加载就执行和程序结束时执行的代码块；个人理解可以把这个看成生命周期
#!/usr/bin/ruby #文件名为be_and_in.rb
BEGIN {
#BEGIN 代码块
puts "BEGIN code block."
}
END {
#END 代码块
puts "END code block."
}
puts "MAIN code."
结果：
运算符
1.在 Ruby 中很多的运算符跟其他语言都是相同的，（比如基本的 +、-、*、/ 算术运算 ，以及 位运算 和 逻辑运算 等）但是还是有一部分是不一样的，下面将对 Ruby 的部分运算符进行操作实验。
2.比较运算符
.eql?：如果原参数与接收到的参数具有相同的类型和值，则返回 true。
范例：
5.eql?(5.0) 返回 false
#equal?：如果原参数与接收到的参数具有相同的对象 id，则返回 true。
3.并行赋值
范例：
a,b,c = 10,20,30
等价于:
a = 10, b = 20, c = 30
4.变量交换
a,b = b,a
#交换了a和b的值，也可以多个变量同时交换
5.三元运算符
a>b ? c=b : c=a
#如果a大于b则将b的值赋给c，否则将a的值赋给c
6.范围运算符
在 Ruby 中有两个范围运算符，分别是 ..和 …
..：表示创建一个从开始点到结束点的范围（包含起始点和结束点）
...：表示创建一个从开始点到结束点的范围（包含起始点但不包含结束点）
范例：
1..10
#创建从1到10的范围
1…10
#创建从1到9的范围
7.defined?运算符
defined? 运算符是以调用相关方法的形式来判断传递的参数是否已经定义，如果表达式未定义则返回 nil，如果已定义则会返回参数描述。
范例：
#!/usr/bin/ruby #文件名为defined.rb
a=100
puts “a is defined?”,defined? a
puts “test is defined?”,defined? test
运行：
$ ruby defined.rb
a is defined?
local-variable
test is defined?
8.点运算符和双冒号运算符
在 Ruby 中类和方法都可以被当做常量来使用 :: 运算符： 可以使用一个模块名称和双冒号来引用一个常量； 双冒号运算符允许在类或模块内定义常量、实例方法和类方法，可以从类或模块外的任何地方进行访问。
范例：
#!/usr/bin/ruby
CONST = ' out there' #定义常量
class Inside_one
CONST = proc {' in there'}
def where_is_my_CONST
::CONST + ' inside one' #引用常量
end
end
class Inside_two
CONST = ' inside two'
def where_is_my_CONST
CONST
end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST
若未使用前缀表达式，则默认使用主 Object 类。 Proc 是对块及其 context(局部变量的作用域以及栈框架)进行对象化处理之后得到的过程对象。
