---

Ruby 入门指南：从零开始，轻松掌握这门优雅的语言

欢迎来到 Ruby 的世界！如果你正在寻找一门既强大、灵活，又富有表现力和乐趣的编程语言，那么 Ruby 是一个绝佳的选择。它以“程序员的幸福感”为设计核心，语法优雅，社区活跃，被广泛应用于 Web 开发（尤其以 Rails 框架闻名）、脚本编写、自动化任务等领域。

本指南旨在为你提供一个清晰、详细且易于跟随的入门路径。无论你是否有编程经验，都能通过本文了解 Ruby 的基本概念和常用特性，并编写出你的第一个 Ruby 程序。让我们开始这段令人兴奋的旅程吧！

文章目录

1. 认识 Ruby：优雅而强大的语言

   • 什么是 Ruby？
   • Ruby 的设计哲学：让程序员快乐
   • Ruby 有什么用？常见的应用领域
   • 为什么选择 Ruby？它的优点

2. 环境搭建：让你的电脑准备好运行 Ruby

   • 安装 Ruby 的几种方式
   • 在 Windows 上安装 Ruby
   • 在 macOS 上安装 Ruby
   • 在 Linux 上安装 Ruby
   • 验证安装
   • 使用 IRB：交互式 Ruby 环境

3. 你的第一个 Ruby 程序：Hello, World!

   • 编写代码
   • 保存文件
   • 运行程序
   • 理解 puts

4. Ruby 基础：构建代码的积木

   • 变量：存储和引用数据
   • 数据类型：Ruby 支持哪些类型？
     • 数字 (Numbers)：整数和浮点数
     • 字符串 (Strings)：文本的世界
     • 布尔值 (Booleans)：真与假
     • 数组 (Arrays)：有序的集合
     • 哈希 (Hashes)：键值对的字典
     • Nil 和 Symbols：特殊的 Ruby 类型
   • 运算符：进行计算和比较
     • 算术运算符
     • 比较运算符
     • 逻辑运算符
     • 赋值运算符
   • 输入与输出：和你的程序交互
     • puts：输出信息
     • print：另一个输出方法
     • gets：获取用户输入
   • 注释：让你的代码更易懂

5. 控制流程：让程序根据条件做出判断或重复执行

   • If / Else / Elsif：条件判断
   • Case：多重条件判断
   • 循环：重复执行代码块
     • While 循环
     • Until 循环
     • For 循环 (较少使用)
     • Each 迭代器 (常用且强大)
     • Break 和 Next：控制循环流程

6. 方法 (Methods)：组织和重用代码

   • 定义方法
   • 调用方法
   • 方法的参数
   • 方法的返回值
   • 默认参数值
   • 可变数量参数

7. 块 (Blocks) 和迭代器 (Iterators)：Ruby 的特色与强大之处

   • 什么是块？
   • 如何使用块：do...end 或 {}
   • 常见的迭代器：each, map, select 等
   • 块参数 (Block Parameters)

8. 类 (Classes) 和对象 (Objects)：面向对象编程的初探

   • 什么是面向对象编程 (OOP)？
   • 什么是类？什么是对象？
   • 定义一个简单的类
   • 创建对象 (实例化)
   • 初始化方法 (initialize)
   • 实例变量 (Instance Variables)
   • 实例方法 (Instance Methods)
   • 读写属性：attr_reader, attr_writer, attr_accessor

9. Ruby 的生态系统：标准库与 Gems

   • 标准库 (Standard Library)
   • Gems：Ruby 的包管理器
     • 什么是 Gem？
     • 安装 Gem：gem install
     • 使用 Bundler 管理 Gems

10. 下一步：继续学习与实践

    • 官方文档与在线资源
    • 练习编写代码
    • 学习更高级的主题 (模块、Mixin、异常处理等)
    • 探索 Ruby 框架 (Rails, Sinatra)

11. 总结：开启你的 Ruby 之旅

---

1. 认识 Ruby：优雅而强大的语言

什么是 Ruby？

Ruby 是一种开源的、动态的、解释型的通用编程语言。它由日本计算机科学家松本行弘（Yukihiro “Matz” Matsumoto）于 20世纪90年代中期创建。Matz 的目标是创造一门既像 Perl 那样强大，又像 Python 那样优雅，并且完全面向对象的语言。

Ruby 的设计哲学：让程序员快乐

Ruby 最核心的设计理念是“让程序员快乐”（Programmer Happiness）。这意味着 Ruby 的设计优先考虑开发者的舒适度和生产力，而不是一味追求机器效率。它提供简洁、直观的语法，许多任务可以用更少的代码完成，并且鼓励代码的可读性和表达力。在 Ruby 中，你常常会找到不止一种完成任务的方式，这种灵活性也是其吸引力之一。

Ruby 有什么用？常见的应用领域

Ruby 被广泛应用于：

• Web 开发： 这是 Ruby 最知名的应用领域，尤其是结合 Ruby on Rails 框架。Rails 遵循“约定优于配置”（Convention over Configuration）的原则，极大地提高了 Web 应用的开发效率。许多知名网站最初或现在仍在使用 Rails 开发，例如 Twitter (早期), GitHub, Shopify, Airbnb 等。
• 脚本编写和自动化： Ruby 简洁的语法和强大的字符串处理能力使其非常适合编写各种自动化脚本，处理文件、系统任务等。
• 数据分析和处理： 虽然不如 Python 的科学计算库丰富，但 Ruby 也有用于数据处理和分析的 Gem。
• 命令行工具： 许多流行的命令行工具是用 Ruby 编写的。
• 教育： Ruby 优雅易读的语法使其成为学习编程的不错选择。

