Ruby 说明文档

1. 引言

Ruby 是一种动态的、面向对象的、解释型的高级编程语言，由日本计算机科学家松本行弘（Yukihiro Matsumoto，常称 Matz）于 1995 年发布。Ruby 的设计哲学强调“程序员友好”，其核心原则是“最小惊讶原则”，即语言的行为应最大程度地符合程序员的直觉，使编程工作变得愉悦而高效。

Ruby 融合了函数式编程和命令式编程的特性，拥有简洁优雅的语法、强大的元编程能力以及完善的动态类型系统。它凭借 Ruby on Rails 框架在 Web 开发领域声名鹊起，同时也广泛应用于自动化脚本、数据处理、DevOps 工具和原型设计等领域。Ruby 的一切皆为对象，包括基本数据类型，这一纯粹的面向对象设计使其语言表达力极为丰富。

2. 基本语法与程序结构

2.1 Hello World 示例

Ruby 程序的入口不需要特定的 main 函数，直接编写顶层代码即可执行。最简单的输出示例如下：

puts "Hello, World!"

2.2 语句与分隔符

• Ruby 使用换行符作为语句的结束标志，通常不需要使用分号。
• 若需在一行内放置多条语句，可以使用分号 ; 分隔。
• 反斜杠 \ 可用于将长语句折行。

2.3 注释

• 单行注释：使用 # 符号，从该符号开始到行尾均为注释。
• 多行注释（内嵌文档）：使用 =begin 和 =end 标记，它们必须位于行首。

# 这是单行注释

=begin
这是多行注释区域
可以包含多行文本
=end

2.4 大小写敏感性

Ruby 是大小写敏感的。特别地，Ruby 的命名约定具有语义含义：

• 类名和模块名采用大写字母开头的驼峰命名法，如 MyClass。
• 常量采用全大写字母加下划线，如 MAX_SIZE。
• 变量和方法名采用蛇形命名法（小写字母加下划线），如 user_name。

3. 数据类型

Ruby 中一切皆为对象，所有数据都拥有属性和方法。

3.1 数字（Numeric）

• 整数：Fixnum（较小整数）和 Bignum（大整数）在 Ruby 2.4 之后统一为 Integer 类。支持十进制、二进制（0b1010）、八进制（0o755）和十六进制（0xFF）。
• 浮点数：Float 类，遵循 IEEE 754 标准，如 3.14、1.2e-3。
• 有理数与复数：Rational（如 2/3r）和 Complex（如 1+2i）也作为内置类型支持。

3.2 字符串（String）

字符串是 String 类的实例，使用单引号或双引号括起。

• 单引号字符串：不解析转义字符（除 \' 和 \\ 外），也不进行插值。
• 双引号字符串：支持转义字符（如 \n、\t）和表达式插值（#{expression}）。

name = "Ruby"
puts "Hello, #{name}"   # 输出：Hello, Ruby
puts 'Hello, #{name}'   # 输出：Hello, #{name}

Ruby 支持多种字符串操作，包括拼接（+）、重复（*）、索引访问及丰富的内置方法（length、upcase、gsub 等）。

3.3 符号（Symbol）

符号是 Symbol 类的实例，以冒号开头（如 :status）。符号是不可变的、唯一的标识符，通常用作哈希的键或表示方法名称。与字符串不同，相同内容的符号在内存中只存在一份，因此内存效率更高。

:active
:"user-name"

3.4 数组（Array）

数组是有序的、可变的集合，可以容纳任意类型的对象（包括混合类型）。索引从 0 开始，支持负索引（从末尾倒数）。

arr = [1, "two", 3.0, :four]
arr[0]    # => 1
arr[-1]   # => :four

Ruby 数组提供了丰富的迭代方法（each、map、select 等）和队列/栈操作（push、pop、shift、unshift）。

3.5 哈希（Hash）

哈希是键值对的集合，类似于字典或映射。键可以是任意类型的对象，但通常使用符号或字符串。

person = { name: "Alice", age: 30 }        # 符号键的简写语法
person[:name]   # => "Alice"

