模块 Kernel
Kernel 模块被类 Object 包含，因此它的方法在每个 Ruby 对象中都可用。
Kernel 实例方法在类 Object 中记录，而模块方法在此处记录。这些方法在没有接收者的情况下调用，因此可以以函数形式调用
sprintf "%.1f", 1.234 #=> "1.2"
这里有什么¶ ↑
模块 Kernel 提供了有用的方法，用于
转换¶ ↑
查询¶ ↑
-
__callee__：将当前方法的调用名称作为符号返回。 -
__dir__：返回当前方法被调用的目录的路径。 -
__method__：将当前方法的名称作为符号返回。 -
autoload?：返回当引用给定模块时要加载的文件。 -
block_given?：如果将代码块传递给调用方法，则返回true。 -
caller：将当前执行堆栈作为字符串数组返回。 -
caller_locations：将当前执行堆栈作为Thread::Backtrace::Location对象数组返回。 -
class：返回self的类。 -
frozen?：返回self是否被冻结。 -
global_variables：返回全局变量的数组，以符号形式表示。 -
local_variables：返回局部变量的数组，以符号形式表示。 -
test：对给定的单个文件或一对文件执行指定的测试。
退出¶ ↑
异常¶ ↑
IO¶ ↑
-
::pp：以漂亮的格式打印给定的对象。 -
gets：返回并将当前输入的下一行赋值给$_。 -
p：将给定对象的 inspect 输出打印到标准输出。 -
print：将给定对象打印到标准输出，不带换行符。 -
printf：打印将给定格式字符串应用于任何其他参数后得到的字符串。 -
putc：对于给定对象，等效于 <tt.$stdout.putc(object)</tt>。 -
puts：对于给定对象，等效于$stdout.puts(*objects)。 -
readlines：返回当前输入的剩余行的数组。
Procs¶ ↑
追踪¶ ↑
-
set_trace_func：将给定的 proc 设置为跟踪处理程序，如果给定nil，则禁用跟踪。 -
trace_var：开始跟踪对给定全局变量的赋值。 -
untrace_var：禁用对给定全局变量的赋值的跟踪。
子进程¶ ↑
-
`command`：返回在子 shell 中运行
command的标准输出。 -
exec：用新进程替换当前进程。 -
fork：将当前进程分成两个进程。 -
spawn：执行给定命令并返回其 pid，而不等待完成。 -
system：在子 shell 中执行给定命令。
加载¶ ↑
-
autoload：注册给定文件，以便在首次引用给定常量时加载。 -
load：加载给定的 Ruby 文件。 -
require：加载给定的 Ruby 文件，除非它已被加载。 -
require_relative：加载相对于调用文件的 Ruby 文件路径，除非它已被加载。
产生¶ ↑
-
tap：将self产生给定的代码块；返回self。 -
then（别名为yield_self）：将self产生给代码块，并返回代码块的结果。
随机值¶ ↑
其他¶ ↑
公共类方法
源代码
# File lib/uri/common.rb, line 865 def URI(uri) if uri.is_a?(URI::Generic) uri elsif uri = String.try_convert(uri) URI.parse(uri) else raise ArgumentError, "bad argument (expected URI object or URI string)" end end
返回从给定 uri 派生的 URI 对象，uri 可以是 URI 字符串或现有的 URI 对象
# Returns a new URI. uri = URI('http://github.com/ruby/ruby') # => #<URI::HTTP http://github.com/ruby/ruby> # Returns the given URI. URI(uri) # => #<URI::HTTP http://github.com/ruby/ruby>
源代码
# File lib/pp.rb, line 692 def pp(*objs) objs.each {|obj| PP.pp(obj) } objs.size <= 1 ? objs.first : objs end
以漂亮的格式打印参数。
pp 返回参数。
公共实例方法
源代码
static VALUE
rb_f_callee_name(VALUE _)
{
ID fname = prev_frame_callee(); /* need *callee* ID */
if (fname) {
return ID2SYM(fname);
}
else {
return Qnil;
}
}
以 Symbol 的形式返回当前调用方法的名称。如果在方法外部调用，则返回 nil。
源代码
static VALUE
f_current_dirname(VALUE _)
{
VALUE base = rb_current_realfilepath();
if (NIL_P(base)) {
return Qnil;
}
base = rb_file_dirname(base);
return base;
}
返回调用此方法的文件的目录的规范化绝对路径。这意味着路径中的符号链接将被解析。如果 __FILE__ 为 nil，则返回 nil。返回值等于 File.dirname(File.realpath(__FILE__))。
源代码
static VALUE
rb_f_method_name(VALUE _)
{
ID fname = prev_frame_func(); /* need *method* ID */
if (fname) {
return ID2SYM(fname);
}
else {
return Qnil;
}
}
以 Symbol 的形式返回当前方法定义时的名称。如果在方法外部调用，则返回 nil。
源代码
static VALUE
rb_f_backquote(VALUE obj, VALUE str)
{
VALUE port;
VALUE result;
rb_io_t *fptr;
StringValue(str);
rb_last_status_clear();
port = pipe_open_s(str, "r", FMODE_READABLE|DEFAULT_TEXTMODE, NULL);
if (NIL_P(port)) return rb_str_new(0,0);
GetOpenFile(port, fptr);
result = read_all(fptr, remain_size(fptr), Qnil);
rb_io_close(port);
rb_io_fptr_cleanup_all(fptr);
RB_GC_GUARD(port);
return result;
}
返回在子 shell 中运行 command 的 $stdout 输出；将全局变量 $? 设置为进程状态。
如果使用不受信任的输入调用此方法，则此方法可能存在安全漏洞；请参阅命令注入。
示例
$ `date` # => "Wed Apr 9 08:56:30 CDT 2003\n" $ `echo oops && exit 99` # => "oops\n" $ $? # => #<Process::Status: pid 17088 exit 99> $ $?.status # => 99>
内置语法 %x{...} 使用此方法。
源代码
static VALUE
rb_f_array(VALUE obj, VALUE arg)
{
return rb_Array(arg);
}
返回从 object 转换而来的数组。
尝试先使用 to_ary，然后使用 to_a 将 object 转换为数组。
Array([0, 1, 2]) # => [0, 1, 2] Array({foo: 0, bar: 1}) # => [[:foo, 0], [:bar, 1]] Array(0..4) # => [0, 1, 2, 3, 4]
如果 object 无法转换，则以数组 [object] 的形式返回 object。
Array(:foo) # => [:foo]
源代码
static VALUE
nucomp_f_complex(int argc, VALUE *argv, VALUE klass)
{
VALUE a1, a2, opts = Qnil;
int raise = TRUE;
if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
a2 = Qundef;
}
if (!NIL_P(opts)) {
raise = rb_opts_exception_p(opts, raise);
}
if (argc > 0 && CLASS_OF(a1) == rb_cComplex && UNDEF_P(a2)) {
return a1;
}
return nucomp_convert(rb_cComplex, a1, a2, raise);
}
如果参数有效，则返回一个新的 Complex 对象；否则，如果 exception 为 true，则引发异常；否则，返回 nil。
使用 Numeric 参数 real 和 imag，如果参数有效，则返回 Complex.rect(real, imag)。
使用字符串参数 s，如果参数有效，则返回一个新的 Complex 对象；该字符串可能具有：
-
一个或两个数字子字符串，每个子字符串指定一个
Complex、Float、Integer、Numeric或Rational值，指定直角坐标-
带符号分隔的实部和虚部数字子字符串（带有尾随字符
'i'）Complex('1+2i') # => (1+2i) Complex('+1+2i') # => (1+2i) Complex('+1-2i') # => (1-2i) Complex('-1+2i') # => (-1+2i) Complex('-1-2i') # => (-1-2i)
-
仅实部的数字字符串（不带尾随字符
'i'）Complex('1') # => (1+0i) Complex('+1') # => (1+0i) Complex('-1') # => (-1+0i)
-
仅虚部的数字字符串（带有尾随字符
'i'）Complex('1i') # => (0+1i) Complex('+1i') # => (0+1i) Complex('-1i') # => (0-1i)
-
-
以 @ 符号分隔的实部和虚部有理数子字符串，每个子字符串指定一个
Rational值，指定极坐标Complex('1/2@3/4') # => (0.36584443443691045+0.34081938001166706i) Complex('+1/2@+3/4') # => (0.36584443443691045+0.34081938001166706i) Complex('+1/2@-3/4') # => (0.36584443443691045-0.34081938001166706i) Complex('-1/2@+3/4') # => (-0.36584443443691045-0.34081938001166706i) Complex('-1/2@-3/4') # => (-0.36584443443691045+0.34081938001166706i)
源代码
# File kernel.rb, line 193 def Float(arg, exception: true) if Primitive.mandatory_only? Primitive.rb_f_float1(arg) else Primitive.rb_f_float(arg, exception) end end
返回转换为浮点数的 arg。 Numeric 类型直接转换，除了 String 和 nil 之外，其余类型使用 arg.to_f 进行转换。转换带有无效字符的 String 将导致 ArgumentError。转换 nil 会生成 TypeError。可以通过传递 exception: false 来抑制异常。
Float(1) #=> 1.0 Float("123.456") #=> 123.456 Float("123.0_badstring") #=> ArgumentError: invalid value for Float(): "123.0_badstring" Float(nil) #=> TypeError: can't convert nil into Float Float("123.0_badstring", exception: false) #=> nil
源代码
static VALUE
rb_f_hash(VALUE obj, VALUE arg)
{
return rb_Hash(arg);
}
返回从 object 转换而来的哈希。
-
如果
object是-
哈希，则返回
object。 -
空数组或
nil，则返回空哈希。
-
-
否则，如果
object.to_hash返回哈希，则返回该哈希。 -
否则，返回
TypeError。
示例
Hash({foo: 0, bar: 1}) # => {:foo=>0, :bar=>1} Hash(nil) # => {} Hash([]) # => {}
源代码
# File kernel.rb, line 286 def Integer(arg, base = 0, exception: true) if Primitive.mandatory_only? Primitive.rb_f_integer1(arg) else Primitive.rb_f_integer(arg, base, exception) end end
返回从 object 转换而来的整数。
尝试先使用 to_int，然后使用 to_i 将 object 转换为整数；有关异常，请参见下文。
如果 base 非零，则 object 必须是字符串或可转换为字符串。
数值对象¶ ↑
如果给定了整数参数 object，则返回 object
Integer(1) # => 1 Integer(-1) # => -1
如果给定了浮点数参数 object，则返回截断为整数的 object
Integer(1.9) # => 1 # Rounds toward zero. Integer(-1.9) # => -1 # Rounds toward zero.
字符串对象¶ ↑
如果给定了字符串参数 object 且 base 为零，则返回以 10 为底数转换为整数的 object
Integer('100') # => 100 Integer('-100') # => -100
如果 base 为零，则字符串 object 可能包含前导字符以指定实际的基数（基数指示符）
Integer('0100') # => 64 # Leading '0' specifies base 8. Integer('0b100') # => 4 # Leading '0b' specifies base 2. Integer('0x100') # => 256 # Leading '0x' specifies base 16.
如果给定了正数 base（在 2..36 范围内），则返回以给定基数转换为整数的 object
Integer('100', 2) # => 4 Integer('100', 8) # => 64 Integer('-100', 16) # => -256
如果给定了负数 base（在 -36..-2 范围内），则如果存在，则返回转换为基数指示符的 object，否则返回 base
Integer('0x100', -2) # => 256 Integer('100', -2) # => 4 Integer('0b100', -8) # => 4 Integer('100', -8) # => 64 Integer('0o100', -10) # => 64 Integer('100', -10) # => 100
base -1 等效于 -10 的情况。
在转换字符串时，允许并忽略周围的空格和嵌入的下划线
Integer(' 100 ') # => 100 Integer('-1_0_0', 16) # => -256
其他类¶ ↑
使用各种其他类的 object 的示例
Integer(Rational(9, 10)) # => 0 # Rounds toward zero. Integer(Complex(2, 0)) # => 2 # Imaginary part must be zero. Integer(Time.now) # => 1650974042
关键字¶ ↑
如果将可选关键字参数 exception 给定为 true（默认值）
-
如果
object不响应to_int或to_i，则引发TypeError。 -
如果
object为nil，则引发TypeError。 -
如果
object是无效字符串，则引发ArgumentError。
如果将 exception 给定为 false，则会抑制任何类型的异常并返回 nil。
源代码
static VALUE
path_f_pathname(VALUE self, VALUE str)
{
if (CLASS_OF(str) == rb_cPathname)
return str;
return rb_class_new_instance(1, &str, rb_cPathname);
}
从给定的字符串 path 创建一个新的 Pathname 对象，并返回 pathname 对象。
要使用此构造函数，必须首先需要 Pathname 标准库扩展。
require 'pathname' Pathname("/home/zzak") #=> #<Pathname:/home/zzak>
有关详细信息，另请参阅 Pathname::new。
源代码
static VALUE
nurat_f_rational(int argc, VALUE *argv, VALUE klass)
{
VALUE a1, a2, opts = Qnil;
int raise = TRUE;
if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
a2 = Qundef;
}
if (!NIL_P(opts)) {
raise = rb_opts_exception_p(opts, raise);
}
return nurat_convert(rb_cRational, a1, a2, raise);
}
将 x/y 或 arg 作为 Rational 返回。
Rational(2, 3) #=> (2/3) Rational(5) #=> (5/1) Rational(0.5) #=> (1/2) Rational(0.3) #=> (5404319552844595/18014398509481984) Rational("2/3") #=> (2/3) Rational("0.3") #=> (3/10) Rational("10 cents") #=> ArgumentError Rational(nil) #=> TypeError Rational(1, nil) #=> TypeError Rational("10 cents", exception: false) #=> nil
字符串形式的语法
string form = extra spaces , rational , extra spaces ;
rational = [ sign ] , unsigned rational ;
unsigned rational = numerator | numerator , "/" , denominator ;
numerator = integer part | fractional part | integer part , fractional part ;
denominator = digits ;
integer part = digits ;
fractional part = "." , digits , [ ( "e" | "E" ) , [ sign ] , digits ] ;
sign = "-" | "+" ;
digits = digit , { digit | "_" , digit } ;
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
extra spaces = ? \s* ? ;
另请参阅 String#to_r。
源代码
static VALUE
rb_f_string(VALUE obj, VALUE arg)
{
return rb_String(arg);
}
返回从 object 转换而来的字符串。
尝试先使用 to_str，然后使用 to_s 将 object 转换为字符串
String([0, 1, 2]) # => "[0, 1, 2]" String(0..5) # => "0..5" String({foo: 0, bar: 1}) # => "{foo: 0, bar: 1}"
如果 object 无法转换为字符串，则引发 TypeError。
源代码
static VALUE
f_abort(int c, const VALUE *a, VALUE _)
{
rb_f_abort(c, a);
UNREACHABLE_RETURN(Qnil);
}
立即终止执行，实际上是通过调用 Kernel.exit(false)。
如果给定了字符串参数 msg，则在终止之前将其写入 STDERR；否则，如果引发了异常，则打印其消息和回溯。
源代码
static VALUE
rb_f_at_exit(VALUE _)
{
VALUE proc;
if (!rb_block_given_p()) {
rb_raise(rb_eArgError, "called without a block");
}
proc = rb_block_proc();
rb_set_end_proc(rb_call_end_proc, proc);
return proc;
}
将 block 转换为 Proc 对象（因此在调用点绑定它），并在程序退出时注册以供执行。如果注册了多个处理程序，则它们将按照注册的反向顺序执行。
def do_at_exit(str1) at_exit { print str1 } end at_exit { puts "cruel world" } do_at_exit("goodbye ") exit
产生
goodbye cruel world
源代码
static VALUE
rb_f_autoload(VALUE obj, VALUE sym, VALUE file)
{
VALUE klass = rb_class_real(rb_vm_cbase());
if (!klass) {
rb_raise(rb_eTypeError, "Can not set autoload on singleton class");
}
return rb_mod_autoload(klass, sym, file);
}
注册 filename，以便在首次访问 const（可以是 String 或符号）时加载（使用 Kernel::require）。
autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
如果 const 定义为自动加载，则要加载的文件名将替换为 filename。如果 const 已定义但不是自动加载，则不执行任何操作。
源代码
static VALUE
rb_f_autoload_p(int argc, VALUE *argv, VALUE obj)
{
/* use rb_vm_cbase() as same as rb_f_autoload. */
VALUE klass = rb_vm_cbase();
if (NIL_P(klass)) {
return Qnil;
}
return rb_mod_autoload_p(argc, argv, klass);
}
如果 name 在当前命名空间或其祖先之一中注册为 autoload，则返回要加载的 filename。
autoload(:B, "b") autoload?(:B) #=> "b" module C autoload(:D, "d") autoload?(:D) #=> "d" autoload?(:B) #=> nil end class E autoload(:F, "f") autoload?(:F) #=> "f" autoload?(:B) #=> "b" end
源代码
static VALUE
rb_f_binding(VALUE self)
{
return rb_binding_new();
}
返回一个 Binding 对象，描述调用点的变量和方法绑定。在调用 Binding#eval 以在此环境中执行评估的命令或提取其局部变量时，可以使用此对象。
class User def initialize(name, position) @name = name @position = position end def get_binding binding end end user = User.new('Joan', 'manager') template = '{name: @name, position: @position}' # evaluate template in context of the object eval(template, user.get_binding) #=> {:name=>"Joan", :position=>"manager"}
Binding#local_variable_get 可用于访问名称保留为 Ruby 关键字的变量
# This is valid parameter declaration, but `if` parameter can't # be accessed by name, because it is a reserved word. def validate(field, validation, if: nil) condition = binding.local_variable_get('if') return unless condition # ...Some implementation ... end validate(:name, :empty?, if: false) # skips validation validate(:name, :empty?, if: true) # performs validation
源代码
static VALUE
rb_f_block_given_p(VALUE _)
{
rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp = ec->cfp;
cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
return RBOOL(cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE);
}
如果 yield 将在当前上下文中执行块，则返回 true。 iterator? 形式已轻微弃用。
def try if block_given? yield else "no block" end end try #=> "no block" try { "hello" } #=> "hello" try do "hello" end #=> "hello"
源代码
static VALUE
rb_callcc(VALUE self)
{
volatile int called;
volatile VALUE val = cont_capture(&called);
if (called) {
return val;
}
else {
return rb_yield(val);
}
}
生成一个 Continuation 对象，该对象将其传递给关联的块。在使用此方法之前，需要 require 'continuation'。执行 cont.call 将导致 callcc 返回（就像从块的末尾落下来一样）。callcc 返回的值是块的值，或者是传递给 cont.call 的值。有关更多详细信息，请参见 Continuation 类。另请参见 Kernel#throw，了解展开调用堆栈的替代机制。
源代码
static VALUE
rb_f_caller(int argc, VALUE *argv, VALUE _)
{
return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 1);
}
返回当前执行堆栈 - 一个包含格式为 file:line 或 file:line: in `method' 的字符串的数组。
可选的 start 参数确定要从堆栈顶部省略的初始堆栈条目的数量。
第二个可选的 length 参数可用于限制从堆栈返回的条目数。
如果 start 大于当前执行堆栈的大小，则返回 nil。
可以选择传递一个范围，这将返回一个包含指定范围内条目的数组。
def a(skip) caller(skip) end def b(skip) a(skip) end def c(skip) b(skip) end c(0) #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10:in `<main>'"] c(1) #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11:in `<main>'"] c(2) #=> ["prog:8:in `c'", "prog:12:in `<main>'"] c(3) #=> ["prog:13:in `<main>'"] c(4) #=> [] c(5) #=> nil
源代码
static VALUE
rb_f_caller_locations(int argc, VALUE *argv, VALUE _)
{
return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 0);
}
返回当前执行堆栈 - 一个包含回溯位置对象的数组。
有关更多信息，请参见 Thread::Backtrace::Location。
可选的 start 参数确定要从堆栈顶部省略的初始堆栈条目的数量。
第二个可选的 length 参数可用于限制从堆栈返回的条目数。
如果 start 大于当前执行堆栈的大小，则返回 nil。
可以选择传递一个范围，这将返回一个包含指定范围内条目的数组。
源代码
static VALUE
rb_f_catch(int argc, VALUE *argv, VALUE self)
{
VALUE tag = rb_check_arity(argc, 0, 1) ? argv[0] : rb_obj_alloc(rb_cObject);
return rb_catch_obj(tag, catch_i, 0);
}
catch 执行其块。如果未调用 throw，则该块正常执行，并且 catch 返回评估的最后一个表达式的值。
catch(1) { 123 } # => 123
如果调用了 throw(tag2, val)，Ruby 会在其堆栈中向上搜索 catch 块，该块的 tag 与 tag2 具有相同的 object_id。当找到时，该块会停止执行并返回 val（如果没有给 throw 提供第二个参数，则返回 nil）。
catch(1) { throw(1, 456) } # => 456 catch(1) { throw(1) } # => nil
当 tag 作为第一个参数传递时，catch 会将其作为块的参数 yield。
catch(1) {|x| x + 2 } # => 3
如果没有给出 tag，catch 会 yield 一个新的唯一对象（来自 Object.new）作为块参数。然后，此对象可以用作 throw 的参数，并且将匹配正确的 catch 块。
catch do |obj_A| catch do |obj_B| throw(obj_B, 123) puts "This puts is not reached" end puts "This puts is displayed" 456 end # => 456 catch do |obj_A| catch do |obj_B| throw(obj_A, 123) puts "This puts is still not reached" end puts "Now this puts is also not reached" 456 end # => 123
源代码
static VALUE
rb_f_chomp(int argc, VALUE *argv, VALUE _)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chomp"), argc, argv);
rb_lastline_set(str);
return str;
}
等效于 $_ = $_.chomp(string)。请参阅 String#chomp。仅当指定了 -p/-n 命令行选项时可用。
源代码
static VALUE
rb_f_chop(VALUE _)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chop"), 0, 0);
rb_lastline_set(str);
return str;
}
等效于 ($_.dup).chop!，但永远不会返回 nil。请参阅 String#chop!。仅当指定了 -p/-n 命令行选项时可用。
源代码
# File kernel.rb, line 18 def class Primitive.attr! :leaf Primitive.cexpr! 'rb_obj_class(self)' end
返回 obj 的类。此方法必须始终使用显式接收者调用，因为 class 也是 Ruby 中的保留字。
1.class #=> Integer self.class #=> Object
源代码
# File kernel.rb, line 47 def clone(freeze: nil) Primitive.rb_obj_clone2(freeze) end
生成 obj 的浅拷贝——obj 的实例变量会被复制，但它们引用的对象不会被复制。 clone 会复制 obj 的冻结值状态，除非给出了带有 false 或 true 值的 :freeze 关键字参数。另请参阅 Object#dup 下的讨论。
class Klass attr_accessor :str end s1 = Klass.new #=> #<Klass:0x401b3a38> s1.str = "Hello" #=> "Hello" s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello"> s2.str[1,4] = "i" #=> "i" s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">" s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">"
此方法可能具有特定于类的行为。如果是这样，该行为将在类的 #initialize_copy 方法下进行记录。
源代码
VALUE
rb_f_eval(int argc, const VALUE *argv, VALUE self)
{
VALUE src, scope, vfile, vline;
VALUE file = Qundef;
int line = 1;
rb_scan_args(argc, argv, "13", &src, &scope, &vfile, &vline);
StringValue(src);
if (argc >= 3) {
StringValue(vfile);
}
if (argc >= 4) {
line = NUM2INT(vline);
}
if (!NIL_P(vfile))
file = vfile;
if (NIL_P(scope))
return eval_string_with_cref(self, src, NULL, file, line);
else
return eval_string_with_scope(scope, src, file, line);
}
计算 string 中的 Ruby 表达式。如果给出了 binding，它必须是一个 Binding 对象，则在它的上下文中执行计算。如果存在可选的 filename 和 lineno 参数，它们将在报告语法错误时使用。
def get_binding(str) return binding end str = "hello" eval "str + ' Fred'" #=> "hello Fred" eval "str + ' Fred'", get_binding("bye") #=> "bye Fred"
源代码
static VALUE
f_exec(int c, const VALUE *a, VALUE _)
{
rb_f_exec(c, a);
UNREACHABLE_RETURN(Qnil);
}
通过执行以下操作之一替换当前进程
-
将字符串
command_line传递给 shell。 -
调用
exe_path上的可执行文件。
如果使用不受信任的输入调用此方法，则此方法可能存在安全漏洞；请参阅命令注入。
新进程是使用 exec 系统调用 创建的；它可能会从调用程序继承其一些环境（可能包括打开的文件描述符）。
如果给出参数 env，它是一个影响新进程的 ENV 的哈希；请参阅 执行环境。
参数 options 是新进程的选项哈希；请参阅 执行选项。
第一个必需参数是以下之一
-
command_line，如果它是一个字符串，并且如果它以 shell 保留字或特殊内置字开头，或者如果它包含一个或多个元字符。 -
否则为
exe_path。
参数 command_line
字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置字开头或包含元字符
exec('if true; then echo "Foo"; fi') # Shell reserved word. exec('exit') # Built-in. exec('date > date.tmp') # Contains meta character.
命令行也可能包含命令的参数和选项
exec('echo "Foo"')
输出
Foo
有关 shell 的详细信息，请参阅 执行 Shell。
如果新进程无法执行，则引发异常。
参数 exe_path
参数 exe_path 是以下之一
-
要调用的可执行文件的字符串路径。
-
一个包含可执行文件路径和要用作执行进程名称的字符串的 2 元素数组。
示例
exec('/usr/bin/date')
输出
Sat Aug 26 09:38:00 AM CDT 2023
Ruby 直接调用可执行文件。此形式不使用 shell；有关注意事项，请参阅 参数 args。
exec('doesnt_exist') # Raises Errno::ENOENT
如果给出了一个或多个 args，则每个都是要传递给可执行文件的参数或选项
exec('echo', 'C*') exec('echo', 'hello', 'world')
输出
C* hello world
如果新进程无法执行，则引发异常。
源代码
static VALUE
f_exit(int c, const VALUE *a, VALUE _)
{
rb_f_exit(c, a);
UNREACHABLE_RETURN(Qnil);
}
通过引发 SystemExit 来启动 Ruby 脚本的终止；可以捕获异常。向底层操作系统返回退出状态 status。
参数 status 的值 true 和 false 分别表示成功和失败；整数值的含义取决于系统。
示例
begin exit puts 'Never get here.' rescue SystemExit puts 'Rescued a SystemExit exception.' end puts 'After begin block.'
输出
Rescued a SystemExit exception. After begin block.
在最终终止之前，Ruby 会执行任何 at-exit 过程（请参阅 Kernel::at_exit）和任何对象终结器（请参阅 ObjectSpace::define_finalizer）。
示例
at_exit { puts 'In at_exit function.' } ObjectSpace.define_finalizer('string', proc { puts 'In finalizer.' }) exit
输出
In at_exit function. In finalizer.
源代码
static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
int istatus;
if (rb_check_arity(argc, 0, 1) == 1) {
istatus = exit_status_code(argv[0]);
}
else {
istatus = EXIT_FAILURE;
}
_exit(istatus);
UNREACHABLE_RETURN(Qnil);
}
立即退出进程；不调用任何退出处理程序。向底层操作系统返回退出状态 status。
Process.exit!(true)
参数 status 的值 true 和 false 分别表示成功和失败；整数值的含义取决于系统。
源代码
static VALUE
rb_f_fork(VALUE obj)
{
rb_pid_t pid;
pid = rb_call_proc__fork();
if (pid == 0) {
if (rb_block_given_p()) {
int status;
rb_protect(rb_yield, Qundef, &status);
ruby_stop(status);
}
return Qnil;
}
return PIDT2NUM(pid);
}
创建一个子进程。
如果给出了块，则在子进程中运行该块；在块退出时，子进程以零状态终止
puts "Before the fork: #{Process.pid}" fork do puts "In the child process: #{Process.pid}" end # => 382141 puts "After the fork: #{Process.pid}"
输出
Before the fork: 420496 After the fork: 420496 In the child process: 420520
如果没有给出块，则 fork 调用会返回两次
-
一次在父进程中，返回子进程的 pid。
-
一次在子进程中，返回
nil。
示例
puts "This is the first line before the fork (pid #{Process.pid})" puts fork puts "This is the second line after the fork (pid #{Process.pid})"
输出
This is the first line before the fork (pid 420199) 420223 This is the second line after the fork (pid 420199) This is the second line after the fork (pid 420223)
在这两种情况下，子进程都可以使用 Kernel.exit! 退出，以避免调用 Kernel#at_exit。
为了避免僵尸进程，父进程应调用以下之一
-
Process.wait，以收集其子进程的终止状态。 -
Process.detach，以注册对其状态的不感兴趣。
调用 fork 的线程是创建的子进程中唯一的线程；fork 不会复制其他线程。
请注意，方法 fork 在某些平台上可用，但在其他平台上不可用
Process.respond_to?(:fork) # => true # Would be false on some.
如果不可用，可以使用 ::spawn 代替 fork。
源代码
# File kernel.rb, line 67 def frozen? Primitive.attr! :leaf Primitive.cexpr! 'rb_obj_frozen_p(self)' end
返回 obj 的冻结状态。
a = [ "a", "b", "c" ] a.freeze #=> ["a", "b", "c"] a.frozen? #=> true
源代码
static VALUE
rb_f_gets(int argc, VALUE *argv, VALUE recv)
{
if (recv == argf) {
return argf_gets(argc, argv, argf);
}
return forward(argf, idGets, argc, argv);
}
从 ARGV（或 $*）中的文件列表中返回（并赋值给 $_）下一行，如果命令行中没有文件，则从标准输入返回。在文件末尾返回 nil。可选参数指定记录分隔符。分隔符包含在每个记录的内容中。nil 分隔符读取整个内容，零长度分隔符一次读取一个段落的输入，其中段落由两个连续的换行符分隔。如果第一个参数是整数，或者给出了可选的第二个参数，则返回的字符串的长度不会超过给定值（以字节为单位）。如果 ARGV 中存在多个文件名，gets(nil) 将一次读取一个文件的内容。
ARGV << "testfile" print while gets
产生
This is line one This is line two This is line three And so on...
在 Ruby 社区中，使用 $_ 作为隐式参数的编程风格逐渐不受欢迎。
源代码
static VALUE
f_global_variables(VALUE _)
{
return rb_f_global_variables();
}
返回全局变量名称的数组。这包括特殊的正则表达式全局变量，如 $~ 和 $+，但不包括编号的正则表达式全局变量（$1、$2 等）。
global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
源代码
static VALUE
rb_f_gsub(int argc, VALUE *argv, VALUE _)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("gsub"), argc, argv);
rb_lastline_set(str);
return str;
}
等效于 $_.gsub...，但如果发生替换，则会更新 $_。仅当指定了 -p/-n 命令行选项时可用。
源代码
static VALUE
rb_f_iterator_p(VALUE self)
{
rb_warn_deprecated("iterator?", "block_given?");
return rb_f_block_given_p(self);
}
已弃用。请改用 block_given?。
源代码
源代码
static VALUE
rb_f_load(int argc, VALUE *argv, VALUE _)
{
VALUE fname, wrap, path, orig_fname;
rb_scan_args(argc, argv, "11", &fname, &wrap);
orig_fname = rb_get_path_check_to_string(fname);
fname = rb_str_encode_ospath(orig_fname);
RUBY_DTRACE_HOOK(LOAD_ENTRY, RSTRING_PTR(orig_fname));
path = rb_find_file(fname);
if (!path) {
if (!rb_file_load_ok(RSTRING_PTR(fname)))
load_failed(orig_fname);
path = fname;
}
rb_load_internal(path, wrap);
RUBY_DTRACE_HOOK(LOAD_RETURN, RSTRING_PTR(orig_fname));
return Qtrue;
}
加载并执行文件 filename 中的 Ruby 程序。
如果文件名是绝对路径（例如，以“/”开头），则将使用绝对路径直接加载该文件。
如果文件名是显式的相对路径（例如，以“./”或“../”开头），则将使用相对于当前目录的相对路径加载该文件。
否则，将在 $LOAD_PATH ($:) 中列出的库目录中搜索该文件。如果在目录中找到该文件，它将尝试加载相对于该目录的文件。如果在 $LOAD_PATH 中的任何目录中都找不到该文件，则将使用相对于当前目录的相对路径加载该文件。
如果尝试加载文件时该文件不存在，则会引发 LoadError。
如果可选的 wrap 参数为 true，则加载的脚本将在匿名模块下执行。如果可选的 wrap 参数是模块，则加载的脚本将在给定的模块下执行。在任何情况下，加载文件中的任何局部变量都不会传播到加载环境。
源代码
static VALUE
rb_f_local_variables(VALUE _)
{
struct local_var_list vars;
rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp));
unsigned int i;
local_var_list_init(&vars);
while (cfp) {
if (cfp->iseq) {
for (i = 0; i < ISEQ_BODY(cfp->iseq)->local_table_size; i++) {
local_var_list_add(&vars, ISEQ_BODY(cfp->iseq)->local_table[i]);
}
}
if (!VM_ENV_LOCAL_P(cfp->ep)) {
/* block */
const VALUE *ep = VM_CF_PREV_EP(cfp);
if (vm_collect_local_variables_in_heap(ep, &vars)) {
break;
}
else {
while (cfp->ep != ep) {
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
}
}
}
else {
break;
}
}
return local_var_list_finish(&vars);
}
返回当前局部变量的名称。
fred = 1 for i in 1..10 # ... end local_variables #=> [:fred, :i]
源代码
# File kernel.rb, line 160 def loop Primitive.attr! :inline_block unless defined?(yield) return Primitive.cexpr! 'SIZED_ENUMERATOR(self, 0, 0, rb_f_loop_size)' end begin while true yield end rescue StopIteration => e e.result end end
重复执行块。
如果没有给出块，则改为返回一个枚举器。
loop do print "Input: " line = gets break if !line or line =~ /^q/i # ... end
在块中引发的 StopIteration 会中断循环。在这种情况下，loop 返回存储在异常中的“结果”值。
enum = Enumerator.new { |y| y << "one" y << "two" :ok } result = loop { puts enum.next } #=> :ok
源代码
static VALUE
rb_f_open(int argc, VALUE *argv, VALUE _)
{
ID to_open = 0;
int redirect = FALSE;
if (argc >= 1) {
CONST_ID(to_open, "to_open");
if (rb_respond_to(argv[0], to_open)) {
redirect = TRUE;
}
else {
VALUE tmp = argv[0];
FilePathValue(tmp);
if (NIL_P(tmp)) {
redirect = TRUE;
}
else {
VALUE cmd = check_pipe_command(tmp);
if (!NIL_P(cmd)) {
// TODO: when removed in 4.0, update command_injection.rdoc
rb_warn_deprecated_to_remove_at(4.0, "Calling Kernel#open with a leading '|'", "IO.popen");
argv[0] = cmd;
return rb_io_s_popen(argc, argv, rb_cIO);
}
}
}
}
if (redirect) {
VALUE io = rb_funcallv_kw(argv[0], to_open, argc-1, argv+1, RB_PASS_CALLED_KEYWORDS);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, io, io_close, io);
}
return io;
}
return rb_io_s_open(argc, argv, rb_cFile);
}
创建一个连接到给定文件的 IO 对象。
如果使用不受信任的输入调用此方法，则此方法可能存在安全漏洞；请参阅命令注入。
如果没有给出块，则返回文件流
open('t.txt') # => #<File:t.txt>
如果给出了块，则使用打开的文件流调用该块，然后关闭该流
open('t.txt') {|f| p f } # => #<File:t.txt (closed)>
输出
#<File:t.txt>
有关详细信息，请参阅 File.open。
源代码
static VALUE
rb_f_p(int argc, VALUE *argv, VALUE self)
{
int i;
for (i=0; i<argc; i++) {
VALUE inspected = rb_obj_as_string(rb_inspect(argv[i]));
rb_uninterruptible(rb_p_write, inspected);
}
return rb_p_result(argc, argv);
}
对于每个对象 obj，执行
$stdout.write(obj.inspect, "\n")
如果给出一个对象，则返回该对象；如果给出多个对象，则返回包含这些对象的数组；如果没有给出对象，则返回 nil。
示例
r = Range.new(0, 4) p r # => 0..4 p [r, r, r] # => [0..4, 0..4, 0..4] p # => nil
输出
0..4 [0..4, 0..4, 0..4]
Kernel#p 旨在用于调试目的。Ruby 实现可以定义 Kernel#p 为全部或部分不可中断。在 CRuby 上，Kernel#p 的数据写入是不可中断的。
源代码
# File lib/pp.rb, line 685 def pretty_inspect PP.pp(self, ''.dup) end
返回一个漂亮打印的对象作为字符串。
有关更多信息，请参阅 PP 模块。
源代码
static VALUE
rb_f_print(int argc, const VALUE *argv, VALUE _)
{
rb_io_print(argc, argv, rb_ractor_stdout());
return Qnil;
}
等效于 $stdout.print(*objects)，此方法是写入 $stdout 的直接方法。
将给定的对象写入 $stdout；返回 nil。如果输出记录分隔符 $OUTPUT_RECORD_SEPARATOR $\）不为 nil，则附加该分隔符。
如果给出了参数 objects，则对于每个对象
-
如果不是字符串，则通过其方法
to_s进行转换。 -
写入
stdout。 -
如果不是最后一个对象，则写入输出字段分隔符
$OUTPUT_FIELD_SEPARATOR（如果$,不为nil，则为$,）。
使用默认分隔符
objects = [0, 0.0, Rational(0, 1), Complex(0, 0), :zero, 'zero'] $OUTPUT_RECORD_SEPARATOR $OUTPUT_FIELD_SEPARATOR print(*objects)
输出
nil nil 00.00/10+0izerozero
使用指定的分隔符
$OUTPUT_RECORD_SEPARATOR = "\n" $OUTPUT_FIELD_SEPARATOR = ',' print(*objects)
输出
0,0.0,0/1,0+0i,zero,zero
如果没有给出参数，则写入 $_ 的内容（通常是最近的用户输入）
gets # Sets $_ to the most recent user input. print # Prints $_.
源代码
static VALUE
rb_f_printf(int argc, VALUE *argv, VALUE _)
{
VALUE out;
if (argc == 0) return Qnil;
if (RB_TYPE_P(argv[0], T_STRING)) {
out = rb_ractor_stdout();
}
else {
out = argv[0];
argv++;
argc--;
}
rb_io_write(out, rb_f_sprintf(argc, argv));
return Qnil;
}
等效于
io.write(sprintf(format_string, *objects))
有关 format_string 的详细信息，请参阅 格式规范。
如果只有一个参数 format_string，则将 objects 格式化为字符串，然后将格式化后的字符串写入 $stdout
printf('%4.4d %10s %2.2f', 24, 24, 24.0)
输出（在 $stdout 上）
0024 24 24.00#
如果给出了参数 io 和 format_string，则将 objects 格式化为字符串，然后将格式化后的字符串写入 io
printf($stderr, '%4.4d %10s %2.2f', 24, 24, 24.0)
输出（在 $stderr 上）
0024 24 24.00# => nil
如果没有参数，则不执行任何操作。
源代码
static VALUE
f_proc(VALUE _)
{
return proc_new(rb_cProc, FALSE);
}
等效于 Proc.new。
源代码
static VALUE
rb_f_putc(VALUE recv, VALUE ch)
{
VALUE r_stdout = rb_ractor_stdout();
if (recv == r_stdout) {
return rb_io_putc(recv, ch);
}
return forward(r_stdout, rb_intern("putc"), 1, &ch);
}
等效于
$stdout.putc(int)
有关多字节字符的重要信息，请参阅 IO#putc。
源代码
static VALUE
rb_f_puts(int argc, VALUE *argv, VALUE recv)
{
VALUE r_stdout = rb_ractor_stdout();
if (recv == r_stdout) {
return rb_io_puts(argc, argv, recv);
}
return forward(r_stdout, rb_intern("puts"), argc, argv);
}
等效于
$stdout.puts(objects)
源代码
static VALUE
f_raise(int c, VALUE *v, VALUE _)
{
return rb_f_raise(c, v);
}
抛出一个异常；参见 异常。
参数 exception 设置新异常的类；它应该是 Exception 类或其子类之一（最常见的是 RuntimeError 或 StandardError），或者是这些类之一的实例。
begin raise(StandardError) rescue => x p x.class end # => StandardError
参数 message 设置新异常中存储的消息，该消息可以通过方法 Exception#message 获取；消息必须是可转换为字符串的对象或 nil。
begin raise(StandardError, 'Boom') rescue => x p x.message end # => "Boom"
如果未给出参数 message，则消息为异常类名称。
参见 消息。
参数 backtrace 可用于修改新异常的回溯信息，该回溯信息由 Exception#backtrace 和 Exception#backtrace_locations 报告；回溯信息必须是一个 Thread::Backtrace::Location 数组、一个字符串数组、单个字符串或 nil。
使用 Thread::Backtrace::Location 实例的数组是最一致的选择，应尽可能首选。必要的值可以从 caller_locations 获取，或者从另一个错误中的 Exception#backtrace_locations 复制。
begin do_some_work() rescue ZeroDivisionError => ex raise(LogicalError, "You have an error in your math", ex.backtrace_locations) end
已引发错误的 Exception#backtrace 和 Exception#backtrace_locations 的方式都设置为相同的回溯信息。
当所需的堆栈位置不可用且应从头开始构建时，可以使用字符串数组或单个字符串。在这种情况下，仅设置 Exception#backtrace。
begin raise(StandardError, 'Boom', %w[dsl.rb:3 framework.rb:1]) rescue => ex p ex.backtrace # => ["dsl.rb:3", "framework.rb:1"] p ex.backtrace_locations # => nil end
如果未给出参数 backtrace，则回溯信息会根据从调用堆栈派生的 Thread::Backtrace::Location 对象数组进行设置。
参见 回溯信息。
关键字参数 cause 设置新异常中存储的原因，该原因可以通过方法 Exception#cause 获取；原因必须是异常对象（Exception 或其子类之一），或 nil。
begin raise(StandardError, cause: RuntimeError.new) rescue => x p x.cause end # => #<RuntimeError: RuntimeError>
如果未给出关键字参数 cause，则原因的值为 $!。
参见 原因。
在可选的调用序列中，如果未给出参数 exception，则会引发一个由 $! 给出的类的新异常，如果 $! 为 nil，则引发 RuntimeError 类的异常。
begin raise rescue => x p x end # => RuntimeError
在未给出参数 exception 的情况下，可以给出参数 message 和关键字参数 cause，但不能给出参数 backtrace。
源代码
static VALUE
rb_f_rand(int argc, VALUE *argv, VALUE obj)
{
VALUE vmax;
rb_random_t *rnd = rand_start(default_rand());
if (rb_check_arity(argc, 0, 1) && !NIL_P(vmax = argv[0])) {
VALUE v = rand_range(obj, rnd, vmax);
if (v != Qfalse) return v;
vmax = rb_to_int(vmax);
if (vmax != INT2FIX(0)) {
v = rand_int(obj, rnd, vmax, 0);
if (!NIL_P(v)) return v;
}
}
return DBL2NUM(random_real(obj, rnd, TRUE));
}
如果调用时没有参数，或者 max.to_i.abs == 0，则 rand 返回一个介于 0.0 和 1.0 之间的伪随机浮点数，包括 0.0 但不包括 1.0。
rand #=> 0.2725926052826416
当 max.abs 大于或等于 1 时，rand 返回一个大于或等于 0 且小于 max.to_i.abs 的伪随机整数。
rand(100) #=> 12
当 max 是一个 Range 时，rand 返回一个随机数，其中 range.member?(number) == true。
允许 max 为负数或浮点数，但可能会产生令人惊讶的结果。
rand(-100) # => 87 rand(-0.5) # => 0.8130921818028143 rand(1.9) # equivalent to rand(1), which is always 0
Kernel.srand 可用于确保在程序的各个不同运行之间，随机数序列是可重复的。
另请参见 Random.rand。
源代码
static VALUE
rb_f_readline(int argc, VALUE *argv, VALUE recv)
{
if (recv == argf) {
return argf_readline(argc, argv, argf);
}
return forward(argf, rb_intern("readline"), argc, argv);
}
等同于方法 Kernel#gets，不同之处在于，如果在流末尾调用它，则会引发异常。
$ cat t.txt | ruby -e "p readlines; readline" ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"] in `readline': end of file reached (EOFError)
可选的关键字参数 chomp 指定是否要省略行分隔符。
源代码
static VALUE
rb_f_readlines(int argc, VALUE *argv, VALUE recv)
{
if (recv == argf) {
return argf_readlines(argc, argv, argf);
}
return forward(argf, rb_intern("readlines"), argc, argv);
}
返回一个数组，其中包含通过调用 Kernel#gets 返回的行，直到达到流的末尾；（请参见 行 IO）。
仅给出字符串参数 sep 时，返回由行分隔符 sep 确定的剩余行，如果没有，则返回 nil；请参见 行分隔符。
# Default separator. $ cat t.txt | ruby -e "p readlines" ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"] # Specified separator. $ cat t.txt | ruby -e "p readlines 'li'" ["First li", "ne\nSecond li", "ne\n\nFourth li", "ne\nFifth li", "ne\n"] # Get-all separator. $ cat t.txt | ruby -e "p readlines nil" ["First line\nSecond line\n\nFourth line\nFifth line\n"] # Get-paragraph separator. $ cat t.txt | ruby -e "p readlines ''" ["First line\nSecond line\n\n", "Fourth line\nFifth line\n"]
仅给出整数参数 limit 时，限制行中的字节数；请参见 行限制。
$cat t.txt | ruby -e "p readlines 10" ["First line", "\n", "Second lin", "e\n", "\n", "Fourth lin", "e\n", "Fifth line", "\n"] $cat t.txt | ruby -e "p readlines 11" ["First line\n", "Second line", "\n", "\n", "Fourth line", "\n", "Fifth line\n"] $cat t.txt | ruby -e "p readlines 12" ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]
给出参数 sep 和 limit 时，会组合这两种行为（请参见 行分隔符和行限制）。
可选的关键字参数 chomp 指定是否要省略行分隔符。
$ cat t.txt | ruby -e "p readlines(chomp: true)" ["First line", "Second line", "", "Fourth line", "Fifth line"]
可选的关键字参数 enc_opts 指定编码选项；请参见 编码选项。
源代码
VALUE
rb_f_require_relative(VALUE obj, VALUE fname)
{
VALUE base = rb_current_realfilepath();
if (NIL_P(base)) {
rb_loaderror("cannot infer basepath");
}
base = rb_file_dirname(base);
return rb_require_string_internal(rb_file_absolute_path(fname, base), false);
}
Ruby 尝试加载相对于包含请求文件的目录的名为 string 的库。如果文件不存在，则会引发 LoadError。如果文件已加载，则返回 true，如果文件之前已加载，则返回 false。
源代码
static VALUE
rb_f_select(int argc, VALUE *argv, VALUE obj)
{
VALUE scheduler = rb_fiber_scheduler_current();
if (scheduler != Qnil) {
// It's optionally supported.
VALUE result = rb_fiber_scheduler_io_selectv(scheduler, argc, argv);
if (!UNDEF_P(result)) return result;
}
VALUE timeout;
struct select_args args;
struct timeval timerec;
int i;
rb_scan_args(argc, argv, "13", &args.read, &args.write, &args.except, &timeout);
if (NIL_P(timeout)) {
args.timeout = 0;
}
else {
timerec = rb_time_interval(timeout);
args.timeout = &timerec;
}
for (i = 0; i < numberof(args.fdsets); ++i)
rb_fd_init(&args.fdsets[i]);
return rb_ensure(select_call, (VALUE)&args, select_end, (VALUE)&args);
}
调用系统调用 select(2)，该调用监视多个文件描述符，等待直到一个或多个文件描述符准备好进行某些类别的 I/O 操作。
并非在所有平台上都实现。
每个参数 read_ios、write_ios 和 error_ios 都是 IO 对象的数组。
参数 timeout 是一个数值（例如整数或浮点数），以秒为单位的超时时间间隔。
该方法监视所有三个数组中给定的 IO 对象，等待某些对象准备就绪；返回一个包含 3 个元素的数组，其元素为：
-
read_ios中准备好进行读取的对象数组。 -
write_ios中准备好进行写入的对象数组。 -
error_ios中有待处理异常的对象数组。
如果在给定的 timeout 内没有对象准备就绪，则返回 nil。
IO.select 会窥视 IO 对象的缓冲区以测试可读性。如果 IO 缓冲区不为空，则 IO.select 会立即通知可读性。这种“窥视”仅发生在 IO 对象上。它不会发生在类似 IO 的对象上，例如 OpenSSL::SSL::SSLSocket。
使用 IO.select 的最佳方式是在调用 read_nonblock、write_nonblock 等非阻塞方法之后调用它。这些方法会引发一个由 IO::WaitReadable 或 IO::WaitWritable 扩展的异常。这些模块通知调用者应如何使用 IO.select 等待。如果引发了 IO::WaitReadable，则调用者应等待读取。如果引发了 IO::WaitWritable，则调用者应等待写入。
因此，可以使用 read_nonblock 和 IO.select 模拟阻塞读取 (readpartial)，如下所示
begin result = io_like.read_nonblock(maxlen) rescue IO::WaitReadable IO.select([io_like]) retry rescue IO::WaitWritable IO.select(nil, [io_like]) retry end
特别是，对于像 OpenSSL::SSL::SSLSocket 这样的 IO 类对象，首选非阻塞方法和 IO.select 的组合。它具有 to_io 方法来返回底层的 IO 对象。IO.select 调用 to_io 以获取要等待的文件描述符。
这意味着由 IO.select 通知的可读性并不意味着来自 OpenSSL::SSL::SSLSocket 对象的可读性。
最可能的情况是 OpenSSL::SSL::SSLSocket 缓冲了一些数据。IO.select 看不到缓冲区。因此，当 OpenSSL::SSL::SSLSocket#readpartial 不阻塞时，IO.select 可能会阻塞。
但是，还存在一些更复杂的情况。
SSL 是一种协议，它是记录序列。该记录由多个字节组成。因此，SSL 的远程端会发送部分记录，IO.select 会通知可读性，但 OpenSSL::SSL::SSLSocket 无法解密字节，并且 OpenSSL::SSL::SSLSocket#readpartial 将会阻塞。
此外，远程端可以请求 SSL 重新协商，这会强制本地 SSL 引擎写入一些数据。这意味着 OpenSSL::SSL::SSLSocket#readpartial 可能会调用写入系统调用，并且可能会阻塞。在这种情况下，OpenSSL::SSL::SSLSocket#read_nonblock 会引发 IO::WaitWritable，而不是阻塞。因此，如上例所示，调用者应等待准备好进行写入。
当多个进程从流中读取时，非阻塞方法和 IO.select 的组合对于诸如 tty、管道套接字之类的流也很有用。
最后，即使对于单个进程，Linux 内核开发人员也不保证 select(2) 的可读性意味着后续 read(2) 的可读性；请参见 select(2)。
在 IO#readpartial 之前调用 IO.select 通常会很好地工作。但是，这不是使用 IO.select 的最佳方式。
select(2) 通知的可写性不显示有多少字节是可写的。IO#write 方法会阻塞，直到写入给定的整个字符串。因此，在 IO.select 通知可写性后，IO#write(两个或多个字节) 可能会阻塞。需要使用 IO#write_nonblock 以避免阻塞。
可以使用 write_nonblock 和 IO.select 模拟阻塞写入 (write)，如下所示：还应为 OpenSSL::SSL::SSLSocket 中的 SSL 重新协商救援 IO::WaitReadable。
while 0 < string.bytesize begin written = io_like.write_nonblock(string) rescue IO::WaitReadable IO.select([io_like]) retry rescue IO::WaitWritable IO.select(nil, [io_like]) retry end string = string.byteslice(written..-1) end
示例
rp, wp = IO.pipe mesg = "ping " 100.times { # IO.select follows IO#read. Not the best way to use IO.select. rs, ws, = IO.select([rp], [wp]) if r = rs[0] ret = r.read(5) print ret case ret when /ping/ mesg = "pong\n" when /pong/ mesg = "ping " end end if w = ws[0] w.write(mesg) end }
输出
ping pong ping pong ping pong (snipped) ping
源代码
static VALUE
set_trace_func(VALUE obj, VALUE trace)
{
rb_remove_event_hook(call_trace_func);
if (NIL_P(trace)) {
return Qnil;
}
if (!rb_obj_is_proc(trace)) {
rb_raise(rb_eTypeError, "trace_func needs to be Proc");
}
rb_add_event_hook(call_trace_func, RUBY_EVENT_ALL, trace);
return trace;
}
建立 proc 作为跟踪处理程序，如果参数为 nil，则禁用跟踪。
注意：此方法已过时，请改用 TracePoint。
proc 最多接受六个参数
-
事件名称字符串
-
文件名字符串
-
行号
-
方法名称符号或 nil
-
绑定或 nil
-
类、模块或 nil
每当发生事件时，都会调用 proc。
事件为
"c-call"-
调用 C 语言例程
"c-return"-
从 C 语言例程返回
"call"-
调用 Ruby 方法
"class"-
开始类或模块定义
"end"-
完成类或模块定义
"line"-
在新行上执行代码
"raise"-
引发异常
"return"-
从 Ruby 方法返回
在 proc 的上下文中禁用跟踪。
class Test def test a = 1 b = 2 end end set_trace_func proc { |event, file, line, id, binding, class_or_module| printf "%8s %s:%-2d %16p %14p\n", event, file, line, id, class_or_module } t = Test.new t.test
产生
c-return prog.rb:8 :set_trace_func Kernel
line prog.rb:11 nil nil
c-call prog.rb:11 :new Class
c-call prog.rb:11 :initialize BasicObject
c-return prog.rb:11 :initialize BasicObject
c-return prog.rb:11 :new Class
line prog.rb:12 nil nil
call prog.rb:2 :test Test
line prog.rb:3 :test Test
line prog.rb:4 :test Test
return prog.rb:5 :test Test
源代码
static VALUE
rb_f_sleep(int argc, VALUE *argv, VALUE _)
{
time_t beg = time(0);
VALUE scheduler = rb_fiber_scheduler_current();
if (scheduler != Qnil) {
rb_fiber_scheduler_kernel_sleepv(scheduler, argc, argv);
}
else {
if (argc == 0 || (argc == 1 && NIL_P(argv[0]))) {
rb_thread_sleep_forever();
}
else {
rb_check_arity(argc, 0, 1);
rb_thread_wait_for(rb_time_interval(argv[0]));
}
}
time_t end = time(0) - beg;
return TIMET2NUM(end);
}
将当前线程的执行挂起指定 secs 参数指定的秒数，如果 secs 为 nil，则永远挂起；返回挂起的整数秒数（四舍五入）。
Time.new # => 2008-03-08 19:56:19 +0900 sleep 1.2 # => 1 Time.new # => 2008-03-08 19:56:20 +0900 sleep 1.9 # => 2 Time.new # => 2008-03-08 19:56:22 +0900
源代码
static VALUE
rb_f_spawn(int argc, VALUE *argv, VALUE _)
{
rb_pid_t pid;
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
VALUE execarg_obj, fail_str;
struct rb_execarg *eargp;
execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
eargp = rb_execarg_get(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
pid = rb_execarg_spawn(execarg_obj, errmsg, sizeof(errmsg));
if (pid == -1) {
int err = errno;
rb_exec_fail(eargp, err, errmsg);
RB_GC_GUARD(execarg_obj);
rb_syserr_fail_str(err, fail_str);
}
#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
return PIDT2NUM(pid);
#else
return Qnil;
#endif
}
通过在该进程中执行以下操作之一来创建新的子进程：
-
将字符串
command_line传递给 shell。 -
调用
exe_path上的可执行文件。
如果使用不受信任的输入调用此方法，则此方法可能存在安全漏洞；请参阅命令注入。
返回新进程的进程 ID (pid)，而不等待其完成。
为了避免僵尸进程，父进程应调用以下之一
-
Process.wait，以收集其子进程的终止状态。 -
Process.detach，以注册对其状态的不感兴趣。
新进程是使用 exec 系统调用 创建的；它可能会从调用程序继承其一些环境（可能包括打开的文件描述符）。
如果给出参数 env，它是一个影响新进程的 ENV 的哈希；请参阅 执行环境。
参数 options 是新进程的选项哈希；请参阅 执行选项。
第一个必需参数是以下之一
-
command_line，如果它是一个字符串，并且如果它以 shell 保留字或特殊内置字开头，或者如果它包含一个或多个元字符。 -
否则为
exe_path。
参数 command_line
字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置字开头或包含元字符
spawn('if true; then echo "Foo"; fi') # => 798847 # Shell reserved word. Process.wait # => 798847 spawn('exit') # => 798848 # Built-in. Process.wait # => 798848 spawn('date > /tmp/date.tmp') # => 798879 # Contains meta character. Process.wait # => 798849 spawn('date > /nop/date.tmp') # => 798882 # Issues error message. Process.wait # => 798882
命令行也可能包含命令的参数和选项
spawn('echo "Foo"') # => 799031 Process.wait # => 799031
输出
Foo
有关 shell 的详细信息，请参阅 执行 Shell。
如果新进程无法执行，则引发异常。
参数 exe_path
参数 exe_path 是以下之一
-
要调用的可执行文件的字符串路径。
-
一个包含要调用的可执行文件路径和用作执行进程名称的字符串的 2 元素数组。
spawn('/usr/bin/date') # Path to date on Unix-style system. Process.wait
输出
Mon Aug 28 11:43:10 AM CDT 2023
Ruby 直接调用可执行文件。此形式不使用 shell；有关注意事项，请参阅 参数 args。
如果给出了一个或多个 args，则每个都是要传递给可执行文件的参数或选项
spawn('echo', 'C*') # => 799392 Process.wait # => 799392 spawn('echo', 'hello', 'world') # => 799393 Process.wait # => 799393
输出
C* hello world
如果新进程无法执行，则引发异常。
源代码
static VALUE
f_sprintf(int c, const VALUE *v, VALUE _)
{
return rb_f_sprintf(c, v);
}
返回将 objects 格式化为 format_string 后得到的字符串。
有关 format_string 的详细信息，请参阅 格式规范。
源代码
static VALUE
rb_f_srand(int argc, VALUE *argv, VALUE obj)
{
VALUE seed, old;
rb_random_mt_t *r = rand_mt_start(default_rand());
if (rb_check_arity(argc, 0, 1) == 0) {
seed = random_seed(obj);
}
else {
seed = rb_to_int(argv[0]);
}
old = r->base.seed;
rand_init(&random_mt_if, &r->base, seed);
r->base.seed = seed;
return old;
}
用 number 播种系统伪随机数生成器。返回之前的种子值。
如果省略 number，则使用操作系统提供的熵源来播种生成器（在 Unix 系统上为 /dev/urandom，在 Windows 上为 RSA 加密提供程序），然后将其与时间、进程 ID 和序列号组合。
可以使用 srand 来确保程序的不同运行之间伪随机数序列的可重复性。通过将种子设置为已知值，可以在测试期间使程序具有确定性。
srand 1234 # => 268519324636777531569100071560086917274 [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319] [ rand(10), rand(1000) ] # => [4, 664] srand 1234 # => 1234 [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
源代码
static VALUE
rb_f_sub(int argc, VALUE *argv, VALUE _)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("sub"), argc, argv);
rb_lastline_set(str);
return str;
}
等效于 $_.sub(args)，但如果发生替换，则会更新 $_。仅当指定 -p/-n 命令行选项时可用。
源代码
static VALUE
rb_f_syscall(int argc, VALUE *argv, VALUE _)
{
VALUE arg[8];
#if SIZEOF_VOIDP == 8 && defined(HAVE___SYSCALL) && SIZEOF_INT != 8 /* mainly *BSD */
# define SYSCALL __syscall
# define NUM2SYSCALLID(x) NUM2LONG(x)
# define RETVAL2NUM(x) LONG2NUM(x)
# if SIZEOF_LONG == 8
long num, retval = -1;
# elif SIZEOF_LONG_LONG == 8
long long num, retval = -1;
# else
# error ---->> it is asserted that __syscall takes the first argument and returns retval in 64bit signed integer. <<----
# endif
#elif defined(__linux__)
# define SYSCALL syscall
# define NUM2SYSCALLID(x) NUM2LONG(x)
# define RETVAL2NUM(x) LONG2NUM(x)
/*
* Linux man page says, syscall(2) function prototype is below.
*
* int syscall(int number, ...);
*
* But, it's incorrect. Actual one takes and returned long. (see unistd.h)
*/
long num, retval = -1;
#else
# define SYSCALL syscall
# define NUM2SYSCALLID(x) NUM2INT(x)
# define RETVAL2NUM(x) INT2NUM(x)
int num, retval = -1;
#endif
int i;
if (RTEST(ruby_verbose)) {
rb_category_warning(RB_WARN_CATEGORY_DEPRECATED,
"We plan to remove a syscall function at future release. DL(Fiddle) provides safer alternative.");
}
if (argc == 0)
rb_raise(rb_eArgError, "too few arguments for syscall");
if (argc > numberof(arg))
rb_raise(rb_eArgError, "too many arguments for syscall");
num = NUM2SYSCALLID(argv[0]); ++argv;
for (i = argc - 1; i--; ) {
VALUE v = rb_check_string_type(argv[i]);
if (!NIL_P(v)) {
StringValue(v);
rb_str_modify(v);
arg[i] = (VALUE)StringValueCStr(v);
}
else {
arg[i] = (VALUE)NUM2LONG(argv[i]);
}
}
switch (argc) {
case 1:
retval = SYSCALL(num);
break;
case 2:
retval = SYSCALL(num, arg[0]);
break;
case 3:
retval = SYSCALL(num, arg[0],arg[1]);
break;
case 4:
retval = SYSCALL(num, arg[0],arg[1],arg[2]);
break;
case 5:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3]);
break;
case 6:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4]);
break;
case 7:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
break;
case 8:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
break;
}
if (retval == -1)
rb_sys_fail(0);
return RETVAL2NUM(retval);
#undef SYSCALL
#undef NUM2SYSCALLID
#undef RETVAL2NUM
}
调用 Posix 系统调用 syscall(2)，它调用指定的函数。
调用由 integer_callno 标识的操作系统函数；返回函数的结果，如果失败则引发 SystemCallError。调用的效果取决于平台。参数和返回值取决于平台。
对于每个 arguments：如果它是一个整数，则直接传递；如果它是一个字符串，则将其解释为二进制字节序列。最多可以有九个这样的参数。
参数 integer_callno 和 argument 以及返回值都取决于平台。
注意：Method syscall 本质上是不安全且不可移植的。DL (Fiddle) 库更适合用于更安全和更具可移植性的编程。
并非在所有平台上都实现。
源代码
static VALUE
rb_f_system(int argc, VALUE *argv, VALUE _)
{
rb_thread_t *th = GET_THREAD();
VALUE execarg_obj = rb_execarg_new(argc, argv, TRUE, TRUE);
struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
struct rb_process_status status = {0};
eargp->status = &status;
last_status_clear(th);
// This function can set the thread's last status.
// May be different from waitpid_state.pid on exec failure.
rb_pid_t pid = rb_execarg_spawn(execarg_obj, 0, 0);
if (pid > 0) {
VALUE status = rb_process_status_wait(pid, 0);
struct rb_process_status *data = rb_check_typeddata(status, &rb_process_status_type);
// Set the last status:
rb_obj_freeze(status);
th->last_status = status;
if (data->status == EXIT_SUCCESS) {
return Qtrue;
}
if (data->error != 0) {
if (eargp->exception) {
VALUE command = eargp->invoke.sh.shell_script;
RB_GC_GUARD(execarg_obj);
rb_syserr_fail_str(data->error, command);
}
else {
return Qnil;
}
}
else if (eargp->exception) {
VALUE command = eargp->invoke.sh.shell_script;
VALUE str = rb_str_new_cstr("Command failed with");
rb_str_cat_cstr(pst_message_status(str, data->status), ": ");
rb_str_append(str, command);
RB_GC_GUARD(execarg_obj);
rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, str));
}
else {
return Qfalse;
}
RB_GC_GUARD(status);
}
if (eargp->exception) {
VALUE command = eargp->invoke.sh.shell_script;
RB_GC_GUARD(execarg_obj);
rb_syserr_fail_str(errno, command);
}
else {
return Qnil;
}
}
通过在该进程中执行以下操作之一来创建新的子进程：
-
将字符串
command_line传递给 shell。 -
调用
exe_path上的可执行文件。
如果使用不受信任的输入调用此方法，则此方法可能存在安全漏洞；请参阅命令注入。
返回
-
如果命令以状态零退出，则返回
true。 -
如果退出状态为非零整数，则返回
false。 -
如果命令无法执行，则返回
nil。
如果关键字参数 exception 设置为 true，则引发异常（而不是返回 false 或 nil）。
将命令的错误状态分配给 $?。
新进程是使用 system 系统调用 创建的；它可能会从调用程序继承一些环境（可能包括打开的文件描述符）。
如果给出参数 env，它是一个影响新进程的 ENV 的哈希；请参阅 执行环境。
参数 options 是新进程的选项哈希；请参阅 执行选项。
第一个必需参数是以下之一
-
command_line，如果它是一个字符串，并且如果它以 shell 保留字或特殊内置字开头，或者如果它包含一个或多个元字符。 -
否则为
exe_path。
参数 command_line
字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置字开头或包含元字符
system('if true; then echo "Foo"; fi') # => true # Shell reserved word. system('exit') # => true # Built-in. system('date > /tmp/date.tmp') # => true # Contains meta character. system('date > /nop/date.tmp') # => false system('date > /nop/date.tmp', exception: true) # Raises RuntimeError.
将命令的错误状态分配给 $?
system('exit') # => true # Built-in. $? # => #<Process::Status: pid 640610 exit 0> system('date > /nop/date.tmp') # => false $? # => #<Process::Status: pid 640742 exit 2>
命令行也可能包含命令的参数和选项
system('echo "Foo"') # => true
输出
Foo
有关 shell 的详细信息，请参阅 执行 Shell。
如果新进程无法执行，则引发异常。
参数 exe_path
参数 exe_path 是以下之一
-
要调用的可执行文件的字符串路径。
-
一个包含可执行文件路径和要用作执行进程名称的字符串的 2 元素数组。
示例
system('/usr/bin/date') # => true # Path to date on Unix-style system. system('foo') # => nil # Command failed.
输出
Mon Aug 28 11:43:10 AM CDT 2023
将命令的错误状态分配给 $?
system('/usr/bin/date') # => true $? # => #<Process::Status: pid 645605 exit 0> system('foo') # => nil $? # => #<Process::Status: pid 645608 exit 127>
Ruby 直接调用可执行文件。此形式不使用 shell；有关注意事项，请参阅 参数 args。
system('doesnt_exist') # => nil
如果给出了一个或多个 args，则每个都是要传递给可执行文件的参数或选项
system('echo', 'C*') # => true system('echo', 'hello', 'world') # => true
输出
C* hello world
如果新进程无法执行，则引发异常。
源代码
# File kernel.rb, line 89 def tap Primitive.attr! :inline_block yield(self) self end
将自身传递给代码块，然后返回自身。此方法的主要目的是“利用”方法链，以便对链中的中间结果执行操作。
(1..10) .tap {|x| puts "original: #{x}" } .to_a .tap {|x| puts "array: #{x}" } .select {|x| x.even? } .tap {|x| puts "evens: #{x}" } .map {|x| x*x } .tap {|x| puts "squares: #{x}" }
源代码
static VALUE
rb_f_test(int argc, VALUE *argv, VALUE _)
{
int cmd;
if (argc == 0) rb_check_arity(argc, 2, 3);
cmd = NUM2CHR(argv[0]);
if (cmd == 0) {
goto unknown;
}
if (strchr("bcdefgGkloOprRsSuwWxXz", cmd)) {
CHECK(1);
switch (cmd) {
case 'b':
return rb_file_blockdev_p(0, argv[1]);
case 'c':
return rb_file_chardev_p(0, argv[1]);
case 'd':
return rb_file_directory_p(0, argv[1]);
case 'e':
return rb_file_exist_p(0, argv[1]);
case 'f':
return rb_file_file_p(0, argv[1]);
case 'g':
return rb_file_sgid_p(0, argv[1]);
case 'G':
return rb_file_grpowned_p(0, argv[1]);
case 'k':
return rb_file_sticky_p(0, argv[1]);
case 'l':
return rb_file_symlink_p(0, argv[1]);
case 'o':
return rb_file_owned_p(0, argv[1]);
case 'O':
return rb_file_rowned_p(0, argv[1]);
case 'p':
return rb_file_pipe_p(0, argv[1]);
case 'r':
return rb_file_readable_p(0, argv[1]);
case 'R':
return rb_file_readable_real_p(0, argv[1]);
case 's':
return rb_file_size_p(0, argv[1]);
case 'S':
return rb_file_socket_p(0, argv[1]);
case 'u':
return rb_file_suid_p(0, argv[1]);
case 'w':
return rb_file_writable_p(0, argv[1]);
case 'W':
return rb_file_writable_real_p(0, argv[1]);
case 'x':
return rb_file_executable_p(0, argv[1]);
case 'X':
return rb_file_executable_real_p(0, argv[1]);
case 'z':
return rb_file_zero_p(0, argv[1]);
}
}
if (strchr("MAC", cmd)) {
struct stat st;
VALUE fname = argv[1];
CHECK(1);
if (rb_stat(fname, &st) == -1) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
switch (cmd) {
case 'A':
return stat_atime(&st);
case 'M':
return stat_mtime(&st);
case 'C':
return stat_ctime(&st);
}
}
if (cmd == '-') {
CHECK(2);
return rb_file_identical_p(0, argv[1], argv[2]);
}
if (strchr("=<>", cmd)) {
struct stat st1, st2;
struct timespec t1, t2;
CHECK(2);
if (rb_stat(argv[1], &st1) < 0) return Qfalse;
if (rb_stat(argv[2], &st2) < 0) return Qfalse;
t1 = stat_mtimespec(&st1);
t2 = stat_mtimespec(&st2);
switch (cmd) {
case '=':
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec == t2.tv_nsec) return Qtrue;
return Qfalse;
case '>':
if (t1.tv_sec > t2.tv_sec) return Qtrue;
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec > t2.tv_nsec) return Qtrue;
return Qfalse;
case '<':
if (t1.tv_sec < t2.tv_sec) return Qtrue;
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec < t2.tv_nsec) return Qtrue;
return Qfalse;
}
}
unknown:
/* unknown command */
if (ISPRINT(cmd)) {
rb_raise(rb_eArgError, "unknown command '%s%c'", cmd == '\'' || cmd == '\\' ? "\\" : "", cmd);
}
else {
rb_raise(rb_eArgError, "unknown command \"\\x%02X\"", cmd);
}
UNREACHABLE_RETURN(Qundef);
}
对给定路径 path0 和 path1 的一个或两个文件系统实体执行测试
-
每个路径
path0或path1都指向文件、目录、设备、管道等。 -
字符
char选择特定的测试。
测试
-
这些测试中的每一个仅对
path0处的实体进行操作，并返回true或false；对于不存在的实体，返回false（不引发异常）字符 测试 'b'实体是否为块设备。 'c'实体是否为字符设备。 'd'实体是否为目录。 'e'实体是否为现有实体。 'f'实体是否为现有常规文件。 'g'是否设置了实体的 setgid 位。 'G'实体的组所有权是否等于调用者的。 'k'是否设置了实体的粘滞位。 'l'实体是否为符号链接。 'o'实体是否由调用者的有效 uid 拥有。 'O'类似于 'o'，但使用实际的 uid（而不是有效 uid）。'p'实体是否为 FIFO 设备（命名管道）。 'r'实体是否可由调用者的有效 uid/gid 读取。 'R'类似于 'r'，但使用实际的 uid/gid（而不是有效 uid/gid）。'S'实体是否为套接字。 'u'是否设置了实体的 setuid 位。 'w'实体是否可由调用者的有效 uid/gid 写入。 'W'类似于 'w'，但使用实际的 uid/gid（而不是有效 uid/gid）。'x'实体是否可由调用者的有效 uid/gid 执行。 'X'类似于 'x'，但使用实际的 uid/gid（而不是有效 uid/git）。'z'实体是否存在且长度为零。 -
此测试仅对
path0处的实体进行操作，并返回整数大小或nil字符 测试 's'如果实体存在且具有非零长度，则返回正整数大小，否则返回 nil。 -
这些测试中的每一个仅对
path0处的实体进行操作，并返回Time对象；如果实体不存在，则引发异常字符 测试 'A'实体的上次访问时间。 'C'实体的上次更改时间。 'M'实体的上次修改时间。 -
这些测试中的每一个都对
path0和path1处的每个实体的修改时间 (mtime) 进行操作，并返回true或false；如果任一实体不存在，则返回false字符 测试 '<'path0处的“mtime”是否小于path1处的 “mtime”。'='path0处的“mtime”是否等于path1处的 “mtime”。'>'path0处的“mtime”是否大于path1处的 “mtime”。 -
此测试对
path0和path1处的每个实体的内容进行操作，并返回true或false；如果任一实体不存在，则返回false字符 测试 '-'实体是否存在且是否相同。
源代码
# File kernel.rb, line 121 def then Primitive.attr! :inline_block unless defined?(yield) return Primitive.cexpr! 'SIZED_ENUMERATOR(self, 0, 0, rb_obj_size)' end yield(self) end
将自身传递给代码块，并返回代码块的结果。
3.next.then {|x| x**x }.to_s #=> "256"
then 的一个很好的用途是在方法链中进行值传递
require 'open-uri' require 'json' construct_url(arguments) .then {|url| URI(url).read } .then {|response| JSON.parse(response) }
当不使用代码块调用时，该方法返回一个 Enumerator，例如，可用于有条件的断路
# Meets condition, no-op 1.then.detect(&:odd?) # => 1 # Does not meet condition, drop value 2.then.detect(&:odd?) # => nil
源代码
static VALUE
rb_f_throw(int argc, VALUE *argv, VALUE _)
{
VALUE tag, value;
rb_scan_args(argc, argv, "11", &tag, &value);
rb_throw_obj(tag, value);
UNREACHABLE_RETURN(Qnil);
}
将控制权转移到等待标签的活动 catch 代码块的末尾。如果没有用于 tag 的 catch 代码块，则引发 UncaughtThrowError。可选的第二个参数为 catch 代码块提供返回值，否则默认为 nil。有关示例，请参见 Kernel::catch。
源代码
static VALUE
f_trace_var(int c, const VALUE *a, VALUE _)
{
return rb_f_trace_var(c, a);
}
控制对全局变量赋值的跟踪。参数 symbol 标识变量（作为字符串名称或符号标识符）。每当变量被赋值时，都会执行 cmd（可以是字符串或 Proc 对象）或代码块。代码块或 Proc 对象接收变量的新值作为参数。另请参见 untrace_var。
trace_var :$_, proc {|v| puts "$_ is now '#{v}'" } $_ = "hello" $_ = ' there'
产生
$_ is now 'hello' $_ is now ' there'
源代码
static VALUE
sig_trap(int argc, VALUE *argv, VALUE _)
{
int sig;
sighandler_t func;
VALUE cmd;
rb_check_arity(argc, 1, 2);
sig = trap_signm(argv[0]);
if (reserved_signal_p(sig)) {
const char *name = signo2signm(sig);
if (name)
rb_raise(rb_eArgError, "can't trap reserved signal: SIG%s", name);
else
rb_raise(rb_eArgError, "can't trap reserved signal: %d", sig);
}
if (argc == 1) {
cmd = rb_block_proc();
func = sighandler;
}
else {
cmd = argv[1];
func = trap_handler(&cmd, sig);
}
if (rb_obj_is_proc(cmd) &&
!rb_ractor_main_p() && !rb_ractor_shareable_p(cmd)) {
cmd = rb_proc_isolate(cmd);
}
return trap(sig, func, cmd);
}
指定信号的处理方式。第一个参数是信号名称（例如“SIGALRM”、“SIGUSR1”等的字符串）或信号编号。可以从信号名称中省略字符“SIG”。命令或代码块指定在信号被引发时要运行的代码。如果命令是字符串“IGNORE”或“SIG_IGN”，则将忽略该信号。如果命令是“DEFAULT”或“SIG_DFL”，则将调用 Ruby 的默认处理程序。如果命令是“EXIT”，则脚本将因信号而终止。如果命令是“SYSTEM_DEFAULT”，则将调用操作系统的默认处理程序。否则，将运行给定的命令或代码块。特殊信号名称“EXIT”或信号编号零将在程序终止之前被调用。trap 返回给定信号的先前处理程序。
Signal.trap(0, proc { puts "Terminating: #{$$}" }) Signal.trap("CLD") { puts "Child died" } fork && Process.wait
产生
Terminating: 27461 Child died Terminating: 27460
源代码
static VALUE
f_untrace_var(int c, const VALUE *a, VALUE _)
{
return rb_f_untrace_var(c, a);
}
删除给定全局变量上指定命令的跟踪，并返回 nil。如果未指定任何命令，则删除该变量的所有跟踪，并返回包含实际删除的命令的数组。
源代码
# File warning.rb, line 52 def warn(*msgs, uplevel: nil, category: nil) if Primitive.cexpr!("NIL_P(category)") Primitive.rb_warn_m(msgs, uplevel, nil) elsif Warning[category = Primitive.cexpr!("rb_to_symbol_type(category)")] Primitive.rb_warn_m(msgs, uplevel, category) end end
如果禁用了警告（例如，使用 -W0 标志），则不执行任何操作。否则，将每个消息转换为字符串，如果字符串不以换行符结尾，则将换行符附加到字符串，并使用该字符串调用 Warning.warn。
warn("warning 1", "warning 2")
产生
warning 1 warning 2
如果给定 uplevel 关键字参数，则字符串将以与 rb_warn C 函数使用的相同格式添加给定调用者帧的信息。
# In baz.rb def foo warn("invalid call to foo", uplevel: 1) end def bar foo end bar
产生
baz.rb:6: warning: invalid call to foo
如果给定 category 关键字参数，则将类别传递给 Warning.warn。给定的类别必须是以下类别之一
- :deprecated
-
用于警告将来可能会删除的已弃用功能。
- :experimental
-
用于警告可能会在未来版本中更改的实验性功能。
- :performance
-
用于警告具有负面性能影响的 API 或模式
私有实例方法
源代码
# File ext/json/lib/json/common.rb, line 873 def JSON(object, *args) if object.is_a?(String) return JSON.parse(object, args.first) elsif object.respond_to?(:to_str) str = object.to_str if str.is_a?(String) return JSON.parse(object.to_str, args.first) end end JSON.generate(object, args.first) end
如果 object 类似于字符串，则解析该字符串并将解析结果作为 Ruby 数据结构返回。否则，从 Ruby 数据结构对象生成 JSON 文本并返回它。
opts 参数分别传递给 generate/parse。有关其文档，请参阅 generate 和 parse。
源代码
# File lib/uri/common.rb, line 865 def URI(uri) if uri.is_a?(URI::Generic) uri elsif uri = String.try_convert(uri) URI.parse(uri) else raise ArgumentError, "bad argument (expected URI object or URI string)" end end
返回从给定 uri 派生的 URI 对象，uri 可以是 URI 字符串或现有的 URI 对象
# Returns a new URI. uri = URI('http://github.com/ruby/ruby') # => #<URI::HTTP http://github.com/ruby/ruby> # Returns the given URI. URI(uri) # => #<URI::HTTP http://github.com/ruby/ruby>
源代码
# File lib/rubygems/core_ext/kernel_gem.rb, line 35 def gem(gem_name, *requirements) # :doc: skip_list = (ENV["GEM_SKIP"] || "").split(/:/) raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name if gem_name.is_a? Gem::Dependency unless Gem::Deprecate.skip warn "#{Gem.location_of_caller.join ":"}:Warning: Kernel.gem no longer "\ "accepts a Gem::Dependency object, please pass the name "\ "and requirements directly" end requirements = gem_name.requirement gem_name = gem_name.name end dep = Gem::Dependency.new(gem_name, *requirements) loaded = Gem.loaded_specs[gem_name] return false if loaded && dep.matches_spec?(loaded) spec = dep.to_spec if spec if Gem::LOADED_SPECS_MUTEX.owned? spec.activate else Gem::LOADED_SPECS_MUTEX.synchronize { spec.activate } end end end
使用 Kernel#gem 来激活特定版本的 gem_name。
requirements 是一个版本需求列表，指定的 gem 必须满足这些需求，最常见的是 “= example.version.number”。有关如何指定版本需求的更多信息，请参阅 Gem::Requirement。
如果要激活 gem 的最新版本，则无需调用 Kernel#gem，Kernel#require 会为您处理好。
如果 gem 被成功激活，Kernel#gem 返回 true，否则返回 false。如果找不到 gem、不匹配版本需求或已激活不同版本，则会引发异常。
应该在任何 require 语句之前调用 Kernel#gem（否则 RubyGems 可能会加载冲突的库版本）。
只有在给出预发布 requirements 时，Kernel#gem 才会加载预发布版本。
gem 'rake', '>= 1.1.a', '< 2'
在较旧的 RubyGems 版本中，可以使用环境变量 GEM_SKIP 来跳过指定 gem 的激活，例如测试尚未安装的更改。现在，RubyGems 会参考 -I 和 RUBYLIB 环境变量来跳过 gem 的激活。
示例
GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb
源代码
# File ext/json/lib/json/common.rb, line 851 def j(*objs) objs.each do |obj| puts JSON::generate(obj, :allow_nan => true, :max_nesting => false) end nil end
将 objs 以最短形式（即一行）的 JSON 字符串输出到 STDOUT。
源代码
# File ext/json/lib/json/common.rb, line 860 def jj(*objs) objs.each do |obj| puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false) end nil end
将 objs 以美化格式（带有缩进且多行）的 JSON 字符串输出到 STDOUT。
源代码
# File lib/pp.rb, line 692 def pp(*objs) objs.each {|obj| PP.pp(obj) } objs.size <= 1 ? objs.first : objs end
以漂亮的格式打印参数。
pp 返回参数。
源代码
# File lib/rubygems/core_ext/kernel_require.rb, line 36 def require(path) # :doc: return gem_original_require(path) unless Gem.discover_gems_on_require RUBYGEMS_ACTIVATION_MONITOR.synchronize do path = File.path(path) # If +path+ belongs to a default gem, we activate it and then go straight # to normal require if spec = Gem.find_default_spec(path) name = spec.name next if Gem.loaded_specs[name] # Ensure -I beats a default gem resolved_path = begin rp = nil load_path_check_index = Gem.load_path_insert_index - Gem.activated_gem_paths Gem.suffixes.find do |s| $LOAD_PATH[0...load_path_check_index].find do |lp| if File.symlink? lp # for backward compatibility next end full_path = File.expand_path(File.join(lp, "#{path}#{s}")) rp = full_path if File.file?(full_path) end end rp end Kernel.send(:gem, name, Gem::Requirement.default_prerelease) unless resolved_path next end # If there are no unresolved deps, then we can use just try # normal require handle loading a gem from the rescue below. if Gem::Specification.unresolved_deps.empty? next end # If +path+ is for a gem that has already been loaded, don't # bother trying to find it in an unresolved gem, just go straight # to normal require. #-- # TODO request access to the C implementation of this to speed up RubyGems if Gem::Specification.find_active_stub_by_path(path) next end # Attempt to find +path+ in any unresolved gems... found_specs = Gem::Specification.find_in_unresolved path # If there are no directly unresolved gems, then try and find +path+ # in any gems that are available via the currently unresolved gems. # For example, given: # # a => b => c => d # # If a and b are currently active with c being unresolved and d.rb is # requested, then find_in_unresolved_tree will find d.rb in d because # it's a dependency of c. # if found_specs.empty? found_specs = Gem::Specification.find_in_unresolved_tree path found_specs.each(&:activate) # We found +path+ directly in an unresolved gem. Now we figure out, of # the possible found specs, which one we should activate. else # Check that all the found specs are just different # versions of the same gem names = found_specs.map(&:name).uniq if names.size > 1 raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ", "}" end # Ok, now find a gem that has no conflicts, starting # at the highest version. valid = found_specs.find {|s| !s.has_conflicts? } unless valid le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate" le.name = names.first raise le end valid.activate end end begin gem_original_require(path) rescue LoadError => load_error if load_error.path == path && RUBYGEMS_ACTIVATION_MONITOR.synchronize { Gem.try_activate(path) } return gem_original_require(path) end raise load_error end end
当需要 RubyGems 时，Kernel#require 将被我们自己的版本替换，后者能够按需加载 gem。
当您调用 require 'x' 时，会发生以下情况：
-
如果该文件可以从现有的 Ruby 加载路径加载，则会加载。
-
否则，将搜索已安装的 gem 中匹配的文件。如果在 gem 'y' 中找到，则该 gem 将被激活（添加到加载路径）。
如果该文件已被加载，则返回 false 的正常 require 功能会被保留。
源代码
# File ext/psych/lib/psych/y.rb, line 5 def y *objects puts Psych.dump_stream(*objects) end
用于 IRB 的 Psych.dump_stream 的别名。