为什么选择 Ruby？它的优点

• 优雅且富有表现力的语法： 代码写起来像自然语言，易于阅读和理解。
• 纯粹的面向对象： 在 Ruby 中，一切皆对象。这使得理解和使用面向对象的概念变得更加自然和一致。
• 强大的社区和生态系统： 拥有一个活跃的开发者社区，大量的 Gem（第三方库）可以方便地实现各种功能。
• 高开发效率： 尤其是结合 Rails 框架进行 Web 开发时，能极大地加速开发过程。
• 灵活性： Ruby 提供了多种方式来解决问题，允许开发者选择最适合自己风格的方式。

2. 环境搭建：让你的电脑准备好运行 Ruby

开始编写 Ruby 代码之前，你需要先在你的电脑上安装 Ruby 解释器。

安装 Ruby 的几种方式

• 使用系统自带的 Ruby： macOS 和许多 Linux 发行版预装了 Ruby，但这通常是较旧的版本，不推荐用于开发。
• 使用版本管理工具： 推荐的方式，例如 rvm (Ruby Version Manager) 或 rbenv。这些工具可以让你轻松安装、管理和切换不同版本的 Ruby，避免版本冲突。
• 直接下载安装包： 适用于 Windows 系统，RubyInstaller 是官方推荐的方式。

在 Windows 上安装 Ruby

推荐使用 RubyInstaller。

1. 访问 RubyInstaller 官网：https://rubyinstaller.org/downloads/
2. 下载一个最新的 WITH DEVKIT 版本。选择 x64 或 x86 取决于你的系统架构，通常选择 x64。WITH DEVKIT 版本包含了一些必要的工具，用于安装某些需要编译的 Gem。
3. 运行下载的 .exe 安装文件。
4. 在安装向导中：
   • 勾选 “Add Ruby executables to your PATH”（将 Ruby 可执行文件添加到系统路径），这非常重要，否则你无法在命令行中直接运行 ruby 命令。
   • 选择安装位置（通常保持默认即可）。
   • 勾选 “Install MSYS2 development toolchain”（安装 MSYS2 开发工具链），这是 WITH DEVKIT 版本的一部分，后续会提示你安装。
5. 完成基本安装后，会打开一个命令行窗口，提示你运行 ridk install 来安装 MSYS2 工具链。输入 3 并按 Enter 键，然后按 Enter 键确认安装。这会安装编译 Ruby Gem 所需的 C/C++ 编译器等工具。等待安装完成。

在 macOS 上安装 Ruby

macOS 通常自带 Ruby，但版本可能较旧。推荐使用 rbenv 或 rvm。这里以 rbenv 为例：

1. 安装 Homebrew（如果还没安装）：打开终端，运行 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
2. 安装 rbenv 和 ruby-build（ruby-build 是 rbenv 的插件，用于安装不同版本的 Ruby）：在终端运行 brew install rbenv ruby-build
3. 将 rbenv 初始化并添加到你的 shell 配置文件中。终端会给出提示，通常你需要运行：
   • rbenv init
   • 然后按照提示将 eval "$(rbenv init -)" 添加到你的 ~/.zshrc 或 ~/.bash_profile 文件中。保存文件并重启终端或运行 source ~/.zshrc (或对应的文件)。
4. 安装一个 Ruby 版本（例如 3.2.2，可以去 ruby-lang.org 查看最新稳定版）：运行 rbenv install 3.2.2 (数字替换为你想安装的版本号)。
5. 设置全局或局部 Ruby 版本：
   • 全局设置（在任何地方都使用这个版本）：rbenv global 3.2.2
   • 局部设置（只在当前目录及其子目录使用）：进入项目目录，运行 rbenv local 3.2.2
6. 运行 rbenv rehash (有时需要，尤其是在安装新 Gem 后)

在 Linux 上安装 Ruby

类似 macOS，推荐使用 rvm 或 rbenv。这里以 rvm 为例（不同的 Linux 发行版安装方式可能略有不同，请参考 RVM 官网文档）：

1. 安装 RVM：在终端运行 \curl -sSL https://get.rvm.io | bash -s stable
2. 加载 RVM 到你的 shell：运行 source ~/.rvm/scripts/rvm
3. 安装 Ruby 版本（例如 3.2.2）：运行 rvm install 3.2.2
4. 设置默认 Ruby 版本：运行 rvm use 3.2.2 --default

验证安装

无论你使用哪种方式安装，打开新的终端或命令提示符窗口，输入以下命令并按回车：

bash
ruby -v

如果安装成功，你应该能看到类似 ruby 3.2.2 (2023-03-30 revisione a51668eba0) [x64-linux] 的输出，显示你安装的 Ruby 版本信息。

同时验证 Gem 是否可用：

bash
gem -v

Gem 是 Ruby 的包管理器，用于安装第三方库。如果能看到版本号，说明安装成功。

使用 IRB：交互式 Ruby 环境

Ruby 自带一个交互式环境，称为 IRB (Interactive Ruby)。在终端或命令提示符中输入 irb 并按回车即可进入。

bash
irb

你可以在 IRB 中直接输入 Ruby 代码，并立即看到结果。这是一个非常方便的工具，可以用来测试小的代码片段、尝试新的语法或探索对象的属性和方法。

ruby
irb(main):001:0> puts "Hello, IRB!"
Hello, IRB!
=> nil
irb(main):002:0> 1 + 1
=> 2
irb(main):003:0> "Ruby".length
=> 4
irb(main):004:0> exit # 退出 IRB