person2 = { "name" => "Bob", "age" => 25 } # 旧式哈希语法

3.6 布尔值与 nil

• true 和 false 分别表示真与假，它们是 TrueClass 和 FalseClass 的唯一实例。
• nil 表示“无”或“空”，是 NilClass 的唯一实例。在条件判断中，只有 false 和 nil 被视为假值，其余所有值（包括 0 和空字符串）都为真。

4. 变量与常量

4.1 局部变量

以小写字母或下划线开头，作用域限定在当前的代码块、方法或顶层上下文中。

count = 10
_message = "internal"

4.2 实例变量

以 @ 开头，属于特定的对象实例，在对象的各方法之间共享。未初始化的实例变量值为 nil。

@name = "Ruby"

4.3 类变量

以 @@ 开头，属于整个类，在所有该类实例和子类之间共享。使用时需谨慎，因其易导致继承结构中的意外副作用。

@@total_count = 0

4.4 全局变量

以 $ 开头，在整个程序范围内可见。滥用全局变量会降低代码的可维护性，应尽量少用。

$debug_mode = true

4.5 常量

以大写字母开头，用于存储不应改变的值。Ruby 对常量仅发出警告而非报错，但最佳实践是不修改常量。

MAX_RETRIES = 3

5. 运算符

5.1 算术运算符

+（加）、-（减）、*（乘）、/（除）、%（取模）、**（指数幂）。

5.2 比较运算符

==（相等）、!=（不等）、>、<、>=、<=。此外还有 <=>（太空船运算符），返回 -1、0 或 1，用于综合比较。

5.3 逻辑运算符

&&（与）、||（或）、!（非）。同时也支持单词形式的 and、or、not，但它们的优先级低于符号形式，通常用于流程控制。

5.4 赋值运算符

=、+=、-=、*=、/=、%=、**=，以及 ||=（惰性赋值，仅在变量为 nil 或 false 时赋值）和 &&=。

5.5 范围运算符

• .. 表示包含右端点的范围，如 1..5 包含 1、2、3、4、5。
• ... 表示排除右端点的范围，如 1...5 包含 1、2、3、4。

5.6 特殊运算符

• defined?：判断表达式是否已定义，返回描述信息字符串或 nil。
• 三元运算符：条件 ? 真值表达式 : 假值表达式。

6. 控制流与迭代

6.1 条件判断

• if / elsif / else：

if score >= 90
  puts "A"
elsif score >= 80
  puts "B"
else
  puts "C"
end

if 可以后置于语句（单行条件），如 puts "Adult" if age >= 18。

• unless：unless 是 if 的反向形式，条件为假时执行。

puts "Under age" unless age >= 18

• case：相当于多分支的 switch，支持多种匹配方式。

case grade
when "A" then puts "Excellent"
when "B", "C" then puts "Good"
else puts "Need improvement"
end

6.2 循环

• while：条件为真时执行。
• until：条件为假时执行（即直到条件为真）。
• for / in：遍历集合，但 Ruby 更推荐使用迭代器。

i = 0
while i < 5
  puts i
  i += 1
end

for item in [1,2,3]
  puts item
end

6.3 迭代器（核心惯用法）

Ruby 强烈推荐使用迭代器和代码块进行循环操作，这是最具 Ruby 风格的编程方式。

• times：执行指定次数。
• each：遍历集合中的每个元素。
• map / collect：对集合进行变换并返回新数组。
• select：筛选符合条件的元素。
• upto / downto：从某个数往上或往下迭代。

5.times { puts "Hello" }

[1, 2, 3].each do |num|
  puts num * 2
end

result = (1..10).select { |n| n.even? }  # => [2, 4, 6, 8, 10]

6.4 跳转语句

• break：退出当前循环或迭代。
• next：跳过本次迭代，进入下一次。
• redo：重新执行本次迭代的代码块，不检查条件。
• return：从方法中返回。
• throw / catch：非局部跳转，用于在嵌套结构中提前退出。

7. 方法与代码块

7.1 方法定义

使用 def 关键字定义方法，以 end 结尾。方法名采用蛇形命名法。

