Ruby 语法(基础)

1.关键字，标识符，注释

Ruby保留字

下表列出了 Ruby 中的保留字。这些保留字不能作为常量或变量的名称。但是，它们可以作为方法名。

BEGIN	do	next	then
END	else	nil	true
alias	elsif	not	undef
and	end	or	unless
begin	ensure	redo	until
break	false	rescue	when
case	for	retry	while
class	if	return	while
def	in	self	_FILE_
defined?	module	super	_LINE_

Ruby标识符

标识符是变量、常量和方法的名称。Ruby 标识符是大小写敏感的。这意味着 Ram 和 RAM 在 Ruby 中是两个不同的标识符。

Ruby 标识符的名称可以包含字母、数字和下划线字符（ _ ）。

Ruby变量命名

• 局不变量小写字母下划线开头
• 全局变量以$开头
• 实例变量@开头
• 类变量@@开头
• 常量 大写字母
• 类名 大驼峰

Ruby基本类型

数字、字符串、数组、符号、散列表、区间、正则表达式

基本类型	对应类
数字	[[Fixnum、Bignum]=>Integer、Float,Complex]=>Numeric
字符串	String
数组	Array
符号	Symbol
散列表	Hash
区间	Range
正则表达式	Regexp

运算符优先级

运算符	说明
[]、[]=	数组下标，数据元素赋值
**	乘幂
！、~、+、-	非、位非、一元加、一元减
*、/、%	乘、除、模
+、-	加、减、
>>、<<	右移、左移
&	位与
^、|	位异或、位或
<=、<、>、>=	比较运算符
<=>,==,===,=,!=,!	各种相等判断
&&、and	逻辑与
||、or	逻辑或
..、...	区间开始点到结束点
? :	三元运算 (a==1?'true':'false')
=、%=、~=、/=、-=、+=、|=、&= 、>>=、<<=、=、&&=、||=、*=	各种赋值运算符
defined?	检查是否定义
not	逻辑非 等价!
if unless while until	表达式和修饰符
begin/end	Block 表达式

流程控制

1.条件控制

# if else 示例
if a<10
  puts 'a小于10'
elsif a<20
  puts 'a大于等于10，小于20'
else
  puts 'a大于30'
end

# unless 示例
unless a<10
  puts 'a小于10'
else
  puts 'a大于等于10'
end

# case示例
case a.class.name
when 'String'
  puts 'a为字符串'
when 'Fixnum','Bignum','Float'
  puts 'a为数字'
when 'Array'
  puts 'a为数组'
else
  puts “a为#{a.a.class.name}”
end

2.循环控制

# while 示例
i = 0
while i<10
  puts i
  i+=1
end

# until 示例
i = 0
until i>10
  puts i
  i += 1
end

# for 示例
for i in [1,2,3,4,5]
  puts i
end

# 使用区间
for i in (1..10)
  puts i
end

# each 示例
(1..10).each do |i|
  puts i
end

# 改变循环过程
# break 跳出整个循环
(1..10).each do |i|
  puts i
  break if i>=5
end

# next 跳出当前循环
(1..10).each do |i|
  next if i%2 == 0
  puts i
end

2.Ruby中的面向对象

定义类和构造函数

定义类方法实例方法

class MyClass
  # 定义类方法
  def self.method1
    puts 'method1'
  end
  
  # 另一种定义类方法
  def MyClass.Method2
    puts 'method2'
  end
  
  # 定义实例方法
  def methods3
    puts 'methods3'
  end 
end

my_class = MyClass.new
my_class.method3
MyClass.method1
MyClass.method2
# method3 实例方法会报错
MyClass.method3 

定义属性

attr、attr_reader、attr_writer、attr_accessor

attr 在缺省的情况下等价于attr_reader

可通过 attr(symbol,writable = false) 设置是否可写

attr(:attr1,true) 等价于 attr_accessor :attr1

class MyClass
  # 使用attr_accessor 定义attrl
  attr_accessor :attr1
  # 使用方法定义 attr2 属性
  def attr2
    @attr2
  end
  def attr2=(value)
    @attr2 = value
  end
end

