Ruby类型转换本质：语义重建而非强制转型

1. 项目概述：Ruby数据类型转换不是“强制转型”，而是“语义重建”

你刚在终端里敲下ruby -v，发现系统自带的 Ruby 版本是 2.6.3，而某个新 gem 报错说failed to convert string value 'unified_test_platform' to an enum value of type——这根本不是语法错误，而是 Ruby 在告诉你：“你给我的这个字符串，它在当前上下文里没有明确的业务含义。” 类似地，当你看到failed to convert property value of type 'java.lang.string' to required type这种混杂 Java 术语的报错（常见于 JRuby 或 Rails 与 Java 服务集成场景），本质也是类型语义链断裂。Ruby 本身没有 C 那样的强制类型转换（cast），它只有显式、有语义、可预测的类型转换方法。所谓“convert data types in Ruby”，核心不是把内存里的字节强行 reinterpret，而是用一套高度约定俗成的方法，把一个对象“翻译”成另一个对象，同时确保这个翻译过程在业务逻辑上站得住脚。比如"123".to_i不是“把字符串变成整数”，而是“把代表十进制整数的文字描述，解析为对应的整数值”；而"123".to_f则是“把同一段文字，按浮点数规则解析”。这种设计让 Ruby 的类型转换天然具备容错性（"abc".to_i返回 0）、可读性（方法名直白）和业务友好性（.to_sym把字符串转为符号，用于哈希键或方法名，语义清晰）。它适合所有正在写 Rails 控制器参数处理、解析 CSV 文件、对接 API JSON 响应、或者调试老系统中roborock ruby这类嵌入式 Ruby 脚本的开发者。无论你是刚学完puts "hello"的新手，还是需要在 macOS 上解决failed to upgrade homebrew portable ruby!后遗留的字符串解析问题的资深运维，理解这套转换逻辑，就是掌握 Ruby 世界里“沟通”的基本语法。

2. 核心思路拆解：为什么 Ruby 不提供(int)str，而坚持.to_i？

2.1 Ruby 的哲学根基：对象即行为，而非内存布局

C 语言的(int)str是一种底层操作：它假设你清楚知道str指针指向的内存前几个字节是什么，并命令 CPU 将其解释为整数。Ruby 完全不关心内存。在 Ruby 里，"123"是一个String对象，它内部封装了字符数组、编码信息、长度缓存等，但你永远无法通过&"123"获取它的地址。因此，任何“强制转换”都毫无意义。Ruby 的设计者 Matz 明确说过：“I wanted a language that was more like natural language, where you ask an object to do something, rather than telling the machine what to do.” 所以，"123".to_i的本质是向字符串对象发送一条消息：“请根据你的内容，生成一个整数对象”，而字符串对象内部早已定义好响应逻辑：跳过空白，识别正负号，逐位解析数字，遇到非数字字符就停止。这个过程是对象自治的、语义完整的、可被重写的。你可以给自己的类定义to_i方法，让它返回任何你认为合理的整数值。这正是 Ruby 的强大之处——类型转换不是编译器的魔法，而是你代码里可读、可测、可调试的普通方法调用。

2.2 两种转换路径：to_*与Kernel.*，它们解决的是不同问题

初学者常困惑："123".to_i和Integer("123")有什么区别？答案是：前者是宽松的、容错的、面向用户输入的转换；后者是严格的、精确的、面向程序逻辑的解析。"123abc".to_i返回123，它默默忽略了后面无法解析的部分；而Integer("123abc")会直接抛出ArgumentError: invalid value for Integer(): "123abc"。这背后是 Ruby 对不同使用场景的精准划分：

• to_*系列（.to_i,.to_f,.to_s,.to_a,.to_h）：设计初衷是处理“可能不干净”的外部数据，比如表单提交、日志行、配置文件。它们必须返回一个值（哪怕默认值），不能让整个流程因一个坏数据而崩溃。"abc".to_i返回0，"abc".to_f返回0.0，nil.to_s返回""，这种“兜底”行为是 Ruby 的仁慈。
• Kernel.*系列（Integer(),Float(),Array(),Hash()）：设计初衷是进行确定性的、无歧义的数据构造。它们要求输入必须完全符合预期格式，否则就报错。这让你能清晰地捕获数据质量问题。例如，在解析一个严格定义的 CSV 文件时，你应该用Integer(row[0])，因为如果第一列不是纯数字，说明数据源本身就有问题，必须立刻中断并告警，而不是默默返回0掩盖真相。

