https://gitee.com/komavideo/LearnRuby.git

1. Ruby的基本语法语句

1.1 puts语句——输出“hello， world”

(任何一门语言的开始——输出一段文字)

puts "hello, world"

换行：

puts "第一行\n第二行\r第三行"

1.2 注释（三种方法）

#   第一种注释方法。
=begin
	第二章注释方法，多行注释
=end
__END__
	第三种注释方法，后面的部分全部为注释

1.3 运算符(操作符)

• Ruby的基本运算符与大多数编程语言类似，不再详细介绍，仅需注意Ruby有乘方运算符为：**

• 三目运算符：：类似于python的三目运算符。

point=40
puts point >= 30 ? "高分球员" : "一般球员"
# 等价于
if point >= 30 then
    puts "高分球员"
else
    puts "一般球员"
end

• 字符串运算符：用于字符串的拼接与合并。

a = "litec";
b = "dows";
# +:字符拼接
puts a + " " + b;
# <<：字符带入
a << b
puts a
puts b
# *：字符循环
a="A"
puts a*4

1.4 字符串中引号的使用

Ruby中的单引号与双引号的使用与shell语法相似，即双引号可以转义或插入变量与运算，而单引号会将其中的内容全部当作字符串。

p1 = "欢迎关注\nlitecdows"
p2 = '欢迎关注这个博主\nlitecdows'
puts p1
puts p2
mvp = "#{50+40+90}" 
puts mvp
mvp = '#{50+40+90}'
puts mvp

1.5 哈希变量（键值对）

类似于python的字典。
这里直接使用小马老师的Gitee源码：

mvp_rank = {"curry" => 28.1,"harden" => 30.3,"lebron" => 26}
puts mvp_rank
puts mvp_rank["harden"]

# 类似JSON使用
player = {name: "harden",age: 28,point: 30.3}
puts player
puts player[:name] + ", " + player[:age].to_s + ", " + player[:point].to_s

1.6 类型转换

• 字符或小数to整数：to_i;
• 数值to字符:to_s;
• 数值或字符to小数：to_f;

g = "23.56"
puts g.to_i
puts g.to_f

1.7 数组

数组里面可以是字符串或数字，先上源码：

games = ["绝地逃生", "永劫无间", "荒野大镖客",23.76,37]
puts games[3]+games[4]
puts games

数组循环:

games.each do |game|
    puts "我喜欢<<#{game}>>"
end

games.each_with_index do |game,i|
    puts "#{i+1}.#{game}"
end

数组合并：

puts games.join(";")

2. Ruby中的基本函数样式

定义一个基本的函数，包括传参与参数初始化。

def sayHello(name="tony") #默认为tony
	#puts中调用变量使用 #{}
    puts "Hello #{name}."
end

sayHello("Ruby") #传入参数Ruby
sayHello #调用默认值

3. Ruby中的类

定义一个基本类，initialize为构造函数, {@+变量名}相当于类内的全局变量

class Player
    #构造函数 @name为模板级变量，定义后可在类中访问。
    def initialize(name = "Koma")
        @name = name
    end
    def show()
        puts "player: #{@name}"
    end
end

实例化一个基本类：

koma = Player.new()
koma.show()

curry = Player.new("Curry")
curry.show()

3.1 与类相关的一些基本方法：

• instance_methods(false)：列出类(class)内部的方法，一般为false，表示仅列举出定义了的方法。即使方法（函数）为空，也会被列举出来。

puts Class.instance_methods(false)

• respond_to?：调查对象(object)的方法/属性是否可用。一般类会对自身的属性或方法作出外部调用的限制，输出true或false。

puts "Ist es möglich anzurufen: " + object.respond_to?("title").to_s

• send：执行对象(object)相应的方法。

if object.respond_to?("show") #判断对象是否存在show方法
   object.send("show")       #执行指定的方法
end

3.2 外部修改object的属性值：

类内的属性（Attribute）默认为私密状态。

class Game
    attr_accessor :price, :title #可以被外部调用修改
    def initialize(title = "怪物猎人世界", price = 200)
        @title = title
        @price = price
    end
    def show()
        puts "标题: #{@title}"
        puts "价格: #{@price}"
    end
end
mygame = Game.new() #实例化（ instantiate ）

# to_s用于puts输出
puts "title is " + mygame.respond_to?("title").to_s
puts "price is " + mygame.respond_to?("price").to_s
# 由于均被设置为可以获取，故下面语句不会报错。
mygame.title = "Super Mario World"
mygame.price = 150
mygame.show()

3.3 静态方法——self

self.Methods只能被类本身（class）而不能被实例（object）调用