my_class = MyClass.new
my_class.attr1 = 'attr1'
puts my_class.attr1

my_class.attr2 = 'attr2'
puts my_class.attr2

访问控制

public(公有)、protected(保护)、private(私有)

• Public 可被任何人调用，没有任何访问限制，通常默认级别就是公有的
• Protected 只能被定义该方法的类及其子类调用
• Private 区别于protected 是不能被明确的接受者调用，只能被self调用

class MyClass
  # 默认是public
  def public_method
    puts 'public_method'
  end
  
  protected
  def protected_method
    puts 'protected_method'
  end
  
  private
  def privated_method
    puts 'privated_method'
  end
  
  public
  def public_method
    puts 'public_method'
  end
end

class MySubClass < MyClass
  # 子类可以在内部使用父类中的protected和provate的方法
  def call_protected_method
    protected_method
  end  
  def call_private_method
    private_method
  end
end

#protected 和 private 区别
class MyClass
    def initialize(name)
        @name = name
    end

    def compare(c)
        c.name == @name
    end

    protected  # 换成private 会报错
    # private
    def name
        @name
    end  
end

a = MyClass.new('a')
b = MyClass.new('a')
puts a.compare(b)

类变量实例变量

class MyClass
    @@instant_object_count = 0
    # 返回myclass的实例数量
    def self.instant_object_count
        @@instant_object_count
    end
    # 返回实例对象的序号
    def object_index
        @instant_object_index
    end

    # 实例方法返回myclass的所有实例数量
    def object_count
        @@instant_object_count
    end
    # 初始化实例函数
    def initialize
        # 创建新实例对象时，类变量计数器+1,并把标记变量给实例变量
        @@instant_object_count = @@instant_object_count +1
        @instant_object_index = @@instant_object_count
    end
end
my_class1 = MyClass.new
puts "现在有#{my_class1.object_count}个实例"
my_class2  = MyClass.new
puts "现在有#{my_class1.object_count}个实例"
puts "class1的序号#{my_class1.object_index}"
puts "class2的序号#{my_class2.object_index}"

输出：
现在有1个实例
现在有2个实例
class1的序号1
class2的序号2

类的扩展和继承

# 扩展实例的方法
class Fixnum
    # 添加一个实例方法
    def speak
        puts "我的值#{self}"
    end
    # 覆盖旧的abs方法
    def  abs
        puts "abs不能用了"
    end
end

# 扩展类方法
def Fixnum.say_hello
    puts 'Hello!'
end

# 批量扩展类方法
class << Fixnum
    def say_hello_again
        puts "Hello again!"
    end
end

1.speak
-1.abs
Fixnum.say_hello
Fixnum.say_hello_again

# 类的继承
class Person
    attr_accessor :name, :age

    def say_hello
        puts "你好，我是#{self.name}"
    end
    
    def say_age
        puts "我的年龄是#{self.age}"
    end
end

class Man < Person
    def sex
        return "男"
    end

    def say_sex
        puts "我的性别是#{self.sex}"
    end

    def say_hello
        super
        say_age
        say_sex
    end
end

man = Man.new
man.name = "张三"
man.age = 22
man.say_hello

别名

class Fixnum
    # 创建一个＋方法的别名
    alias plus +
    def +(value)
        return self.plus(value*2)
    end
end

puts 1.plus(1) # 结果为2

puts 1+1 # 结果为3

复制、冻结对象

dum和clone都是浅复制，如果对象还包含了对其他对象的引用，将不会复制这些包含的对象，而只复制他的引用

class MyClass
    attr_accessor :value
end
a = MyClass.new
# 冻结a
a.freeze
# 下面代码会出错
def a.new_method
    puts "变量a的新方法"
end

a = "text"
a.freeze

a<<"a" # 会报错 
a = a+"a" # 不会报错 a将是一个新的对象

对象的序列化

class MyClass
    attr_accessor :value
end

a = MyClass.new
a.value = 1

# 获取a的序列化字符
dump_copy = Marshal.dump(a)
# 通过序列化字符重建对象
b = Marshal.load(dump_copy)

puts b.class
puts b.value