提示：Kernel.*方法还有一个关键特性——它们支持进制指定。Integer("1010", 2)返回10（二进制），Integer("FF", 16)返回255（十六进制），而"1010".to_i(2)也能做到，但to_i的进制参数是 Ruby 1.9+ 才加入的，且语义上不如Integer(str, base)直观。对于需要处理十六进制颜色码、二进制传感器数据（如某些roborock ruby脚本中解析硬件寄存器）的场景，Integer(str, 16)是更安全、更明确的选择。

2.3 字符串到符号（.to_sym）：为什么它如此特殊？

"user_name".to_sym返回:user_name，这个操作看似简单，却触及 Ruby 的核心机制——符号（Symbol）是不可变的、唯一的、内存高效的字符串标识符。它不是“把字符串变成另一个字符串”，而是“为这段文本创建一个全局唯一的、轻量级的引用”。每次调用"user_name".to_sym，Ruby 都会检查符号表，如果:user_name已存在，就直接返回它的引用；如果不存在，就创建一个新的符号对象并存入表中。这意味着符号比较是 O(1) 的指针比较，而字符串比较是 O(n) 的逐字符比对。在哈希键、方法名、状态枚举中大量使用符号，是 Ruby 性能优化的基石。这也是为什么你在 Rails 的params或config中总看到:id,:name——它们不是随意的命名习惯，而是经过深思熟虑的性能与语义选择。roborock ruby这类嵌入式脚本尤其依赖符号，因为它们运行在资源受限的设备上，减少内存分配和字符串拷贝至关重要。

3. 核心细节与实操要点：从to_i到to_h，每个方法的“潜规则”

3.1 数字转换：.to_i、.to_f、Integer()、Float()的实战边界

"123".to_i返回123，这是最基础的用法。但真实世界远比这复杂。我们来拆解几个典型场景：

场景一：处理带单位的用户输入

# 用户可能输入 "123kg", "45.6 lbs", "78g" weight_input = "123kg" # 错误做法：weight_input.to_i => 123 (侥幸成功，但逻辑脆弱) # 正确做法：先提取数字部分，再转换 numeric_part = weight_input.match?(/^-?\d+\.?\d*/) ? weight_input.scan(/-?\d+\.?\d*/).first : nil weight_value = numeric_part ? Float(numeric_part) : nil # 使用 Float() 保证精度

这里的关键是：.to_i和.to_f的“宽容”是双刃剑。它们会静默吞掉所有非数字字符，导致你丢失了“用户到底输入了什么”的上下文。在需要验证输入合法性的场景（如 Web 表单），应该先用正则提取，再用Integer()或Float()进行严格解析。

场景二：解析十六进制或二进制数据

# 从传感器读取的原始数据可能是十六进制字符串 hex_data = "aF12" # 直接 .to_i(16) 是可行的，但更推荐 Kernel.Integer decimal_value = Integer(hex_data, 16) # => 44818 # 如果 hex_data 可能包含 "0x" 前缀，Integer() 会自动处理 Integer("0xAf12", 16) # => 44818，同样有效 # 而 "0xAf12".to_i(16) 会失败，因为它不认识 "0x" 前缀

Integer(str, base)能智能识别0x、0b、0o等前缀，而.to_i(base)则要求字符串必须是纯数字字符。在处理roborock ruby脚本中常见的硬件寄存器值（如0xFF00）时，Integer()是更鲁棒的选择。

场景三：处理科学计数法与无穷大

"1.23e4".to_f # => 12300.0 "inf".to_f # => Infinity "-inf".to_f # => -Infinity "nan".to_f # => NaN # 但 Float() 对这些特殊值更严格 Float("inf") # => Infinity Float("1.23e4") # => 12300.0 Float("nan") # => NaN Float("abc") # => ArgumentError: invalid value for Float(): "abc"

.to_f对inf/nan的宽容，有时是便利，有时是陷阱。如果你的业务逻辑中NaN是一个有效状态（如表示缺失的传感器读数），那么.to_f是合适的；但如果NaN意味着数据污染，就必须用Float()并捕获异常。

注意：to_i和to_f在遇到空字符串""时，行为不一致。"".to_i返回0，而"".to_f返回0.0。这看起来合理，但"\n\t ".to_i也返回0（因为to_i会跳过空白），而"\n\t ".to_f返回0.0。这种“静默成功”在调试时极易掩盖问题。我踩过的坑是：一个 CSV 解析脚本，某列本该是数字，但因 Excel 导出时多了一个不可见的 Unicode 空格，to_i返回了0，导致后续计算全部错误，花了半天才定位到源头。从此，我的原则是：只要数据来源不可信，就优先用Integer()/Float()，并用rescue显式处理错误。

