Ruby 入门 + 进阶训练

1. Hello World没有分号，没有 main

复制puts "你好，Ruby！"        # 打印并换行
print "1 + 2 = "         # 不换行
puts 1 + 2

2. 变量与一切皆对象连数字都是对象

变量不用声明类型，赋啥是啥。关键思想：一切皆对象——数字、字符串、类、nil 都能调用方法。

复制x = 3
puts x.class          # Integer
puts 3.odd?           # true（数字也是对象，能调方法）
name = "Ruby"
puts name.upcase      # RUBY

3. 字符串与符号 Symbol命名的两种身份

• "字符串"：可变、每次出现可能新建对象。
• :符号：不可变、全局唯一（同名 Symbol 是同一个对象），用作名字/键。

复制s1 = "a"; s2 = "a"
puts s1.equal?(s2)        # false（两个不同对象）
sym1 = :name; sym2 = :name
puts sym1.equal?(sym2)    # true（同一个 Symbol）

4. 数组与哈希Ruby 的集合很顺手

复制arr = [1, 2, 3]
arr << 4                 # 追加，得到 [1,2,3,4]
h = { name: "Ruby", age: 30 }
puts h[:name]            # Ruby（用 Symbol 作键）
puts arr.last            # 4

5. 控制流if / unless / while

复制x = 10
puts "正数" if x > 0          # 后置 if（一行判断超好用）
unless x < 0                 # unless = if not
  puts "非负"
end
3.times { puts "循环" }        # 块式循环

6. 方法 def用 def ... end 定义

复制def greet(name)
  "你好，#{name}！"        # 字符串插值 #{}，最后一个表达式自动返回
end
puts greet("Ruby")

7. 块 / Proc / LambdaRuby 的函数式灵魂

块（{...} 或 do...end）是匿名代码块，可传给方法。区分：

• block：最轻量，用 yield 调用，无对象身份。
• proc：return 从外围方法返回。
• lambda：像「真正函数」，return 只从自己返回，且严格检查参数个数。

复制def run
  yield 3                  # 调用传入的块
end
run { |n| puts "拿到 #{n}" }

lam = lambda { |a, b| a + b }
puts lam.call(2, 3)

8. 类与对象class / initialize / @实例变量

复制class Dog
  def initialize(name)
    @name = name           # @ 开头是实例变量
  end
  def bark
    "#{@name} 汪汪"
  end
end
d = Dog.new("旺财")
puts d.bark

9. 模块与混入mixin 代替多继承

Ruby 单继承，用 module + include 把一组方法「混入」类，实现多能力复用。

复制module Greetable
  def hi
    "嗨，我是 #{@name}"
  end
end
class Cat
  include Greetable        # 混入模块的方法
  def initialize(name); @name = name; end
end
puts Cat.new("咪咪").hi

10. 异常处理begin / rescue / ensure

复制begin
  puts 1 / 0
rescue ZeroDivisionError => e
  puts "出错：#{e.message}"
ensure
  puts "一定执行"
end

11. method_missing 元编程拦截未定义的方法调用

当对象收到未定义的方法，Ruby 会调 method_missing，借此能实现「动态方法名」。

复制class Dynamic
  def method_missing(name, *args)
    "你调用了 #{name}，参数 #{args.inspect}"
  end
end
d = Dynamic.new
puts d.whatever(1, 2)     # 未定义方法也被接住

12. 打开类与猴子补丁运行时修改已有类

Ruby 允许重新打开任何类（包括内置类）追加方法——强大也危险。

复制class String
  def shout
    self.upcase + "!"
  end
end
puts "hello".shout        # HELLO!

13. 枚举 each / map / select函数式的日常

复制nums = [1, 2, 3, 4, 5]
puts nums.map { |n| n * n }.inspect        # [1,4,9,16,25]
puts nums.select { |n| n.odd? }.inspect    # [1,3,5]
puts nums.inject(0) { |s, n| s + n }       # 15（累加）

14. 并发：GIL 与 RactorRuby 的并行真相

CRuby 有 全局解释器锁（GIL/GVL）：同一时刻只有一个线程在执行 Ruby 代码。CPU 密集并行请用多进程；Ruby 3 的 Ractor 才提供真正的并行。

复制# 多线程适合 IO 等待，不适合 CPU 密集
threads = 3.times.map do
  Thread.new { sleep 0.1; "done" }
end
puts threads.map(&:value).inspect

15. 文件 IO读写的惯用写法

复制# 写
File.write("a.txt", "hello")
# 读
puts File.read("a.txt")
# 逐行
File.foreach("a.txt") { |line| puts line }

16. attr_accessor 原理揭开属性方法的魔法

attr_accessor :x 等价于自动生成 def x; @x; end 和 def x=(v); @x=v; end。

复制class User
  attr_accessor :name     # 自动生成 getter + setter
end
u = User.new
u.name = "Ruby"
puts u.name

🧪 动手实验室（点 ▶ 直接看结果）

代码已预填，打开自动跑一次；点 ▶ 运行 看结果，框内可直接改。

① Hello World

② 字符串与符号

③ 数组 map / select

④ 类与对象

⑤ 块与 yield

💡 连老师都不会教你的干货（工业级技巧）

自测题（点击展开答案）

• Q1：Ruby 里 3.odd? 能调用说明什么？
  A：说明一切皆对象——连整数都是对象，能响应方法。
• Q2：:name 和 "name" 作哈希键的区别？
  A：同名 Symbol 是同一个对象（equal? 为 true），字符串每次新建。键应优先用 Symbol，省内存且唯一。
• Q3：proc 和 lambda 的 return 行为有何不同？
  A：lambda 的 return 只退出自身；proc 的 return 直接退出外围方法。参数检查也：lambda 严格、proc 宽松。
• Q4：Ruby 多线程能加速 CPU 密集计算吗？
  A：不能。CRuby 有 GIL，同刻只有一个线程跑 Ruby 代码；多线程主要帮 IO 并发。
• Q5：attr_accessor :x 做了什么？
  A：自动生成 x 的 getter 和 x= 的 setter，等价于手写两个方法。
• Q6：为什么猴子补丁危险？
  A：它修改全局类，多个库改同一方法会互相覆盖，导致难以追踪的 bug；生产应限定作用域。
• Q7：inject(0) { |s,n| s+n } 是干什么？
  A：累加（归约）。从初始值 0 开始，每次把元素 n 合并进累计值 s，最终得到总和。