Ruby 内建函数

Ruby 核心方法 (通常称为内置函数)

Ruby 的 Kernel 模块被 Object 类包含，使其方法几乎在 Ruby 程序的每个部分都可用。这些方法通常可以不带显式接收者调用（例如，puts "hello" 而不是 self.puts "hello"），这让它们看起来像函数。本章概述了常用的 Kernel 方法和其他重要的核心功能。

一些重要的 Kernel 方法精选：

方法签名	描述
abort(message=nil)	立即终止程序执行。如果给出 message，则打印到 stderr。如果有一个活跃的异常 ($!)，则显示其消息。
Array(object)	将 object 转换为 Array。如果 to_ary 可用，则调用它，否则调用 to_a。
at_exit { block }	注册一个 block，使其在程序退出时执行。多个块按注册的相反顺序执行。
autoload(module_name, filename)	注册 filename，使其在 module_name (字符串或符号) 首次被引用时加载 (使用 require)。
binding	返回一个 Binding 对象，表示当前的执行上下文 (变量、方法、self)。与 eval 一起使用时很有用。
block_given?	如果当前方法被调用时附带了一个 block，则返回 true，否则返回 false。
caller(start=1, length=nil)	以 file:line: in method“ 的格式返回当前的执行堆栈 (backtrace)，为一个字符串数组。
catch(tag) { block }	提供一种从 block 执行非局部退出 (跳转) 的方式。与 throw(tag, value) 一起使用。
eval(string, binding=TOPLEVEL_BINDING, filename="(eval)", lineno=1)	执行 string 中的 Ruby 代码。binding 指定上下文。由于处理不可信输入时存在安全风险，请极端谨慎使用。
exec(command, *args)	用指定的 command 替换当前进程。如果成功则不返回。
exit(status=true) / exit!(status=true)	exit 终止脚本，运行 at_exit 处理程序和 ensure 子句。exit! 立即终止，不运行处理程序。status 可以是一个整数退出码 (0 表示成功) 或 true/false。
Float(arg, exception: true)	将 arg 转换为 Float。除非 exception: false，否则失败时抛出异常。
fork { block }	创建一个子进程。block 在子进程中执行。在父进程中返回子进程的 PID，在子进程中返回 nil。并非所有平台都可用 (例如，标准的 Windows Ruby)。
format(format_string, *args) / sprintf(format_string, *args)	根据 format_string 和 args 返回格式化后的字符串。参见下面的格式化指令。
gets(separator=$/)	从标准输入 (或通过命令行指定的 ARGF 文件) 读取下一行。separator 是行结束符。到达 EOF 时返回 nil。
global_variables	返回一个符号数组，表示所有已定义的全局变量的名称。
Integer(arg, base=0, exception: true)	将 arg 转换为 Integer。base 指定数字基数。除非 exception: false，否则失败时抛出异常。
lambda { block } / proc { block }	从 block 创建一个 Proc 对象。lambda 对参数检查更严格，并且与使用 Proc.new 或 proc 关键字创建的 proc 相比，其 return 行为不同。
load(filename, wrap=false)	加载并执行 filename 中的 Ruby 程序。与 require 不同，load 可以多次执行一个文件，并且不跟踪已加载的文件。如果 wrap 为 true，则加载到一个匿名模块中。
local_variables	返回一个符号数组，表示当前已定义的局部变量的名称。
loop { block }	无限重复执行 block，直到被显式中断 (例如，使用 break 或异常)。
open(path, mode="r", &block)	以指定的 mode 打开 path 指定的文件。如果给定了 block，文件对象将被传递给 block，并在 block 完成后自动关闭。如果 path 以 | 开头，则被视为用于管道 I/O 的命令。
p(obj1, obj2, ...)	对于每个对象，打印 obj.inspect 后跟一个换行符到 $stdout。用于调试。
print(*args)	对每个 arg 调用 to_s 后，将其打印到 $stdout。默认不添加换行符。如果没有给出参数，则打印 $_。
printf(format_string, *args) / printf(io, format_string, *args)	根据 format_string 格式化参数 (类似于 sprintf)，并打印到 $stdout 或指定的 io 对象。
puts(*args)	将每个 arg 打印到 $stdout，并在每个参数后添加一个换行符 (除非参数本身是一个数组，在这种情况下每个元素打印在一行上)。对参数调用 to_s。
raise(exception_class, message, backtrace) / fail(...)	抛出一个异常。fail 是 raise 的一个旧别名；建议使用 raise。如果在 rescue 子句内调用时不带参数，可以重新抛出当前异常。
rand(max=0.0)	生成一个伪随机数。如果 max 是一个大于 0 的整数，则返回一个从 0 到 max-1 的整数。如果 max 是一个 Float 或 0，则返回一个介于 0.0 和 1.0 (不包含 1.0) 之间的浮点数。如果 max 是一个 Range，则返回该范围内的随机元素。
readline(separator=$/)	类似于 gets，但在文件末尾抛出 EOFError。
readlines(separator=$/)	读取标准输入 (或 ARGF) 中的所有行，并将其作为字符串数组返回。
require(name) / require_relative(name)	require 加载给定的库/文件 (name) 一次。它搜索 Ruby 的加载路径。用于加载 gem 和标准库。require_relative 加载相对于当前文件目录的文件。
select(read_array, write_array=nil, error_array=nil, timeout=nil)	执行低级 I/O 多路复用。检查 IO 对象数组的 I/O 就绪状态。
sleep(duration)	暂停执行 duration 秒 (可以是浮点数)。如果不带参数，则永远睡眠。
String(arg)	通过调用 to_s 将 arg 转换为 String。
system(command, *args)	在子 shell 中执行 command。如果命令以状态 0 退出，则返回 true，否则返回 false；如果命令执行失败，则返回 nil。退出状态可在 $? 中获取。
test(cmd, file1, file2=nil)	执行文件测试。cmd 是指定测试的字符 (例如，?f 表示普通文件)。为了提高可读性，建议使用 File 类方法 (例如，File.file?)。
throw(tag, value=nil)	发起一个非局部退出，跳转到匹配 tag 的 catch 块。value 成为 catch 的返回值。
trap(signal, command_or_proc)	为操作系统 signal (例如 'INT', 'TERM') 设置一个处理程序。