3.2 字符串转换：.to_s、String()、inspect与to_json的语义鸿沟

123.to_s返回"123"，这很直观。但nil.to_s返回""，[1,2,3].to_s返回"[1, 2, 3]"，Time.now.to_s返回"2023-10-05 14:23:45 +0800"。.to_s的核心语义是：“给我一个人类可读的、简洁的字符串表示”。它不保证可逆，也不保证格式统一。String(123)的行为与123.to_s完全相同，它是Kernel.String方法，主要用于在不确定对象类型时，强制将其转换为字符串，例如在日志拼接中：log_message = "Value: " + String(value)，这样即使value是nil或Array，也不会报错。

然而，当需要机器可读、可解析、可序列化的字符串时，.to_s就力不从心了。这时你需要：

• inspect：返回一个“调试友好”的、能反映对象内部结构的字符串。[1,2,3].inspect返回"[1, 2, 3]"，{a: 1}.inspect返回"{:a=>1}"。它常用于日志和调试，因为你能一眼看出对象的类型和内容。
• to_json（需require 'json'）：返回标准 JSON 格式的字符串。{a: 1}.to_json返回'{"a":1}'。这是与外部 API 交互、持久化数据的黄金标准。roborock ruby脚本如果需要将设备状态上报到云端，to_json是唯一正确的选择。

实操心得：在 Rails 的控制器中，我见过太多人这样写：render json: { status: "success", data: @user.to_s }。这会导致@user.to_s输出一个毫无意义的#<User:0x00007f...>字符串。正确做法是render json: @user，Rails 会自动调用as_json方法，生成结构化的 JSON。记住：.to_s是给人看的，to_json是给机器看的，二者绝不能混用。

3.3 符号与数组/哈希转换：.to_sym、.to_a、.to_h的陷阱与妙用

.to_sym的妙处在于它能将任意字符串“固化”为一个轻量级的标识符。"status".to_sym得到:status，之后所有对:status的引用都指向同一个内存地址。这使得它成为哈希键的完美选择：{ status: "active" }在内部就是{ :status => "active" }。但.to_sym有一个致命限制：它不能用于包含空格或特殊字符的字符串。"user name".to_sym返回:"user name"，这是一个合法的符号，但:"user name"无法作为哈希键的字面量（{ "user name": "John" }会报错），必须写成{ :"user name" => "John" }，这非常丑陋且易错。

解决方案是使用String#intern（与to_sym等价）或更现代的String#to_sym（Ruby 2.2+），但更重要的是，在设计 API 或数据结构时，就应避免使用空格作为键名。roborock ruby的固件配置文件通常使用下划线_或连字符-，这正是为了兼容 Ruby 符号。

.to_a和.to_h则是集合转换的利器。"abc".to_a返回["a", "b", "c"]，将字符串拆分为字符数组。{a: 1, b: 2}.to_a返回[[:a, 1], [:b, 2]]，这是一个二维数组，可以方便地用map进行转换。而.to_h则是它的逆操作：[[:a, 1], [:b, 2]].to_h返回{a: 1, b: 2}。这个组合在数据清洗中极为常用：

# 将一个扁平的参数哈希，按前缀分组 params = { "user_name" => "Alice", "user_age" => "30", "order_id" => "123" } # 提取所有以 "user_" 开头的键 user_params = params.select { |k, v| k.start_with?("user_") } # 将 "user_name" => "Alice" 转换为 :name => "Alice" user_hash = user_params.map { |k, v| [k.sub("user_", "").to_sym, v] }.to_h # => { name: "Alice", age: "30" }

这里，.map生成了[:name, "Alice"], [:age, "30"]的数组，.to_h将其一键转为哈希。整个过程清晰、函数式、无副作用。

4. 完整实操流程：从 macOS 上修复homebrew portable ruby升级失败，到安全解析unified_test_platform

4.1 诊断failed to upgrade homebrew portable ruby!的根本原因

