Ruby 常用方法速查指南:String、Array 与类型转换方法全解析(A-to-Z-Resources-for-Students)

原创2026-09-30 13:25:361,707 阅读
文章标签:知识库教程教育

Ruby 常用方法速查指南:String、Array 与类型转换方法全解析(A-to-Z-Resources-for-Students)

本篇技术指南以本仓库 CheatSheet/Ruby-CheatSheet.md 为核心骨架,系统梳理 Ruby 中最常用的 String 方法、子串操作、Number 方法、Array 方法与类型转换函数,并结合可变方法(bang 方法)与不可变方法的差异展开深入讲解。读完本文,你将掌握 Ruby 日常编码中最高频的内置方法清单、各方法的返回值行为与边界细节,并能在不查阅文档的情况下快速写出正确的字符串与数组操作代码。


一、开篇:理解 Ruby 方法的两大核心行为

在逐条查看速查表之前,必须先建立两个 Ruby 方法行为的底层认知,否则很容易写出与预期不符的代码。

1. 非破坏性方法(返回新对象)与破坏性方法(bang 方法)

Ruby 速查表开篇就强调了一个关键原则:

A new string is returned, unless a bang (!) is added after the method (for example, .split!) which mutates the original string.

也就是说,绝大多数字符串/数组方法默认返回一个新对象,原对象保持不变;只有当方法名带有 ! 后缀(如 gsub!、split!)时,才会原地修改调用它的原始对象。例如:

str = "  Hello  "
str.strip      # => "Hello",原 str 仍是 "  Hello  "
str.strip!     # => "Hello",此时 str 已被原地修改为 "Hello"

这是一条贯穿整个速查表的行为主线:读表时,凡是带 ! 的方法,都要意识到它对原对象的"破坏性"副作用。

2. 返回值的多样性

Ruby 方法并非全部返回"处理后的结果",部分方法返回布尔值(true/false,如 include?、is_a?),部分方法返回被移除的元素本身(如 pop、shift),理解每个方法的返回值类型,是正确串联方法调用链的前提。


二、String 方法速查与详解

下表完整继承了原速查表的所有字符串方法,并补充了每个方法的返回类型与使用注意点。

方法 功能 返回值
.strip 移除字符串首尾的空白字符 新字符串
.chomp 仅当字符串末尾是回车符或换行符时移除最后一个字符 新字符串
.upcase 将字符串中所有字符转为大写 新字符串
.downcase 将字符串中所有字符转为小写 新字符串
.class 返回对象的类名 Class
.object_id 返回对象的整数标识符 Integer
.length 返回字符串中的字符个数(包含空白字符) Integer
.count 统计某个字符在字符串中出现的次数 Integer
.insert 在指定索引之前插入一段字符串 新字符串
.capitalize 首字母大写、其余字母小写 新字符串
.reverse 反转字符串中字符的顺序 新字符串
.split 将字符串按分隔符拆分成数组 Array
.chop 移除字符串的最后一个字符(无论是否为换行符) 新字符串
.pop 移除并返回字符串中的最后一个字符 String
.include?("STR") 判断字符串是否包含指定子串 Boolean
.index("STR") 返回指定子串首次出现的起始索引 Integer / nil
to_s 将数据类型转换为字符串 String
to_i 将数据类型转换为整数 Integer
to_f 将数据类型转换为浮点数 Float
to_sym 将数据类型转换为符号(Symbol) Symbol
<< 字符串拼接(原地追加) 原字符串
.each_char 逐字符遍历字符串(返回枚举器) Enumerator
.gsub 全局替换字符串中的指定文本 新字符串

重点方法逐条说明

.strip / .chomp / .chop —— 三种"去字符"方式的差别

  • .strip 只清理字符串首尾的空白(空格、制表符、换行),中间空白不受影响;
  • .chomp 只在字符串**末尾恰好是回车(\r)或换行(\n)**时才删除这一个字符,常用于读取文件行后去掉行尾换行;
  • .chop 则无条件删除最后一个字符(包括普通字符),例如 "Batman".chop # => "Batma"。
"  hi  ".strip   # => "hi"
"hi\n".chomp     # => "hi"
"hi\n".chop      # => "hi"
"hi!".chop       # => "hi"

.count 与 .length 的区别

.length 返回字符总数(含空白),而 .count 用于统计特定字符的出现次数:

"HELLO".length      # => 5
"HELLO".count('L')  # => 2

.insert —— 按索引插入

