Ruby边学边记

最新推荐文章于 2024-09-15 06:16:29 发布

NickZhc

最新推荐文章于 2024-09-15 06:16:29 发布

阅读量419

点赞数

分类专栏： ruby 文章标签： ruby 编程语言-编程

本文链接：https://blog.csdn.net/u010319740/article/details/50867868

版权

ruby 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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(局部变量的作用域以及栈框架)进行对象化处理之后得到的过程对象。