=> nil, => 2, => 4 是 Ruby 解释器返回的结果。在 IRB 中，每一行代码执行后都会显示其返回值。

3. 你的第一个 Ruby 程序：Hello, World!

按照惯例，我们的第一个程序总是打印 “Hello, World!”。

编写代码

打开一个文本编辑器（如 VS Code, Sublime Text, Atom, Notepad++ 或简单的记事本），输入以下一行代码：

ruby
puts "Hello, World!"

保存文件

将文件保存到你的电脑上，文件扩展名通常是 .rb，表示这是一个 Ruby 源文件。例如，你可以保存为 hello.rb。

运行程序

打开你的终端或命令提示符，导航到你保存 hello.rb 文件的目录。然后输入以下命令并按回车：

bash
ruby hello.rb

理解 puts

puts 是 Ruby 中一个非常常用的方法（Method），用于将内容输出到终端或命令行窗口。puts 是 “put string” 的缩写。它会打印你提供的内容，并在末尾自动添加一个换行符。

4. Ruby 基础：构建代码的积木

现在我们已经能运行简单的 Ruby 程序了，接下来学习 Ruby 的基础概念。

变量：存储和引用数据

变量是用来存储数据并给数据起一个名字的“容器”。在 Ruby 中，声明变量并赋值非常简单：

ruby
name = "Alice"
age = 30
price = 9.99

• 变量名以小写字母或下划线开头。
• 无需预先声明变量的类型（Ruby 是动态类型语言）。
• 使用 = 符号进行赋值。

你可以随时改变变量的值：

“`ruby
greeting = “Hello”
puts greeting # 输出：Hello

greeting = “Hi there”
puts greeting # 输出：Hi there
“`

数据类型：Ruby 支持哪些类型？

Ruby 是一个高度面向对象的语言，这意味着在 Ruby 中，一切都是对象，包括数字、字符串，甚至布尔值。每个对象都属于某个类（Class），拥有自己的属性（数据）和方法（行为）。

以下是 Ruby 中一些基本且常用的数据类型（或者说类）：

数字 (Numbers)

用于表示数值。主要有两种：

• 整数 (Integers): 没有小数部分的数字，如 1, 100, -5。 Ruby 3.1 开始，整数类型统一为 Integer，无需区分 Fixnum 和 Bignum。
• 浮点数 (Floats): 带有小数部分的数字，如 3.14, -0.5, 2.0。

ruby
integer_number = 42
float_number = 3.14159
large_number = 123_456_789_012_345_678 # 可以用下划线增强可读性

字符串 (Strings)

用于表示文本。可以用单引号 ' 或双引号 " 包围。

• 单引号字符串: 字面量，不会解释其中的特殊字符或变量。
• 双引号字符串: 可以解释转义序列（如 \n 表示换行，\t 表示制表符）和进行字符串插值 (String Interpolation)。

“`ruby
single_quoted = ‘这是一个单引号字符串\n不会换行’
double_quoted = “这是一个双引号字符串\n会换行”

puts single_quoted
puts double_quoted

字符串插值（仅双引号有效）

name = “Bob”
message = “你好，#{name}！” # 使用 #{} 将变量的值嵌入字符串中
puts message # 输出：你好，Bob！
“`

字符串有很多有用的方法，比如 .length, .upcase, .downcase, .reverse 等等。

ruby
text = "Ruby Programming"
puts text.length # 输出：16
puts text.upcase # 输出：RUBY PROGRAMMING
puts text.reverse # 输出：gnimmargorP ybuR

布尔值 (Booleans)

表示逻辑上的“真”或“假”。在 Ruby 中只有两个布尔值：true 和 false。

“`ruby
is_student = true
is_retired = false

puts is_student # 输出：true
puts is_retired # 输出：false
“`

Ruby 中只有 false 和 nil 被认为是“假值”（falsy），其他任何值（包括 0, "" 空字符串, [] 空数组, {} 空哈希）都被认为是“真值”（truthy）。

数组 (Arrays)

用于存储有序的、可变长度的元素集合。元素可以是任何类型的对象。数组用方括号 [] 表示，元素之间用逗号 , 分隔。

ruby
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed_array = [1, "hello", true, [4, 5]] # 数组可以包含不同类型的元素，甚至其他数组

• 访问元素： 使用索引访问，索引从 0 开始。

  • fruits[0] # 获取第一个元素 “apple”
  • numbers[4] # 获取第五个元素 5
  • fruits[-1] # 获取最后一个元素 “cherry” (负数索引从后往前数)
  • fruits[0..1] # 获取一个范围的元素 [“apple”, “banana”]

• 修改元素： 通过索引赋值。

  • fruits[1] = "blueberry" # 现在 fruits 是 [“apple”, “blueberry”, “cherry”]

• 添加元素：

  • fruits.push("grape") # 在末尾添加，等同于 fruits << "grape"
  • fruits.unshift("orange") # 在开头添加

• 删除元素：

  • fruits.pop # 删除并返回最后一个元素
  • fruits.shift # 删除并返回第一个元素
  • fruits.delete("apple") # 删除所有值为 “apple” 的元素
  • fruits.delete_at(1) # 删除指定索引的元素

“`ruby
my_list = []
my_list << 1 # 添加 1
my_list << 2 # 添加 2
puts my_list.inspect # inspect 方法会显示对象的内部表示，这里输出 [1, 2]

puts my_list[0] # 输出 1
“`