当你在 macOS 上执行brew upgrade ruby失败，并看到failed to install homebrew portable ruby (and your system version is too old)这样的提示时，问题往往不在 Ruby 本身，而在于 Homebrew 的 Ruby 环境与你的系统 Shell（通常是 zsh）之间的字符串编码与路径解析冲突。Homebrew 的 portable Ruby 是一个自包含的 Ruby 发行版，它需要正确解析$PATH、$HOME等环境变量。如果这些变量中包含了非 ASCII 字符（比如中文用户名、带空格的路径），旧版本的 Homebrew Ruby 可能无法正确to_s或to_path，导致初始化失败。

第一步：确认问题根源

# 查看当前 shell 的环境变量 env | grep -E '^(PATH|HOME|SHELL)' # 检查 HOME 路径是否包含空格或中文 echo $HOME # 检查 Ruby 版本和位置 which ruby ruby -v # 检查 Homebrew 的 Ruby 是否被正确加载 brew --prefix ruby

第二步：临时绕过，进入纯净 Ruby 环境

# 创建一个最小化环境，排除所有干扰 env -i PATH="/usr/bin:/bin:/usr/sbin:/sbin" /opt/homebrew/bin/ruby -v # 如果这一步成功，说明问题出在你的环境变量上 # 如果失败，则是 Homebrew Ruby 本身损坏

第三步：安全升级，避免字符串解析错误

# 不要直接 brew upgrade ruby # 先卸载旧的 portable ruby brew uninstall ruby # 清理可能残留的缓存和链接 rm -rf $(brew --prefix ruby) # 强制重新安装最新版 brew install ruby # 关键一步：重新链接，确保所有路径字符串被正确解析 brew link --force ruby

注意：brew link --force这个命令之所以有效，是因为它会重新执行 Ruby 的postinstall脚本，该脚本内部会调用File.expand_path和Dir.home等方法，这些方法在新版 Ruby 中对 Unicode 路径的to_s处理更加健壮。我曾经在一个用户名为“张三”的 Mac 上反复失败，直到执行了brew link --force，问题才解决。这本质上是一次对 Ruby 内部字符串路径处理能力的“压力测试”。

4.2 解析cannot convert string value 'unified_test_platform' to an enum value of type错误

这个错误信息非常典型，它出现在 Rails 应用或某些 Ruby SDK 中，当一个字符串参数（如params[:platform]）被期望映射到一个预定义的枚举（Enum）类时。例如：

class TestRun enum platform: { ios: 0, android: 1, unified_test_platform: 2 } end

此时，如果前端传来的params[:platform]是字符串"unified_test_platform"，Rails 会尝试调用TestRun.platforms["unified_test_platform"]，这内部会调用String#to_sym，然后去哈希中查找:unified_test_platform键。如果找不到，就会报这个错。

解决方案不是“强制转换”，而是“语义对齐”：

方案一：在控制器中预处理（推荐）

class TestRunsController < ApplicationController def create # 将字符串参数标准化为符号 platform_param = params[:platform]&.to_s&.downcase&.tr('-', '_')&.to_sym # 确保它是我们支持的枚举值之一 if TestRun.platforms.key?(platform_param) @test_run = TestRun.new(platform: platform_param, ...) # ... 保存逻辑 else render json: { error: "Unsupported platform: #{params[:platform]}" }, status: :bad_request end end end

这里，&.to_s防止nil报错，&.downcase统一大小写，&.tr('-', '_')将连字符转为下划线（适配unified-test-platform这种常见写法），最后&.to_sym生成符号。整个链条是防御性的、可读的、可测试的。

方案二：扩展 Enum 类，增加字符串解析能力

# lib/core_ext/enumerable.rb class Enumerable def from_string(str) return nil if str.nil? # 尝试匹配字符串的多种变体 candidates = [ str.to_sym, str.downcase.to_sym, str.tr('-', '_').to_sym, str.tr(' ', '_').to_sym ] candidates.find { |c| self.key?(c) } end end # 在模型中使用 class TestRun enum platform: { ios: 0, android: 1, unified_test_platform: 2 } def self.platform_from_string(str) platforms.from_string(str) end end # 使用 TestRun.platform_from_string("UNIFIED-TEST-PLATFORM") # => :unified_test_platform

这个方案将转换逻辑封装在模型层，保持了控制器的简洁，并且可以被所有调用方复用。

4.3 构建一个鲁棒的roborock ruby数据解析器

roborock ruby并不是一个官方术语，而是社区对 Roborock 扫地机器人固件中嵌入的 Ruby 脚本的俗称。这些脚本通常用于自定义清扫逻辑、解析传感器原始数据（如激光雷达点云、陀螺仪读数）。它们运行在资源极其有限的 ARM 设备上，因此对字符串解析的效率和内存占用极为敏感。