def greet(name)
  "Hello, #{name}!"
end

puts greet("World")

• 方法默认返回最后一个表达式的值，也可以显式使用 return。
• 方法参数支持默认值：def say(word = "Hello")。
• 可变参数（任意数量参数）使用 *args 收集为数组。
• 关键字参数（命名参数）使用 key: value 形式。

def introduce(name, age: 0, **options)
  puts "#{name}, age #{age}"
  puts options[:city]
end

7.2 代码块（Block）

代码块是 Ruby 最独特的特性之一，它是一段可传递的、未命名的代码。代码块用 do...end（多行）或 {...}（单行）包裹。

• 显式接收块：在方法内部使用 yield 调用传入的代码块。
• 检查块是否提供：block_given? 方法。
• 转为对象：使用 & 将代码块转换为 Proc 对象，反之亦然。

def logger
  if block_given?
    puts "Start logging"
    yield
    puts "End logging"
  end
end

logger { puts "Inside the block" }

7.3 Proc 与 Lambda

Proc 和 Lambda 是将代码块封装为可调用的对象，便于存储和传递。

• Proc：proc { |x| x * 2 } 或 Proc.new { |x| x * 2 }。return 会从当前方法返回。
• Lambda：lambda { |x| x * 2 } 或 ->(x) { x * 2 }（箭头语法）。return 仅从自身返回，更像是普通方法。

square = ->(x) { x * x }
puts square.call(5)   # => 25

8. 面向对象编程

Ruby 是纯面向对象语言，所有对象都源自 Object 类。

8.1 类定义

使用 class 关键字定义类，以 end 结尾。类名以大写字母开头。

class Animal
  def initialize(name)
    @name = name
  end

  def speak
    puts "#{@name} makes a sound."
  end
end

dog = Animal.new("Dog")
dog.speak

initialize 是构造函数，在 .new 调用时执行。

8.2 访问控制（可见性）

• public：默认可见性，任何地方都可调用。
• protected：可在同一类及其子类中调用，无需显式接收者。
• private：只能以隐式接收者（即当前对象自身）调用，不可显式指定接收者。

class Person
  private
  def secret
    "hidden"
  end
end

8.3 属性访问器

Ruby 不直接公开实例变量，通过方法进行封装。但提供便捷的快捷方式：

• attr_reader :name：生成读取方法 name。
• attr_writer :name：生成写入方法 name=。
• attr_accessor :name：同时生成读取和写入方法。

class User
  attr_accessor :username
  def initialize(username)
    @username = username
  end
end

8.4 继承

使用 < 表示继承。Ruby 支持单继承，但通过模块（Module）实现多重继承（混入）。

class Cat < Animal
  def speak
    puts "#{@name} says Meow!"
  end
end

子类可以重写父类方法，并使用 super 调用父类的同名方法。

8.5 模块与混入（Mixins）

模块是方法的集合，不能实例化。通过 include 将模块方法引入类中作为实例方法，或通过 extend 引入作为类方法。

module Swimmable
  def swim
    puts "Swimming!"
  end
end

class Fish
  include Swimmable
end

fish = Fish.new
fish.swim

Ruby 内置的 Enumerable 模块是混入的经典示例，只要类实现了 each 方法，就可以混入 Enumerable 获得 map、select、reduce 等大量集合方法。

8.6 单例方法与单例类

单个对象可以拥有独一无二的方法，称为单例方法。

str = "hello"
def str.shout
  upcase + "!"
end
puts str.shout   # => "HELLO!"

对象的单例类（也称为元类或本征类）是存储这些单例方法的地方，可通过 class << object 打开。

9. 异常处理

Ruby 使用 begin...rescue...ensure 结构处理异常。

begin
  result = 10 / 0
rescue ZeroDivisionError => e
  puts "Error occurred: #{e.message}"
  result = 0
rescue => e  # 捕获所有标准异常
  puts "General error: #{e}"
else
  puts "No error occurred"  # 未发生异常时执行
ensure
  puts "This always runs"   # 无论是否异常均执行（如释放资源）