哈希 (Hashes)

用于存储无序的、键值对 (key-value pairs) 的集合。键和值可以是任何类型的对象。哈希用花括号 {} 表示。

• 传统的哈希语法：键使用 => 连接到值。
• Symbols 作为键： Ruby 1.9 引入了一种更简洁的语法，当键是 Symbol 类型时非常常用。

“`ruby

传统语法

person = { “name” => “Alice”, “age” => 30, “city” => “New York” }

Symbol 键的简洁语法 (更常用)

person_sym = { name: “Bob”, age: 25, city: “London” }
“`

• 访问元素： 使用键访问，键放在方括号 [] 中。

  • person["name"] # 获取值为 “Alice”
  • person_sym[:name] # 获取值为 “Bob” (注意使用 Symbol 键时访问也用 Symbol)

• 添加/修改元素： 通过键赋值。

  • person["job"] = "Engineer" # 添加新键值对或修改已有的值
  • person_sym[:age] = 26 # 修改 age 的值

• 删除元素：

  • person.delete("city") # 删除键为 “city” 的键值对

“`ruby
my_hash = {}
my_hash[“key1”] = “value1”
my_hash[:key2] = “value2” # 使用 Symbol 键

puts my_hash[“key1”] # 输出 value1
puts my_hash[:key2] # 输出 value2
“`

Nil 和 Symbols：特殊的 Ruby 类型

• Nil: 表示“没有值”或“空”。在 Ruby 中，nil 是 NilClass 类的唯一实例。当你引用一个不存在的变量或方法返回空时，通常会得到 nil。
• Symbols: 以冒号 : 开头，后跟一个名称（类似变量名）。例如 :name, :age, :my_symbol. Symbol 表示的是一个“名称”或“标识符”本身，而不是它的值。同一个 Symbol 在内存中只存在一份。Symbol 常用作哈希的键、方法参数、或者表示某种状态。

“`ruby
status = nil # 变量没有值

my_symbol = :status_active
puts my_symbol.class # 输出 Symbol
“`

运算符：进行计算和比较

Ruby 支持常见的运算符。

算术运算符

用于执行数学计算。

• + 加法
• - 减法
• * 乘法
• / 除法 (整数除法会丢弃小数部分，浮点数除法保留小数)
• % 取模 (取余数)
• ** 幂 (指数)

ruby
puts 5 + 3 # 输出 8
puts 10 - 4 # 输出 6
puts 6 * 7 # 输出 42
puts 10 / 2 # 输出 5 (整数除法)
puts 10.0 / 3 # 输出 3.3333333333333335 (浮点数除法)
puts 10 % 3 # 输出 1
puts 2 ** 3 # 输出 8

比较运算符

用于比较两个值，返回布尔值 (true 或 false)。

• == 等于
• != 不等于
• > 大于
• < 小于
• >= 大于等于
• <= 小于等于
• <=> 组合比较运算符：返回 -1 (小于), 0 (等于), 或 1 (大于)

ruby
puts 5 == 5 # 输出 true
puts 5 != 10 # 输出 true
puts 10 > 5 # 输出 true
puts 3 < 7 # 输出 true
puts 5 >= 5 # 输出 true
puts 4 <= 6 # 输出 true
puts 5 <=> 10 # 输出 -1
puts 10 <=> 5 # 输出 1
puts 5 <=> 5 # 输出 0

逻辑运算符

用于组合或修改布尔表达式。

• && (and) 逻辑与：两边都为真时结果为真。
• || (or) 逻辑或：两边至少一个为真时结果为真。
• ! (not) 逻辑非：取反。

Ruby 也支持英文单词形式的逻辑运算符 and, or, not，但通常推荐使用 &&, ||, ! 因为它们的运算符优先级更高。

“`ruby
is_adult = true
has_ticket = false

puts is_adult && has_ticket # 输出 false
puts is_adult || has_ticket # 输出 true
puts !has_ticket # 输出 true
“`

赋值运算符

将值赋给变量。

• = 简单赋值
• +=, -=, *=, /=, %=, **= 复合赋值 (如 x += 1 等同于 x = x + 1)

ruby
x = 10
x += 5 # x 现在是 15
x *= 2 # x 现在是 30
puts x # 输出 30

输入与输出：和你的程序交互

puts：输出信息

前面已经接触过 puts，它用于将内容打印到控制台并换行。

ruby
puts "Hello again!"
puts 123
puts true

print：另一个输出方法

print 类似于 puts，但它不会在末尾添加换行符。

ruby
print "这是第一行，"
print "这是同一行。"
puts "\n下一行开始..." # 使用 \n 手动换行

输出会是：
这是第一行，这是同一行。
下一行开始...

gets：获取用户输入

gets 方法用于从用户那里获取一行输入（从标准输入读取）。它会读取直到用户按下回车键。

ruby
print "请输入你的名字: "
name = gets # 获取用户输入，包含换行符
puts "你好，#{name}!"

重要提示： gets 读取的输入会包含用户输入的末尾换行符 (\n)。通常你需要去掉它。最常用的方法是链式调用 .chomp 方法。

ruby
print "请输入你的名字: "
name = gets.chomp # 获取用户输入并去掉末尾换行符
puts "你好，#{name}！很高兴认识你。"

注释：让你的代码更易懂

注释是写在代码中，但会被解释器忽略的文本。它们用于解释代码的功能、目的或特殊处理，帮助开发者（包括未来的自己）理解代码。

• 单行注释: 以 # 开头。
• 多行注释: 使用 =begin 和 =end 包围。