假设我们需要解析一行来自串口的传感器数据："TEMP:23.5;HUMID:45;BATT:87%"。

目标：将其安全、高效地转换为一个哈希{ temp: 23.5, humid: 45, batt: 87 }。

步骤分解：

1. 分割字符串：使用split(';')，而不是正则，因为split是 C 实现的，速度极快。
2. 逐项解析：对每个key:value对，用split(':')分割，得到两部分。
3. 键名转换：将"TEMP"转为:temp，使用downcase.to_sym，避免创建不必要的字符串对象。
4. 值转换：对"23.5"，使用Float()进行严格解析；对"87%"，先用gsub('%', '')去除百分号，再to_i。

完整实现：

def parse_sensor_data(raw_line) return {} if raw_line.nil? || raw_line.empty? # 第一步：分割成键值对数组，O(n) 时间 pairs = raw_line.split(';') # 第二步：将每个键值对转换为 [symbol, value] 数组 # 使用 map! 原地修改，避免创建新数组 pairs.map! do |pair| key_val = pair.split(':', 2) # 最多分割成两部分，防止值中含冒号 next if key_val.length != 2 key = key_val[0].strip.downcase.to_sym val_str = key_val[1].strip case key when :temp, :humid [key, Float(val_str)] # 严格解析，失败则抛异常 when :batt # 处理带单位的值 clean_val = val_str.gsub(/[^0-9.]/, '') # 移除所有非数字非点字符 [key, clean_val.empty? ? 0 : clean_val.to_i] else [key, val_str] # 其他未知键，保留原字符串 end end # 第三步：过滤掉 nil，并转换为哈希 pairs.compact.to_h rescue ArgumentError => e # 记录原始数据和错误，便于调试 Rails.logger.warn "Sensor parse failed: #{raw_line.inspect} - #{e.message}" {} end # 测试 parse_sensor_data("TEMP:23.5;HUMID:45;BATT:87%") # => { temp: 23.5, humid: 45, batt: 87 }

这个解析器的特点是：

• 极致的性能：所有操作都是原生 C 实现的split、strip、gsub，没有正则回溯。
• 内存友好：map!和compact避免了中间数组的创建。
• 强错误处理：rescue捕获所有Float()解析失败，并记录原始数据，方便在roborock设备上远程诊断。
• 业务语义清晰：针对不同键（temp,humid,batt）采用不同的转换策略，而不是一刀切的.to_f。

5. 常见问题与排查技巧实录：那些年我们踩过的 Ruby 类型转换坑

5.1 “to_i返回 0，但我明明传了个空字符串！”——空值与默认值的迷思

问题现象：在一个用户注册表单中，params[:age]是空字符串""，你写了age = params[:age].to_i，结果age是0，导致一个 0 岁的用户被创建。

根本原因：这是.to_i的设计使然，它必须返回一个整数，而0是最合理的默认值。但这与业务逻辑冲突——年龄0和“未填写”是两个完全不同的概念。

排查技巧：

• 日志追踪：在转换前加一句Rails.logger.debug "Raw age param: #{params[:age].inspect}"。inspect会显示""，而to_s会显示""，但inspect还能显示nil（nil）和空格（" "）。
• 类型断言：在开发环境中，使用binding.pry或byebug，在转换行设置断点，用params[:age].class和params[:age].length检查其真实状态。

终极解决方案：

# 使用更语义化的判断 age_str = params[:age] if age_str.blank? # blank? 包含 nil, "", " " age = nil elsif age_str.match?(/^\d+$/) age = age_str.to_i else # 报错或提示用户 errors.add(:age, "must be a positive integer") end

blank?是 Rails 提供的、比nil? || empty?更全面的空值检查，它能正确处理nil、空字符串、只含空白字符的字符串。

5.2 “Integer()报错，但to_i却成功了”——宽容与严格的选择困境

问题现象：一个支付金额字段，前端传"100.50"，后端用amount = Integer(params[:amount])，报错；换成amount = params[:amount].to_i，得到100，但小数点后的50丢失了，导致少收了 50 分钱。

根本原因：Integer()严格要求输入是整数字符串，而to_i会截断小数部分。这暴露了业务需求的模糊性：这个字段到底是“整数金额（分）”，还是“浮点金额（元）”？

排查技巧：