常用的 Numeric 和 Integer 方法

这些方法可用于数值对象 (Integer, Float 等的实例)。

#!/usr/bin/env ruby
num_i = -10
num_f = 12.75

puts "整数方法:"
puts "#{num_i}.abs: #{num_i.abs}"                # => 10 (绝对值)
puts "#{num_i}.even?: #{num_i.even?}"              # => true (是否为偶数)
puts "#{num_i}.odd?: #{num_i.odd?}"                # => false (是否为奇数)
puts "5.next: #{5.next}"                   # => 6 (或 5.succ，下一个整数)
puts "5.times { |i| print "#{i} " }: " ; 5.times { |i| print "#{i} " } ; puts

puts "\n浮点数方法:"
puts "#{num_f}.round: #{num_f.round}"              # => 13 (四舍五入)
puts "#{num_f}.floor: #{num_f.floor}"              # => 12 (向下取整)
puts "#{num_f}.ceil: #{num_f.ceil}"               # => 13 (向上取整)
puts "#{num_f}.truncate: #{num_f.truncate}"        # => 12 (截断小数)

puts "\n数值方法 (两者都可用):"
puts "#{num_i}.zero?: #{num_i.zero?}"              # => false (是否为零)
puts "0.zero?: #{0.zero?}"                    # => true (是否为零)
puts "#{num_f}.positive?: #{num_f.positive?}"    # => true (是否为正数)
puts "#{num_i}.negative?: #{num_i.negative?}"    # => true (是否为负数)

精选的 Numeric, Integer, Float 方法：