“`ruby

这是一个单行注释

name = “Alice” # 变量 name 存储用户的名字

=begin
这是一个多行注释块。
通常用于注释掉大段代码或写详细的说明。
=end

puts “程序继续执行”
“`

良好的注释习惯是编写高质量代码的重要组成部分。

5. 控制流程：让程序根据条件做出判断或重复执行

控制流程语句决定了程序执行的顺序。

If / Else / Elsif：条件判断

根据条件是否为真来执行不同的代码块。

“`ruby
age = 18

if age >= 18
puts “你是一个成年人。”
elsif age >= 0 # 可以有零个或多个 elsif
puts “你是一个未成年人。”
else
puts “无效的年龄。” # 条件都不满足时执行 else
end
“`

Ruby 也有简洁的 修饰符形式 (Modifier Form)：

“`ruby
puts “你可以投票。” if age >= 18 # 只有当条件为真时执行前面的语句

还有一个除非 (unless) 语句，与 if 相反

unless 条件 … end 等同于 if !条件 … end

puts “你不能投票。” unless age >= 18
“`

Case：多重条件判断

当有多个可能的相等比较时，case 语句比多个 elsif 更简洁。

“`ruby
score = 85
grade = case score
when 90..100 # 使用范围运算符 ..
“A”
when 80..89
“B”
when 70..79
“C”
when 60..69
“D”
else
“F”
end

puts “你的分数是 #{score}，等级是 #{grade}。”

case 也可以直接比较值

day = “Monday”
case day
when “Monday”
puts “是周一，开始工作！”
when “Friday”
puts “是周五，快到周末了！”
else
puts “是工作日。”
end
“`

循环：重复执行代码块

循环用于重复执行一段代码，直到满足某个条件或遍历完一个集合。

While 循环

当条件为真时，重复执行代码块。

“`ruby
count = 0
while count < 5
puts “Count is: #{count}”
count += 1 # 记得更新条件相关的变量，否则可能导致无限循环
end

输出：

Count is: 0

Count is: 1

Count is: 2

Count is: 3

Count is: 4

“`

Until 循环

当条件为假时，重复执行代码块。与 while 相反。

“`ruby
count = 0
until count >= 5
puts “Count is: #{count}”
count += 1
end

输出同上

“`

while 和 until 也有修饰符形式：

ruby
num = 0
num += 1 while num < 10 # 当 num 小于 10 时，重复执行 num += 1
puts num # 输出 10

For 循环 (较少使用)

Ruby 的 for 循环通常用于遍历一个范围或集合，但在 Ruby 中更常用的是迭代器方法 (如 each)。

“`ruby

遍历范围

for i in 1..5 # 1..5 表示从 1 到 5 的整数范围，包含 5
puts “For loop count: #{i}”
end

输出 1 到 5

遍历数组

fruits = [“apple”, “banana”, “cherry”]
for fruit in fruits
puts “Fruit: #{fruit}”
end

输出每个水果名称

“`

Each 迭代器 (常用且强大)

each 是 Array、Hash、Range 等许多集合对象提供的迭代器方法。它会遍历集合中的每一个元素，并对每个元素执行关联的块 (Block) 代码。

“`ruby

遍历数组

numbers = [1, 2, 3, 4, 5]
numbers.each do |number| # do…end 是块的语法
puts “Number: #{number}”
end

或者使用 {} 的简洁语法，常用语单行块

numbers.each { |number| puts “Number: #{number}” }

输出同上

遍历哈希

person = { name: “Alice”, age: 30 }
person.each do |key, value| # 哈希迭代时块接收键和值
puts “#{key}: #{value}”
end

输出：

name: Alice

age: 30

“`

each 不会改变原始集合，通常用于遍历和执行某种操作。还有其他强大的迭代器，如 map (用于转换集合中的每个元素并返回新集合)、select (用于过滤集合中的元素) 等，这些将在块和迭代器部分更详细介绍。

Break 和 Next：控制循环流程

• break: 立即终止当前循环，跳出循环体，继续执行循环后面的代码。
• next: 跳过当前循环迭代中剩余的代码，进入下一次迭代。

“`ruby
numbers = [1, 2, 3, 4, 5, 6, 7]
numbers.each do |num|
break if num > 5 # 当 num 大于 5 时，停止循环
next if num.even? # 如果 num 是偶数，跳过本次迭代的 puts
puts num
end

输出：

1

3

5

“`

6. 方法 (Methods)：组织和重用代码

方法是封装了一系列操作的代码块，可以重复调用。这有助于组织代码，提高可读性和可维护性。

定义方法

使用 def 关键字定义方法，end 关键字结束方法定义。

“`ruby
def say_hello
puts “Hello!”
end

def greet(name) # 方法可以接受参数
puts “你好，#{name}！”
end

def add(a, b) # 方法可以接受多个参数
result = a + b
return result # 使用 return 指定返回值，通常可以省略
end

def subtract(a, b)
a – b # Ruby 方法的返回值是方法中最后一个表达式的值，return 可以省略
end
“`

调用方法

直接使用方法名和括号（如果需要参数）来调用方法。

“`ruby
say_hello # 调用无参数方法
greet(“Bob”) # 调用带一个参数的方法
sum = add(10, 20) # 调用带多个参数并接收返回值的方法
puts sum # 输出 30

difference = subtract(20, 5)
puts difference # 输出 15
“`

调用方法时，如果方法没有歧义（例如，不是局部变量名），并且没有传递参数，可以省略括号：

ruby
say_hello
greet "Charlie" # 这里的括号省略了