class Game
    def initialize(id, title, price)
        @id = id
        @title = title
        @price = price
    end

    def showGame
        puts @id + ", " + @title + ", " + @price.to_s
    end

    def self.toStr
        puts "I love this game."
    end
end

zelda = Game.new("zelda", "ゼルダの伝説", 350)
zelda.showGame
#zelda.toStr #去掉注释会报错
# 以下两种调用方式均可。
Game.toStr
Game::toStr

3.4 Class继承

面向对象的编程必然会涉及到继承的问题。Ruby的继承的基本思路与其他编程语言类似。
Ruby使用“<”继承：Subclass < Father_class

#继承上一段代码的类
class SteamGame < Game
    def SteamInfo
        puts "G胖说了,STEAM要统一各个平台，完成Game All In One。"
    end
end
SteamGame.toStr
mygame = SteamGame.new("nobunaga-taishi", "信長の野望・大志", 450)
mygame.showGame
mygame.SteamInfo

3.5 Ruby模块的定义

module是Ruby中模块的关键字。module的使用仅与类有一点相似。可以使用模块名访问其自身的属性与静态方法。但不可以通过模块名访问一般方法。
模块的定义：

module BaseFunc
    Version = "0.0.1"

    def v
        return Version
    end

    def add(a, b)
        return a + b
    end

    def self.showVersion #静态方法
        return Version
    end

    #将v方法定义范围静态方法
    module_function :v
end

通过模块名访问：

puts BaseFunc::Version
#self两种访问方法
puts BaseFunc.showVersion
puts BaseFunc::showVersion
puts BaseFunc.v
#puts BaseFunc.add(10, 30) #会报错，使用模块名无法访问一般方法。

类include模块：

class BaseClass include BaseFunc
end
puts BaseClass::Version #可以访问
#self等私有方法属性是该模块自身的不会被include。
# puts BaseClass.showVersion
# puts BaseClass.v
myCls = BaseClass.new
#模块中的一般方法可以被include该模块的类的object继承。
puts myCls.add(10,20)

4. Ruby中的控制语句

参考源码(有现成的就用现成的吧，博主懒得敲了doge)

4.1 判断语句

4.1.1 if语句

if point_per_game >= 30
    puts "3500万美元/年"
elsif point_per_game >= 20
    puts "2000万美元/年"
else
    puts "中产合同吧"
end

4.1.2 unless语句

PUBG_SteamPrice = 40
#unless=只要不
unless PUBG_SteamPrice < 50
    #大于等于50的时候
    puts "《绝地求生》这个游戏虽然好玩，但是价格太贵，我还是玩学习版吧。"
else
    #小于50的时候
    puts "《绝地求生》降价了，大家要支持正版啊！剁手买！"
end

4.1.3 case 语句

week_day = 13

case week_day
    when 0,7
        puts "星期日"
    when 1
        puts "星期一"
    when 2
        puts "星期二"
    when 3
        puts "星期三"
    when 4
        puts "星期四"
    when 5
        puts "星期五"
    when 6 
        puts "星期六"
    else
        raise Exception.new("没这天")
end

4.2 循环

其实自己用的话，也就只会用那么几种。但是不得不说Ruby的循环样式很多。

#循环数组
gamelist = ["塞尔达传说", "超级马里奥", "开心剪纸"]
for game in gamelist do
    puts game
end

#循环1-5
for num in 1..5 do
    puts num
end

#循环1-4
for num in 1...5 do
    puts num
end

#while循环
index = 0
while index < 5 do
    puts "while.index=" + index.to_s
    index+=1
end

#untile
index = 0
until index == 5 do
    puts "until.index=" + index.to_s
    index+=1
end

#each循环
gamelist = ["塞尔达传说", "超级马里奥", "开心剪纸"]

gamelist.each { |game|
    puts game
}

gamelist.each do |game|
    puts game
end

gamelist.each_with_index do |game,i|
    puts i.to_s + "." + game
end

#times循环
5.times do |i|
    puts "第 #{i} 次times循环"
end

#step循环
1.step(10,1) do |i|
    puts "#{i}"
end

#upto
2.upto(5) do |i|
    puts "updo=" + i.to_s
end

#downto
5.downto(2) do |i|
    puts "downto=" + i.to_s
end

4.3 例外处理

类似于python的例外处理。

begin
    #有可能发生错误的处理
    puts ">处理开始"
    #raise "my raise error!"
    #10 / 0
rescue => e
    #错误发生时
    puts "X错误发生!"
    puts e
else
    #正常处理时
    puts "O正常处理"
ensure
    #最后处理，无论是否发生处理(final)
    puts "_最后的扫尾处理"
end