"Hello".insert(3, "hi5") 表示在索引 3 处插入 "hi5",结果得到 "Helhi5lo"(索引 3 原本对应字符 l,插入后该字符及其之后的内容整体后移)。

.split —— 拆分机制

默认按空白字符拆分;传入不同分隔符可改变拆分粒度:

"a b c".split            # => ["a", "b", "c"](按空白拆分)
"hello".split("")        # => ["h", "e", "l", "l", "o"](按字符拆分)
"one two".split(" ")     # => ["one", "two"](按单词/空格拆分)

.pop 用于字符串时的行为

对字符串调用 .pop 会移除并返回最后一个字符,例如 "Linda".pop 返回 "a"——注意这与 Array 的 .pop 语义一致,但属于速查表列出的字符串用法。

.include? 与 .index —— 子串检测

  • .include?("STRING") 返回布尔值,判断某子串是否存在于原字符串中;
  • .index("STRING") 返回该子串首次出现位置的起始索引,找不到时返回 nil。
"hello world".include?("world")  # => true
"hello world".index("world")     # => 6

<< 拼接的"陷阱"

<< 是原地拼接操作,直接修改调用它的字符串对象本身(等价于带 bang 的破坏性操作),而 + 拼接返回新字符串。若后续代码依赖原字符串不变,务必区分二者。

.gsub 全局替换

替换字符串中所有匹配的文本,而非只替换第一处:

string = "We have many dogs"
string.gsub("dogs", "cats")   # => "We have many cats"

.capitalize 与 .capitalise 的拼写说明

速查表中写的是英式拼写 .capitalise,而 Ruby 官方方法名是美式拼写 .capitalize。实际调用请使用 .capitalize:

"hELLO".capitalize   # => "Hello"

三、子串(Sub-String)操作与 Range 用法

原速查表用 string = "abc123" 作为基准串,给出了三类子串操作范式:

1. 索引 + 长度切片

string = "abc123"
string[3, 3]   # => "123",x=起始索引,y=取几个字符

string[x, y] 的语义是:从索引 x 开始,向后取 y 个字符。

2. Range 切片(含端点)

string[0..-2]   # 从索引 0 到倒数第 2 个字符(含端点)

Ruby 支持负数索引,-1 表示最后一个字符、-2 表示倒数第二个。0..-2 即"从开头到倒数第二个字符(含)",注意 Range 的 .. 是闭区间(包含结束端点),而 ... 是开区间(不包含结束端点)。

"abc123"[0..-2]   # => "abc12"
"abc123"[0...-2]  # => "abc1"

3. Range 生成序列并转数组

(1..10).to_a      # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
('A'..'Z').to_a   # => ["A", "B", "C", "D", "E", "F", ...](字母表全集)

Range 结合 .to_a 是生成等差数列或字母序列的惯用技巧,在批量生成测试数据、构造循环区间时非常实用。


四、Number 方法速查

方法 功能 示例
.abs 返回整数/浮点数的绝对值 -3.abs # => 3
.round 将浮点数四舍五入到指定小数位(默认 0 位) 3.14159.round(2) # => 3.14
(-7.8).abs        # => 7.8
3.14159.round     # => 3
3.14159.round(2)  # => 3.14

注意 .round 的默认精度为 0,即四舍五入到整数;传入参数 n 时保留 n 位小数。


五、Array 方法速查与详解

数组操作是 Ruby 日常编码的重头戏,原速查表完整列出了如下方法:

方法 功能 是否破坏原数组
.join 将数组元素拼接为单个字符串,可传入分隔符 否
.length 统计数组元素个数 否
.first 访问数组第一个元素 否
.last 访问数组最后一个元素 否
.take(n) 返回前 n 个元素组成的新数组 否
.drop(n) 返回去掉前 n 个元素后剩下的数组 否
.pop 永久移除最后一个元素并返回它 是
.shift 永久移除第一个元素并返回它 是
.push 在数组末尾追加元素 是
.unshift 在数组开头追加元素 是
.delete 永久删除数组中指定的元素 是
.delete_at 按索引永久删除元素 是
.reverse 反转数组顺序(不修改原数组) 否
.select 遍历数组,返回使条件为真的元素组成的新数组 否
.is_a? 检查对象的类类型(如 Integer) 否

关键行为演示

.join —— 数组转字符串

["a", "b", "c"].join        # => "abc"
["a", "b", "c"].join(", ")  # => "a, b, c"

.take 与 .drop —— 非破坏性的头部/尾部截取