方法的参数

参数是传递给方法的值，方法可以使用这些值进行计算或操作。

“`ruby
def multiply(x, y)
puts “#{x} * #{y} = #{x * y}”
end

multiply(4, 5) # 输出：4 * 5 = 20
“`

方法的返回值

方法执行完毕后，可以返回一个值。在 Ruby 中，方法执行的最后一个表达式的值就是方法的返回值。你可以选择使用 return 关键字明确指定返回值，但通常在返回最后一个表达式的值时会省略 return。

“`ruby
def get_greeting(name)
“Hello, #{name}” # 这是方法中最后一个表达式
end

message = get_greeting(“David”)
puts message # 输出：Hello, David

def check_number(num)
if num > 0
return “Positive” # 使用 return 提前返回
elsif num < 0
return “Negative”
else
“Zero” # 这是最后一个表达式，会被作为返回值
end
end

puts check_number(10) # 输出：Positive
puts check_number(-5) # 输出：Negative
puts check_number(0) # 输出：Zero
“`

默认参数值

可以为方法的参数指定默认值，如果在调用时不提供该参数，将使用默认值。

“`ruby
def greet(name = “World”)
puts “Hello, #{name}!”
end

greet # 调用时不传参数，使用默认值 “World”，输出：Hello, World!
greet(“Ruby”) # 调用时传参数，使用 “Ruby”，输出：Hello, Ruby!
“`

可变数量参数 (Arbitrary Number of Arguments)

使用星号 * 可以让方法接受可变数量的参数，这些参数将作为数组传递给方法。

“`ruby
def sum_all(*numbers) # numbers 将是一个数组
total = 0
numbers.each do |num|
total += num
end
total
end

puts sum_all(1, 2, 3) # 输出 6
puts sum_all(10, 20, 30, 40) # 输出 100
puts sum_all # 输出 0
“`

7. 块 (Blocks) 和迭代器 (Iterators)：Ruby 的特色与强大之处

块是 Ruby 中一个非常独特且强大的特性。它们是一段可以传递给方法的可执行代码。块不是方法的一部分，但可以与方法调用关联。

什么是块？

块是匿名函数，用 do...end 或 {} 包围。它们不能独立存在，必须依附于方法的调用。

“`ruby

{} 形式，常用于单行块

[1, 2, 3].each { |num| puts num * 2 }

do…end 形式，常用于多行块

[1, 2, 3].each do |num|
result = num * 2
puts result
end
“`

如何使用块：do...end 或 {}

两种语法是等效的，但习惯上单行代码使用 {}，多行代码使用 do...end，以增强可读性。

块可以接收参数，这些参数在块变量（用 | 包围）中可用。块变量的名字可以自己定义。

常见的迭代器：each, map, select 等

许多 Ruby 内置的方法，尤其是集合类（如 Array, Hash, Range）的方法，都接受块作为参数，并在集合的每个元素上执行块中的代码。这些方法被称为迭代器。

• each: 遍历集合中的每个元素，对每个元素执行块中的代码。返回原始集合。

  ruby
["a", "b", "c"].each do |letter|
puts "Letter: #{letter}"
end

• map (或 collect): 遍历集合中的每个元素，对每个元素执行块中的代码，并收集块的返回值到一个新数组中返回。

  ruby
numbers = [1, 2, 3]
doubled_numbers = numbers.map do |num|
num * 2
end
puts doubled_numbers.inspect # 输出：[2, 4, 6]

• select (或 filter): 遍历集合中的每个元素，对每个元素执行块中的代码。如果块的返回值是真值，则将该元素收集到一个新数组中返回。

  ruby
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = numbers.select do |num|
num.even? # 返回 true 或 false
end
puts even_numbers.inspect # 输出：[2, 4, 6]

• reduce (或 inject): 将集合中的元素累加或组合成一个单一的值。

  “`ruby
  numbers = [1, 2, 3, 4]
  sum = numbers.reduce(0) do |accumulator, current_number| # accumulator 是累加器，current_number 是当前元素
  accumulator + current_number
  end
  puts sum # 输出 10

  也可以用于字符串连接等

  words = [“hello”, ” “, “world”]
  sentence = words.reduce(“”) { |acc, word| acc + word }
  puts sentence # 输出 “hello world”
  “`

块参数 (Block Parameters)

块变量 (|...| 中的变量) 是用来接收方法传递给块的数据。

“`ruby

Array 的 each 方法传递单个元素给块

[1, 2, 3].each { |element| puts element }

Hash 的 each 方法传递键和值作为两个参数给块

{ a: 1, b: 2 }.each { |key, value| puts “#{key} is #{value}” }

Range 的 step 方法传递当前值给块

(1..10).step(2) { |num| puts num } # 输出 1, 3, 5, 7, 9
“`

理解和熟练使用块及迭代器是掌握 Ruby 的关键一步。

8. 类 (Classes) 和对象 (Objects)：面向对象编程的初探

Ruby 是一门纯粹的面向对象编程 (OOP) 语言。这意味着一切都是对象，每个对象都属于某个类。

什么是面向对象编程 (OOP)？

OOP 是一种编程范式，它将程序组织成对象的集合，每个对象都是某个类的实例。对象封装了数据（属性）和操作数据的方法（行为）。OOP 的核心概念包括：

• 封装 (Encapsulation): 将数据和操作数据的方法捆绑在一起，隐藏内部实现细节。
• 继承 (Inheritance): 允许一个类继承另一个类的属性和方法，实现代码重用。
• 多态 (Polymorphism): 允许不同类的对象对同一消息做出不同的响应。

