宽容他人，放过自己。

ruby的学习（2）

Posted on Apr 24, 2018 By anchoriteFili

Ruby 类和对象

class Vehicle

    Number no_of_wheels
    Number horsepower
    Characters type_of_tank
    Number Capacity

    Function speeding {
        
    }

    Function driving {

    }

    Function halting {

    }
end

Ruby 类中的变量

局部变量：局部变量是在方法中定义的变量。局部变量以小写字母或_开始。 实例变量：实例变量可以跨任何特定的实例或对象中的方法使用，实例变量在变量名之前放置符号(@) 类变量：类变量可以跨不同的对象使用。类变量在变量名之前放置符号(@@) 全局变量：类变量不能跨类使用。如果您想要有一个可以跨类使用的变量，您需要定义全局变量。全局变量总是以美元符号($)开始。

在 Ruby 中创建对象

class Vehicle
    Number no_of_wheels
    Function speeding {
    }
end

class Customer
    @@no_of_customers=0
    # 自定义方法创建对象。
    def initialize(id, name, addr)
        @cust_id=id
        @cust_name=name
        @cust_addr=addr
    end
    
end

=begin
在 Ruby 中，函数被称为方法。类中的每个方法是以关键字 def 开始，后跟方法名。
方法名总是以小写字母开头。在 Ruby 中，您可以使用关键字 end 来结束一个方法。  
=end

class Sample
    def hello
        puts "Hello Ruby!"
    end
end

# 使用自定义方法创建对象
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# 使用new方法来创建对象
vehi1 = Vehicle. new
vehi2 = Vehicle. new

Ruby 类案例

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.display_details()
cust2.total_no_of_customers()

Ruby 全局变量

在 Ruby 中，您可以通过在变量或常量钱放置 # 字符，来访问任何变量或常量的值。

$gloabal_variable = 10

class Class1
    def print_global
        puts "全局变量在 Class1 中输出为 #$gloabal_variable"
        
    end
end

class Class2
    def print_global
        puts "全局变量在 Class2 中输出为 #$gloabal_variable"
    end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

=begin
全局变量在 Class1 中输出为 10
全局变量在 Class2 中输出为 10
=end

Ruby 实例变量

实例变量以 @ 开头。未初始化的实例变量的值为nil，在使用 -w 选项后，会产生警告。

=begin
实例变量以 @ 开头。未初始化的实例变量的值为nil，在使用-w选项后，会产生警告。
=end

class Customer
    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
end

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.display_details()
cust2.display_details()

Ruby 比较运算符

a = 10 b = 20

运算符 描述 实例
<=> 联合比较运算符，如果第一个操作数等于第二个操作数则返回0，如果第一个操作数大于第二个操作数则返回1，如果第一个操作数小于第二个操作数则返回-1. (a <=> b)返回-1
=== 用于测试 case 语句的 when 子句内的相等。 (1…10) === 5 返回 true
.eql? 如果接收器和参数具有相同的类型和相同的值，则返回true 1 .eql? (1.0) 返回false
equal? 如果接收器和参数具有相同的对象id，则返回 true。 如果 aObj 是 bObj 的副本，那么 aObj == bObj 返回true。a.equal?bObj 返回 false，但是 a.equal?aObj 返回 true。

Ruby 赋值运算符

运算符 描述 实例
**= 指数且赋值运算符，执行指数运算，并赋值给左操作数 c**=a

Ruby 并行赋值

a, b, c = 10, 20, 30 # 使用并行赋值可以更快地声明
a, b = b, c # 并行赋值在交换两个变量的值时也很有用

Ruby 位运算符

运算符 描述 实例  
& 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 (a & b) 将得到12，即为 0000 1100  
| 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 (a b)将得到61 即为0011 1101
^ 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 (a^b)将得到49，即为 0011 0001  
~ 二级制补码运算符是一元运算符，具有“翻转”位效果，即0变1，1变0. (~a)将得到 -61，即为 1100 0011, 一个有符号二进制数的补码形式。  
« 二进制左移运算符。左操作数的值向左移动有操作数指定的位数。 a « 2 将得到 240,即为 1111 0000  
» 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 a » 2 将得到 15，即为 0000 1111  

Ruby 逻辑运算符

运算符 描述 实例
and 称为逻辑与运算符。如果两个操作数都为真，则条件为真。 (a and b)为真
or 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (a or b)为真
not 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 not(a && b)为假。

Ruby defined?运算符

defind? 是一个特殊的运算符，以方法调用的形式来判断传递的表达式是否已定义。它返回表达式的描述字符串，如果表达式未定义则返回 nil.

Ruby 点运算符 “.” 和双冒号运算符 “::”

可以使用类或模块名称和两个冒号 :: 来引用类或模块中的常量。:: 是一元运算符，允许在类或模块内定义常量、实例方法和类方法，可以从类或模块外的任何地方进行访问。

=begin
:: 是一元运算符，允许在类或模块内定义常量、实例方法和类方法，可以从类或模块外的任何地方进行访问。
请记住：在 Ruby 中，类和方法也可以被当做常量。
你只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。
如果 :: 前的表达式为类或模块名称，则返回该类或模块快内对应的常量值；如果 :: 前末没有前缀表达式，
则返回主Object类中对应的常量值。
=end


MR_COUNT = 0    # 定义在主 Object 类上的常量
module Foo
    MR_COUNT = 0
    ::MR_COUNT = 1  # 设置全部计数为1
    MR_COUNT = 2    # 设置局部计数为2
end

puts MR_COUNT   # 这是全局常量
puts Foo::MR_COUNT  # 这是 "Foo" 的局部常量

=begin
/Users/zetafin/ruby/test.rb:16: warning: already initialized constant MR_COUNT
/Users/zetafin/ruby/test.rb:13: warning: previous definition of MR_COUNT was here
/Users/zetafin/ruby/test.rb:17: warning: already initialized constant Foo::MR_COUNT
/Users/zetafin/ruby/test.rb:15: warning: previous definition of MR_COUNT was here
1
2
=end

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 'one: ' + Inside_one.new.where_is_my_CONST
puts 'two: ' + Inside_two.new.where_is_my_CONST
puts 'three: ' + Object::CONST + Inside_two::CONST
puts 'four: ' + Inside_two::CONST + CONST
puts 'five: ' + Inside_one::CONST
puts 'six: ' + Inside_one::CONST.call + Inside_two::CONST

=begin
结果：
one:  out there inside one
two:  inside two
three:  out there inside two
four:  inside two out there
/Users/zetafin/ruby/test.rb:45:in `+': no implicit conversion of Proc into String (TypeError)
        from /Users/zetafin/ruby/test.rb:45:in `<main>'
=end