方法	描述
n.abs	返回 n 的绝对值。
n.ceil	返回大于或等于 n 的最小整数 (Float)。
n.floor	返回小于或等于 n 的最大整数 (Float)。
n.round([digits])	将 n 四舍五入到最近的整数，或 digits 指定的小数位数 (Float)。
n.truncate([digits])	移除小数部分，返回整数，或截断到 digits 指定的位数 (Float)。
n.to_i / n.to_int	将 n 转换为 Integer (对 Float 截断小数)。
n.to_f	将 n 转换为 Float。
n.integer?	如果 n 是 Integer，则返回 true。
n.float?	如果 n 是 Float，则返回 true。
n.zero?	如果 n 是零，则返回 true。
n.positive?	如果 n 大于零，则返回 true。
n.negative?	如果 n 小于零，则返回 true。
int.even?	如果 int 是偶数整数，则返回 true。
int.odd?	如果 int 是奇数整数，则返回 true。
int.next / int.succ	返回整数 int + 1。
int.pred	返回整数 int - 1。
int.times { |i| ... }	迭代 int 次 block，传入当前迭代次数 (从 0 到 int-1)。
num.step(limit, step_value) { |i| ... }	从 num 迭代到 (或迭代到) limit，步长为 step_value。
float.finite?	如果 float 是有限数，则返回 true。
float.infinite?	正无穷返回 1，负无穷返回 -1，否则返回 nil。
float.nan?	如果 float 是非数字 (NaN)，则返回 true。

Math 模块函数

Math 模块提供了一系列三角函数、对数函数和其他数学函数。这些函数通常以 Math.函数名(参数) 的形式调用。

函数 (位于 Math 模块)	描述
Math.sqrt(x)	返回 x 的非负平方根 (x 必须是非负数)。
Math.log(x) / Math.log(x, base)	返回 x 的自然对数，或以 base 为底 x 的对数。
Math.log10(x)	返回 x 的以 10 为底的对数。
Math.exp(x)	返回 e (欧拉数) 的 x 次幂。
Math.sin(x), Math.cos(x), Math.tan(x)	x 的三角函数正弦、余弦、正切 (参数单位为弧度)。
Math.asin(x), Math.acos(x), Math.atan(x)	反三角函数。
Math.atan2(y, x)	y/x 的反正切，使用 x 和 y 的符号确定象限。
Math::PI	圆周率 Pi 的常量 (约 3.14159…)。
Math::E	欧拉数 E 的常量 (约 2.71828…)。

示例：

#!/usr/bin/env ruby
puts "Square root of 16: #{Math.sqrt(16)}" # => 4.0 (16的平方根)
puts "PI: #{Math::PI}" # => 3.14159... (PI)
puts "Cosine of PI: #{Math.cos(Math::PI)}" # => -1.0 (PI的余弦)

sprintf/format 转换说明符

sprintf (或 format) 方法在格式字符串中使用转换说明符来确定参数的格式。说明符以 % 开头，可以包含标志、宽度、精度和类型字符。

常用类型字符：

说明符	描述
b	二进制整数 (基数 2)。
c	字符 (将整数参数视为字符编码)。
d 或 i	十进制整数 (基数 10)。
u	无符号十进制整数。
o	八进制整数 (基数 8)。
x	十六进制整数 (小写 a-f)。
X	十六进制整数 (大写 A-F)。
f	定点表示法浮点数 (例如，123.45)。
e	科学记数法浮点数 (例如，1.2345e+02)。
E	类似于 e，但使用大写 E。
g	使用 %e 或 %f 格式中较短的一个。
G	使用 %E 或 %f 格式中较短的一个。
s	字符串 (对参数调用 to_s)。
p	使用 inspect 打印对象 (Ruby 特有)。
%	字面量的百分号 (%%)。

标志、宽度和精度示例：

#!/usr/bin/env ruby
puts sprintf("Number: %d, String: %s", 123, "hello")  # => "Number: 123, String: hello" (数字: 123, 字符串: hello)
puts sprintf("Padded: %05d", 42)                   # => "Padded: 00042" (填充零, 宽度 5)
puts sprintf("Float: %.2f", 123.4567)              # => "Float: 123.46" (2位小数)
puts sprintf("Hex: %x", 255)                       # => "Hex: ff" (十六进制)
puts sprintf("Left-justified: |%-10s|", "text")   # => "Left-justified: |text      |" (左对齐, 宽度 10)

test 函数参数 (建议使用 File 类方法)

test(cmd, file1, file2) 函数执行文件测试。虽然可用，但通常建议使用更具可读性和面向对象风格的 File 类方法（例如，File.readable?(file1), File.exist?(file1))。

有关特定方法的更多详细信息，请始终查阅 Ruby 官方文档中 Kernel, Numeric, Integer, Float, 和 Math 模块/类的说明。（Ruby 核心文档）