在本入门指南中，我们将重点介绍类和对象的基础。

什么是类？什么是对象？

• 类 (Class): 是一种蓝图或模板，定义了一类对象的共同属性和行为。例如，String 类定义了所有字符串对象（如 "hello", "world"）的共同特性（如长度、包含哪些字符）和行为（如转大写、查找子串）。
• 对象 (Object): 是类的一个具体实例。例如，"hello" 是 String 类的一个对象，10 是 Integer 类的一个对象。

定义一个简单的类

使用 class 关键字定义类，类名通常以大写字母开头。

ruby
class Dog
# 类的定义放在这里
end

创建对象 (实例化)

使用类名后跟 .new 来创建一个新的对象，这个过程称为实例化。

ruby
my_dog = Dog.new # 创建 Dog 类的一个新对象
your_dog = Dog.new # 创建另一个 Dog 对象

初始化方法 (initialize)

initialize 是一个特殊的方法，当使用 .new 创建对象时，它会自动被调用。它通常用于设置新创建对象的初始状态（属性）。

“`ruby
class Dog
def initialize(name, breed)
@name = name # @name 是一个实例变量
@breed = breed
puts “一只新狗狗被创建了！它的名字是 #{@name}，品种是 #{@breed}。”
end
end

my_dog = Dog.new(“旺财”, “拉布拉多”)
your_dog = Dog.new(“小七”, “萨摩耶”)
“`

实例变量 (Instance Variables)

实例变量属于对象的个体，每个对象都有自己独立的实例变量值。实例变量以 @ 符号开头。

“`ruby
class Dog
def initialize(name)
@name = name # @name 是实例变量
end

def get_name
@name # 方法可以访问实例变量
end
end

dog1 = Dog.new(“小白”)
dog2 = Dog.new(“小黑”)

puts dog1.get_name # 输出：小白
puts dog2.get_name # 输出：小黑
“`

实例方法 (Instance Methods)

实例方法定义了对象可以执行的行为。它们在类中使用 def 关键字定义，并且可以访问该对象的实例变量。

“`ruby
class Dog
def initialize(name, breed)
@name = name
@breed = breed
end

def bark # 实例方法
puts “汪！汪！我是 #{@name}！”
end

def display_info # 另一个实例方法
puts “名字：#{@name}，品种：#{@breed}”
end
end

my_dog = Dog.new(“阿黄”, “金毛”)
my_dog.bark # 调用实例方法 bark
my_dog.display_info # 调用实例方法 display_info
“`

读写属性：attr_reader, attr_writer, attr_accessor

默认情况下，对象的实例变量 @name 或 @breed 是不能直接从对象外部访问的。

ruby
puts my_dog.@name # 会出错！不能直接访问实例变量

为了让外部代码能够读取或写入实例变量，我们需要定义相应的访问方法。

• 读方法 (Getter): 用于获取实例变量的值。
• 写方法 (Setter): 用于设置实例变量的值。

“`ruby
class Dog
def initialize(name)
@name = name
end

# 手动定义读方法
def name
@name
end

# 手动定义写方法
def name=(new_name) # 注意方法名末尾的 = 号
@name = new_name
end
end

dog = Dog.new(“Buddy”)
puts dog.name # 调用读方法，输出 Buddy
dog.name = “Lucky” # 调用写方法 (语法上看起来像赋值)
puts dog.name # 输出 Lucky
“`

手动定义读写方法很常见，但 Ruby 提供了更简洁的方式：attr_reader, attr_writer, attr_accessor。这些是 Module 类中的方法，通常在类定义中使用，它们会为你自动创建读/写方法。

• attr_reader :attribute_name: 创建一个名为 attribute_name 的读方法。
• attr_writer :attribute_name: 创建一个名为 attribute_name= 的写方法。
• attr_accessor :attribute_name: 同时创建读方法和写方法 (attr_reader + attr_writer)。

使用 Symbol 来指定属性名。

“`ruby
class Dog
attr_accessor :name, :breed # 同时创建 name 和 breed 的读写方法

def initialize(name, breed)
@name = name
@breed = breed
end

def bark
puts “汪！汪！我是 #{@name}！”
end
end

my_dog = Dog.new(“豆豆”, “泰迪”)
puts my_dog.name # 调用自动生成的 name 读方法，输出 豆豆
my_dog.breed = “贵宾犬” # 调用自动生成的 breed 写方法
puts my_dog.breed # 调用自动生成的 breed 读方法，输出 贵宾犬
“`

面向对象是 Ruby 的核心，深入理解类和对象对于编写更复杂、更结构化的 Ruby 代码至关重要。

9. Ruby 的生态系统：标准库与 Gems

Ruby 语言本身提供了一套非常丰富的内置功能，这部分被称为标准库。此外，Ruby 还有一个庞大且活跃的第三方库生态系统，这些库被称为 Gems。

标准库 (Standard Library)

Ruby 安装包自带了许多有用的模块和类，无需额外安装即可使用。例如：

• Math: 提供数学函数，如 Math.sqrt, Math::PI。
• Array, Hash, String, Integer, Float 等核心类：它们的方法（如 .length, .each, [] 等）构成了 Ruby 的核心功能。
• File, Dir: 用于文件和目录操作。
• Time, Date: 处理时间和日期。
• Net::HTTP: 进行 HTTP 请求。
• JSON: 处理 JSON 数据。

你可以通过 Ruby 官方文档查找标准库的详细信息。