• 审查 API 文档：确认该字段的契约。如果是“金额（元）”，就应该用Float()；如果是“金额（分）”，就应该要求前端传整数，或后端用((params[:amount].to_f * 100).round)转换。
• 数据库 Schema 检查：rails db:schema:dump查看该字段的类型。如果是integer，说明是“分”；如果是decimal，说明是“元”。

最佳实践：

# 对于金额（元），使用 Float() 并验证精度 begin amount_in_yuan = Float(params[:amount]) # 确保最多两位小数 raise ArgumentError, "Amount must have at most 2 decimal places" unless amount_in_yuan.to_s.match?(/^\d+(\.\d{1,2})?$/) amount_in_cents = (amount_in_yuan * 100).round rescue ArgumentError => e # 统一错误处理 render json: { error: e.message }, status: :unprocessable_entity end

5.3 “to_sym创建了奇怪的符号，哈希里找不到！”——符号的不可变性与动态生成

问题现象：你写了key = "user_name".to_sym，然后hash[key]返回nil，但hash[:user_name]却有值。

根本原因：key变量里存储的确实是:user_name，但hash里存储的键是另一个:user_name符号。这听起来矛盾，但 Ruby 中，所有内容相同的符号，都指向同一个对象。所以key == :user_name是true，key.equal?(:user_name)也是true。问题一定出在别处。

排查技巧：

• 检查字符串内容："user_name".bytes查看每个字符的 ASCII 码。你可能会发现"user_name"实际上是"user_name\u200B"（带了一个零宽空格），to_sym会把它变成:"user_name\u200B"，这与:user_name完全不同。
• 使用inspect："user_name".inspect会显示所有不可见字符，:"user_name".inspect也会显示。

解决方案：

# 在生成符号前，进行严格的字符串清理 def safe_to_sym(str) return nil if str.nil? # 移除所有控制字符和零宽空格 cleaned = str.encode('UTF-8', invalid: :replace, undef: :replace, replace: ''). gsub(/[[:cntrl:]]/, ''). gsub(/\u200B|\u200C|\u200D|\uFEFF/, '') cleaned.strip.empty? ? nil : cleaned.to_sym end # 使用 key = safe_to_sym(params[:key]) hash[key] # 现在肯定能找到了

5.4 “to_h报错wrong number of arguments”——二维数组的结构陷阱

问题现象：你有一个数组data = [["name", "Alice"], ["age", 30]]，想用data.to_h转成哈希，但报错ArgumentError: wrong number of arguments (given 1, expected 0)。

根本原因：to_h方法要求数组中的每个元素本身是一个恰好有两个元素的数组（即[key, value]对）。如果data中有一个元素是["name", "Alice", "extra"]（三个元素），或者["name"]（一个元素），to_h就会报这个错。

排查技巧：

• 检查数组结构：data.map(&:length)会返回每个子数组的长度，一眼就能看出哪个不合规。
• 使用all?断言：data.all? { |pair| pair.is_a?(Array) && pair.length == 2 }。

安全转换函数：

def array_to_hash(safe_array) # 过滤掉不合规的元素，只保留 [key, value] 对 valid_pairs = safe_array.select do |pair| pair.is_a?(Array) && pair.length >= 2 end # 取前两个元素，忽略多余的 valid_pairs.map { |pair| pair.take(2) }.to_h end # 测试 array_to_hash([["name", "Alice"], ["age", 30, "extra"], ["city"]]) # => { "name" => "Alice", "age" => 30 }

5.5 “roborock ruby脚本在设备上跑，to_i结果不对！”——嵌入式环境的编码与 locale 陷阱

问题现象：一个在 macOS 上测试完美的roborock ruby脚本，部署到扫地机器人上后，"123".to_i返回0。

根本原因：嵌入式 Linux 系统的 locale 设置可能不是en_US.UTF-8，而是C或POSIX。在Clocale 下，to_i的行为与en_US下略有不同，尤其是在处理千位分隔符或小数点时。更常见的是，设备上的 Ruby 是一个精简版，可能缺少某些标准库，导致String#to_i的实现有差异。

排查技巧：

• 在设备上直接运行 Ruby：通过 SSH 连接到机器人，执行ruby -e "puts '123'.to_i"，确认基础功能。
• 检查 locale：locale命令输出当前设置。
• 检查 Ruby 版本和构建选项：ruby -v和ruby -r rbconfig -e "puts RbConfig::CONFIG['configure_args']"。

终极保障方案：

# 不依赖内置的 to_i，自己写一个最简解析器 def robust_to_i