arr = [0, 1, 2, 3, 4]
arr.take(3)   # => [0, 1, 2](原数组不变)
arr.drop(3)   # => [3, 4](原数组不变)

.pop / .shift / .push / .unshift —— 栈与队列操作

这四个方法模拟了数据结构中栈(Stack)与队列(Queue)的经典操作,且都会原地修改数组:

arr = [0, 1, 2, 3, 4]
arr.push(99)      # => [0, 1, 2, 3, 4, 99],末尾追加
arr.pop           # => 99(返回被移除的元素),arr 变为 [0, 1, 2, 3, 4]
arr.shift         # => 0(返回被移除的元素),arr 变为 [1, 2, 3, 4]
arr.unshift(1)    # => [1, 1, 2, 3, 4],开头插入

.delete 与 .delete_at —— 按值删除与按下标删除

arr = [1, 2, 2, 3]
arr.delete(2)      # => 2,删除所有等于 2 的元素,arr 变为 [1, 3]
arr.delete_at(0)   # => 1,删除索引 0 处的元素,arr 变为 [3]

.select —— 条件筛选(迭代 + 过滤)

.select 遍历数组并将"条件返回真"的元素收集成新数组,是函数式编程风格的过滤利器:

[1, 2, 3, 4, 5].select { |n| n.even? }   # => [2, 4]

.is_a? —— 类型检查

.is_a? 用于判断对象是否属于某个类(含继承关系),常配合迭代器做类型过滤:

[1, "a", 2.5].select { |e| e.is_a? Integer }   # => [1]

.reverse 的非破坏性提醒

数组的 .reverse 与字符串的 .reverse 一样默认不修改原数组,如需原地反转应使用 reverse!——再次印证开篇"bang 方法"原则。


六、类型转换(Conversion)函数总览

原速查表末尾专门整理了 Ruby 中一组高频转换函数,用于在不同数据类型之间切换:

方法 功能
.to_i 转换为整数(Integer)
.to_f 转换为浮点数(Float)
.to_s 转换为字符串(String)
.to_sym 转换为符号(Symbol)
.to_a 转换为数组(Array)
"42".to_i        # => 42
"3.14".to_f      # => 3.14
123.to_s         # => "123"
"name".to_sym    # => :name
(1..3).to_a      # => [1, 2, 3]

实际使用提示:to_i 遇到无法解析的内容(如 "abc".to_i)时返回 0 而不会抛异常;to_sym 常用于把用户输入或字符串键转换为更高效、可比较的 Symbol 键(如哈希键、send 动态调用方法名)。在需要接收命令行参数或外部输入并参与数值运算的场景中,to_i / to_f 是最常用的显式类型收窄手段。


七、实战速查:把这些方法组合起来

将上述方法串联使用,可以快速完成典型的文本清洗与数据处理任务:

# 需求:从原始文本中提取所有数字并求和
raw = "订单号: 1001, 数量: 3, 单价: 59.9"
nums = raw.split(",").map { |part| part.split(":").last.strip.to_f }
# => [1001.0, 3.0, 59.9]

# 需求:数组去重、排序并拼接为字符串
[3, 1, 2, 1].uniq.sort.join("-")    # => "1-2-3"

# 需求:判断字符串是否以某个子串开头/结尾
"hello.rb".include?(".rb")          # => true
"hello.rb".end_with?(".rb")         # => true(end_with? 为同类常用方法)

八、如何在当前仓库中继续学习 Ruby

本速查表位于仓库的 CheatSheet 目录 下,与之并列的还有 C 语言、数据结构、Docker、Git、Vim 等主题的速查表,可对照学习。仓库主文档 README.md 在"Programming Languages & Frameworks"部分专门整理了 Ruby 学习资源(如 Ruby on Rails Tutorial、Learn Ruby The Hard Way、Ruby Tapas 等),适合在掌握本文基础方法后进一步深入。此外,仓库的 Python/Python.md 与 Node.JS/Nodejs.md 等文档也采用同类速查风格,便于跨语言对比方法命名与行为差异。

最后提醒:本速查表面向 Ruby 日常高频操作,使用前请确认你的运行环境已安装 Ruby(可通过 ruby -v 验证)。表中个别方法的拼写(如 capitalise)与官方命名(capitalize)存在差异,实际编码时以官方 API 为准;所有示例均可在任意 Ruby 交互环境(irb)中直接验证。

登录后查看全文
awesome-ai-engineering