Gems：Ruby 的包管理器

什么是 Gem？

Gem 是打包 Ruby 代码的一种方式，包含了库文件、可执行文件、文档等。它们通过 RubyGems 包管理系统进行分发和安装。rubygems.org 是官方的 Gem 仓库，你可以找到成千上万个开源 Gem。

安装 Gem：gem install

使用 gem 命令行工具来安装 Gem。

bash
gem install gem_name # 安装最新版本的 gem_name
gem install gem_name --version 1.2.3 # 安装指定版本

安装后，你就可以在 Ruby 代码中使用这个 Gem 提供的功能了。通常需要使用 require 关键字来加载 Gem。

“`ruby

假设你安装了 json gem (标准库自带，但作为例子)

gem install json # 如果需要的话

require ‘json’ # 加载 json gem

data = { name: “Alice”, age: 30 }
json_string = JSON.generate(data)
puts json_string # 输出: {“name”:”Alice”,”age”:30}
“`

使用 Bundler 管理 Gems

对于实际项目，特别是 Web 应用，往往会依赖很多 Gems，而且不同项目可能依赖同一 Gem 的不同版本。手动管理这些依赖非常困难。Bundler 是一个强大的依赖管理工具，它可以帮助你：

• 声明项目所需的所有 Gem 及其版本。
• 确保所有团队成员和部署环境使用完全相同的 Gem 版本。
• 避免 Gem 版本冲突。

要使用 Bundler，你需要在项目根目录下创建一个名为 Gemfile 的文件，列出你的项目依赖。

“`ruby

Gemfile 示例

source ‘https://rubygems.org’ # 从哪个源获取 Gems

gem ‘rails’, ‘~> 7.0.0’ # 声明依赖 rails gem，版本要求大于等于 7.0.0 且小于 7.1
gem ‘pry’ # 声明依赖 pry gem (一个增强的 IRB 工具)
gem ‘json’ # 声明依赖 json gem
“`

然后在终端进入项目目录，运行：

bash
gem install bundler # 如果还没安装 Bundler
bundle install # 读取 Gemfile，安装所有声明的 Gems

bundle install 会创建一个 Gemfile.lock 文件，精确记录了安装的每个 Gem 的版本及其依赖关系。下次运行 bundle install 时，Bundler 会根据 Gemfile.lock 来确保安装的是相同版本。

在使用了 Bundler 的项目中，运行 Ruby 程序或命令时通常使用 bundle exec 前缀，以确保程序运行在 Bundler 管理的环境中，可以使用项目中声明的 Gems。

bash
bundle exec ruby your_script.rb

或者在 Rails 项目中：

bash
bundle exec rails server

10. 下一步：继续学习与实践

恭喜你！你已经迈出了 Ruby 编程的第一步，掌握了基本语法、数据类型、控制流程、方法、块和面向对象的基础。但这仅仅是开始，编程是一个持续学习和实践的过程。

官方文档与在线资源

• Ruby 官方网站 (ruby-lang.org): 提供了最新的 Ruby 新闻、下载链接、文档和教程。
• Ruby API Documentation: 学习 Ruby 内置类和方法的最佳资源。可以在 doc.ruby-lang.org 找到。
• RubyGems.org: 查找和了解各种 Gems。
• 在线教程平台: 如 Codecademy, freeCodeCamp, exercism.io (提供大量编程练习), Coursera, Udemy 等都有 Ruby 相关课程。
• 书籍: 《Programming Ruby》（俗称 Pickaxe book）、《Practical Object-Oriented Design in Ruby》等都是 Ruby 领域的经典著作。

练习编写代码

实践是最好的老师。 尝试用 Ruby 解决一些小问题：

• 编写一个计算器程序。
• 写一个猜数字游戏。
• 处理文本文件（读取、写入、分析）。
• 从网上抓取一些数据（使用 Net::HTTP 或更高级的 Gem）。
• 用类来模拟现实世界的对象（如 Book, Car, Student）。

学习更高级的主题

Ruby 还有许多更高级的特性值得学习，例如：

• 模块 (Modules) 和 Mixin: 实现代码复用，解决多重继承问题。
• 异常处理 (Exception Handling): 使用 begin, rescue, ensure 处理错误。
• 文件 I/O: 更详细的文件读写操作。
• 正则表达式 (Regular Expressions): 强大的文本匹配工具。
• 测试 (Testing): 学习如何为你的代码编写自动化测试（如使用 MiniTest 或 RSpec）。
• 元编程 (Metaprogramming): 在运行时修改或生成代码（Ruby 的强大之处之一）。

探索 Ruby 框架

当你对 Ruby 语言本身有了较好的掌握后，可以开始探索 Ruby 的应用框架。

• Ruby on Rails: 最流行的 Ruby Web 框架，非常适合快速开发 Web 应用。
• Sinatra: 一个轻量级的 Web 框架，适合构建简单的 Web 服务或 API。

学习一个框架能让你了解 Ruby 如何应用于实际项目中，并接触更广泛的工具和模式。

11. 总结：开启你的 Ruby 之旅

从安装环境，到编写第一个程序，再到理解变量、数据类型、控制流程、方法、块和面向对象的基础，你已经掌握了 Ruby 的核心要素。Ruby 的优雅语法和强大功能将为你的编程之旅带来很多乐趣。

记住，“程序员的幸福感”是 Ruby 的核心价值。享受编写 Ruby 代码的过程吧！保持好奇心，不断学习，多加实践，你会在 Ruby 的世界中越走越远。

祝你学习顺利，编码愉快！

---