end

• 使用 raise 或 fail 手动抛出异常：raise "Invalid input"。
• 可以自定义异常类，通常继承自 StandardError。

10. 标准库概览

Ruby 内置了功能强大的标准库，通过 require 加载所需模块即可使用。

• 核心扩展：json（JSON 解析与生成）、yaml（YAML 处理）、csv（CSV 文件操作）。
• 集合与枚举：Set（无序不重复集合）、Enumerator（惰性枚举器）。
• 文件与IO：File、Dir 用于文件系统操作；IO 用于输入输出流。
• 时间与日期：Time、Date、DateTime 处理时间和日期计算。
• 网络编程：Net::HTTP、Net::SMTP 等支持 HTTP 和邮件协议；Socket 提供底层网络接口。
• 并发与并行：Thread 用于多线程编程；Fiber 用于轻量级协程；Process 用于进程管理。
• 测试框架：Test::Unit（内置单元测试框架）和 RSpec（第三方，但极为常用）。
• Web 服务器：WEBrick 是内置的 HTTP 服务器库。

11. 元编程

Ruby 强大的元编程能力允许程序在运行时动态操作类、模块和方法。

• 动态方法调用：使用 send 或 public_send 调用对象的方法。
• 定义方法：使用 define_method 在运行时定义实例方法。
• 缺失方法：method_missing 是 Ruby 最著名的钩子方法，当调用未定义的方法时触发，可用于构建 DSL（领域特定语言）。
• 类宏：attr_accessor 本身就是类宏的典型例子，它是在类定义时执行的类方法。

class Dynamic
  define_method :dynamic_method do |arg|
    puts "Called with #{arg}"
  end

  def method_missing(name, *args)
    puts "You called #{name} with #{args}"
  end
end

obj = Dynamic.new
obj.dynamic_method(10)  # 正常调用
obj.anything(1,2)       # 触发 method_missing

12. 编程风格与最佳实践

遵循社区统一的编码风格（以 Ruby Style Guide 为基准）能极大提升代码的可读性和协作效率。

• 缩进与空格：使用两个空格缩进，不使用制表符。在操作符前后、逗号后添加空格。
• 命名规范：类名使用 CamelCase；变量和方法使用 snake_case；常量使用 SCREAMING_SNAKE_CASE。
• 条件与循环：优先使用后置 if 和 unless 简化单行条件。尽量避免使用 for，改用 each 系列迭代器。
• 块风格：单行块使用 {...}，多行块使用 do...end。
• 返回值：利用方法的隐式返回值，避免不必要的 return。
• 冻结字符串：在文件头部使用 # frozen_string_literal: true 以优化字符串内存管理（Ruby 2.3+）。
• 安全导航：使用 &. 运算符（如 user&.profile&.age）优雅地处理 nil 对象链。
• 测试驱动：养成编写测试的习惯，Ruby 社区高度重视测试，RSpec 和 Minitest 是最常用的测试框架。

13. 结语

Ruby 是一门为程序员幸福而设计的语言。它从 Lisp、Smalltalk 和 Perl 等语言中汲取灵感，将纯粹的面向对象思想与强大的函数式编程特性融为一体。Ruby 的动态性和元编程能力使其成为构建 Web 应用（Rails）、自动化脚本和 DSL 的理想选择。虽然 Ruby 在执行纯计算密集型任务时速度不及 C 或 Rust，但其极高的开发效率和优雅的代码表达能力，让开发者能够以更少的代码完成更多工作，且维护成本更低。

学习 Ruby 不仅仅是学习一门编程语言，更是学习一种编程哲学。当您深入理解并习惯使用迭代器、代码块和混入等惯用法时，您会发现编写代码成为了一种流畅而愉悦的创造体验。持续阅读优秀的 Ruby 开源项目源码，积极参与社区讨论，将帮助您进一步提升 Ruby 水平。

本文档全面介绍了 Ruby 语言的核心特性和标准用法，适用于初学者入门与开发者日常参考。愿您在 Ruby 的世界里享受编程的乐趣。