1. 函数
2. 对象
3. 数组
4. 备注
5. 运算操作符
6. 三项运算式
7. 字符串运算
8. 引号的使用
- 8.1 单引号、双引号
9. 哈希变量
10. 类型转换
整数转小数
小数转整数
- 13. 循环处理
- 14. 例外处理(类比try…catch…finally)

1. 函数

1.1 定义一个函数

def say_hello()
        puts "hello world"
end
调用:
say_hello      // 'helllo world'
或者
say_hello()    // 'hello world'

1.2 传参给函数

def say_hello(name)
        puts "hello #{name}."
end
调用:
say_hello('chenxi')   // 'hello chenxi'

1.3 函数参数默认值

def say_hello(name = 'wuming')
        puts "hello #{name}."
end
调用:
say_hello()     // 'hello wuming'

2. 对象

2.1 定义一个对象

class Player
      def initialize(name = 'chenxi')
          @name = name   // 这个类似python里的self.name=name 或者 js里的this.name=name
    end
      def show_name()
          puts "player's name: #{@name}"
    end
end

2.2 实例化一个对象

chenxi = Player.new()
chenx.show()
amy = Player.new('Amy')
amy.show()

2.3 instance_methods：列出对象（类）内部的可用方法，用于调查解析对象的使用

class Game
      def initialize(title = '怪物猎人世界', price = 200)
          @title = title
           @price = price
    end
      def show()
          puts "标题 #{@title}"
          puts "价格 #{@price}"
    end
      def show2()
    end
      def show3()
    end
end
puts Game.instance_methods(false)   // show show2 show3  传入false只打印我们定义的方法

2.4 respond_to?: 判断对象的方法/属性是否可用（多用于设计模式中）

send: 执行对象的方法

mario = Game.new('超级马里奥', 350)
if mario.respond_to?('show')
     mario.send('show')

2.5 使用对象属性

attr_accessor: 定义可存取对象的属性（提供了可供对象外部使用的属性） ```ruby class Game attr_accessor :price, :title def initialize(title = ‘怪物猎人世界’, price = 200)
```
 @title = title
 @price = price
```
end def show()
```
 puts "标题: #{@title}"
 puts "价格: #{@price}"
```
end end

game = Game.new() game.show() // 标题: 怪物猎人世界价格: 200

game.title = ‘跑跑卡丁车’ game.price = 120 game.show() // 标题: 跑跑卡丁车价格: 120


<a name="JXHwS"></a>
### 2.6 class再入门 - 类的静态方法
```ruby
class Game
      def initialize(id, title, price)
          @id = id
          @title = title
          @price = price
    end
      def show_game()
          puts @id + ", " + @title + ", " + @price.to_s
    end
      def self.toStr()           # self.方法名 => 这样的写法是指这个方法是类的静态方法
          puts "I love this game."
    end
end
game = Game.new("aulio", "my first game", 300)
game.show_game()
# 调用类的静态方法
Game.toStr()
或者
Game::toStr()

2.7 类继承

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

      def show_game()
          puts @id + ", " + @title + ", " + @price.to_s
    end

      def self.toStr()           # self.方法名 => 这样的写法是指这个方法是类的静态方法
          puts "I love this game."
    end
end

# 子类
class SteamGame < Game
      def steam_info()
          puts "G胖说了，Steam要统一各个平台，完成Game all in one"
    end
end

SteamGame.toStr()         # 子类继承了父类，可以调用在子类上直接调用父类的静态方法
# 另种写法：SteamGame::toStr()

new_game = SteamGame.new("1", "信长的野望", 400)
new_game.show_game()      # 子类的实例上调用父类的方法
new_game.steam_info()     # 子类的实例上调用子类的方法

3. 数组

3.1 定义一个数组

games = ['绝地逃生', '怪物猎人世界', '跑跑卡丁车']

3.2 循环数组的内容

不带索引遍历

games.each do |game|
    puts '游戏名: #{game}'
end

带索引遍历

games.each_with_index do |game, index|
    puts "#{index} - #{game}"
end

3.3 数组连接 join

puts games.join(',')

3.4 判断是否是一个数组

if games.respond_to?('each')
      ...
end

if games.respond_to?('each_with_index')
      ...
end

4. 备注

单行备注
```
# 注释
```
多行备注
```
=begin
...
=end
```
之后全备注
```
__END__
被注释的内容...
```

5. 运算操作符

5.1 运算操作符

+: 加法
-: 减法
*：乘法
**: 阶乘、几次方
/: 除法
%: 取余

5.2 比较操作符

==: 等于
!=: 不等于
: 大于
=: 大于等于
<: 小于
<=: 小于等于

5.3 逻辑操作符

&&: 逻辑与
||: 逻辑或
!: 逻辑非

5.4 位运算操作符（不常用）

&: 与AND
|: 或OR
^: 异或
~: 位反转
<<: 左移位
: 右移位

6. 三项运算式

写法：条件？处理1 ：处理2

point = 30
if point >= 30
    puts "顶级球员"
else
    puts "一般球员"
end

👆改写成三项运算式

puts point >= 30 ? "顶级球员" : "一般球员"

7. 字符串运算

7.1 字符连接(+)

a = "hello"
b = "chenxi"

puts a + " " + b      // "hello chenxi"

7.2 字符带入(<<): 类似 +=

a = "hello"
b = "chenxi"

puts a    // "hello"
puts b    // "chenxi"

a << b    // 想象成 a += b
puts a    // "hellochenxi"

7.3 字符翻倍(*)

a = "A"
puts a * 4     // "AAAA"

8. 引号的使用

8.1 单引号、双引号

p1 = "aa\nbb"
p2 = 'cc\ndd'


puts p1          // aa
                 // bb

puts p2          // cc\ndd

9. 哈希变量

哈希变量 (key - value值对) ```ruby mvp_rank = { “curry” => 28.1, “harden” => 30.3, “lebron” => 26 }

puts mvp_rank // {“curry”=>28.1, “harden”=>30.3, “lebran”=>26} puts mvp_rank[“harden”] // 30.3

类似JSON写法
```ruby
player = {
    name: "harden",
  age: 28,
  point: 30.3
}

puts layer              // {:name => "harden", :age => 28, :point => 30.3}

puts player[:name] + ", " + player[:age].to_s + ", " + player[:point].to_s

10. 类型转换

字符转数值
数值转字符 ```ruby

FG = “50” P3 = “40” FT = “90”

puts FG + P3 + FT # 504090 puts FG.to_i + P3.to_i + FT.to_i # 180 puts (FG.to_i + P3.to_i + FT.to_i).to_s + “ 俱乐部” # 180 俱乐部

整数转小数

puts FG.to_i # 50 puts FG.to_i.to_f # 50.0

小数转整数

puts 1234.5678 # 1234.5678 puts 1234.5678.to_i # 1234


---


<a name="uHFKV"></a>
## 11. 模块的定义
> Ruby模块其实类似Class类的概念，但也有所不同


---


<a name="fRYic"></a>
## 12. 条件控制文

- if / else
- if / elsif
- unless
- case / when
```ruby
point_per_game = 15

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

# unless = 只要不
PUBG_SteamPrice = 40

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

week_day = 0

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

13. 循环处理

for
while
until

13.1 循环数组 - 记住

game_list = ["赛达尔传说", "超级马里奥", "消消乐"]

for game in game_list do
      puts game
end

13.2 循环1-5

for num in 1..5 do         // .. 等价 小于等于
      puts num               // 1 2 3 4 5
end

13.3 循环1-4 - 记住

for num in 1...5 do        // ... 等价 小于
      puts num               // 1 2 3 4
end


len = 5
for index in 0...len do
      puts index             // 1 2 3 4 5
end

13.4 while循环 - 记住

index = 0

while index < 5 do
      puts "while.index = " + index.to_s
      index += 1
end

13.5 until循环

index = 0

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

13.6 each循环 - 记住

game_list = ["赛达尔传说", "超级马里奥", "消消乐"]

game_list.each do |game|
      puts game
end

game_list.each_with_index do |game, index|
      puts index.to_s + "." + game
end

13.7 times循环

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

类似
for (let i = 0; i < 5; i++) { ... }

13.8 step循环 - 记住

1.step(10, 3) do |i|      // 从1开始循环到10，每次跳3个间隔
      puts "#{i}"
end

类似
for (let i = 1; i < 10; i += 3) { ... }

13.9 upto循环

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

类似 
for (let i = 2; i <= 5; i++) { ... }

13.10 downto循环

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

类似
for (let i = 5; i >= 2; i--) { ... }

14. 例外处理(类比try…catch…finally)

begin
rescue / else / ensure

end ```ruby begin

puts "处理开始"
# raise error

rescue => e

# 捕获到错误、异常
puts "错误发生"

else

# 正常处理
   puts "运行正常"

ensure

# 最后处理
puts "最后处理"

end

类比： try { …
} catch(error) { … } finally { … } ```

Ruby基础知识