Kernel

模块内核

RubyGems 添加了 gem 方法以允许激活特定的 gem 版本，并覆盖了 Kernel 上的 require 方法，使 gem 看起来就好像它们存在于$LOAD_PATH。有关更多详细信息，请参阅这些方法的文档。

内核模块包含在 Object 类中，所以它的方法在每个 Ruby 对象中都可用。

内核实例方法记录在类 Object 中，而模块方法记录在此处。这些方法在没有接收器的情况下被调用，因此可以用函数形式调用：

sprintf "%.1f", 1.234 #=> "1.2"

公共类方法

URI（s）显示源

返回uri转换为 URI 对象。

# File lib/uri/common.rb, line 732
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

open(path , mode [, perm]) →io 或零显示源

open(path , mode [, perm]) {|io| block } → obj

创建连接到给定流，文件或子流程的 IO 对象。

如果path不以管道字符（|）开头，则将其视为要使用指定模式打开的文件的名称（默认为“r”）。

mode字符串可以是字符串，也可以是整数。如果它是一个整数，它必须是按位或开放（2）标志，例如 File :: RDWR 或 File :: EXCL。如果是字符串，则为“fmode”，“fmode：ext_enc”或“fmode：ext_enc：int_enc”。

有关mode字符串指令的完整文档，请参阅 IO.new 的文档。

如果正在创建文件，则可以使用该perm参数设置其初始权限。有关权限的描述，请参见 File.new和open（2）和 chmod（2）手册页。

如果指定了一个块，它将以 IO 对象作为参数进行调用，并且当块终止时 IO 将自动关闭。该调用返回该块的值。

如果path以管道字符（"|"）开头，则会创建一个子进程，并通过一对管道连接到调用者。返回的 IO 对象可用于写入标准输入并从此子流程的标准输出中读取。

如果管道后面的命令是单个减号（"|-"），则 Ruby 分支，并且此子进程连接到父级。如果该命令不是"-"，则该子进程运行该命令。

当子进程是 ruby（通过打开"|-"）时，open调用返回nil。如果某个块与公开呼叫相关联，则该块将运行两次 - 一次在父级，一次在子级。

block 参数将是父级和nil子级中的 IO 对象。父IO对象将连接到孩子的$ stdin和$ stdout。子程序将在程序段结尾处终止。

示例

从“testfile”中读取：

open("testfile") do |f|
  print f.gets
end

生产：

This is line one

打开一个子进程并读取其输出：

cmd = open("|date")
print cmd.gets
cmd.close

生产：

Wed Apr  9 08:56:31 CDT 2003

打开运行相同 Ruby 程序的子进程：

f = open("|-", "w+")
if f == nil
  puts "in Child"
  exit
else
  puts "Got: #{f.gets}"
end

生产：

Got: in Child

使用块打开子进程以接收 IO 对象：

open "|-" do |f|
  if f then
    # parent process
    puts "Got: #{f.gets}"
  else
    # child process
    puts "in Child"
  end
end

生产：

Got: in Child

static VALUE
rb_f_open(int argc, VALUE *argv)
{
    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)) {
                    argv[0] = cmd;
                    return rb_io_s_popen(argc, argv, rb_cIO
                }
            }
        }
    }
    if (redirect) {
        VALUE io = rb_funcallv(argv[0], to_open, argc-1, argv+1

        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
}

另外别名为：open_uri_original_open，open_uri_original_open

pp（* objs）显示源文件

以漂亮的形式打印参数。

pp 返回参数（s）。

# File lib/pp.rb, line 19
def pp(*objs)
  objs.each {|obj|
    PP.pp(obj)
  }
  objs.size <= 1 ? objs.first : objs
end

私有类方法

open_uri_original_open(*args)

别名为：open

公共实例方法

Array(arg) →数组显示源

作为数组返回arg。

首先在arg上尝试调用to_ary，然后to_a。

Array(1..5)   #=> [1, 2, 3, 4, 5]

static VALUE
rb_f_array(VALUE obj, VALUE arg)
{
    return rb_Array(arg
}

BigDecimal（* args）显示源文件

另请参阅 BigDecimal.new

static VALUE
BigDecimal_global_new(int argc, VALUE *argv, VALUE self)
{
    ENTER(1
    Real *pv;
    VALUE obj;

    obj = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0
    GUARD_OBJ(pv, BigDecimal_new(argc, argv)
    if (ToValue(pv)) pv = VpCopy(NULL, pv
    RTYPEDDATA_DATA(obj) = pv;
    return pv->obj = obj;
}

Complex（x，y）→数字显示源

返回 x + i * y;

Complex(1, 2)    #=> (1+2i)
Complex('1+2i')  #=> (1+2i)
Complex(nil)     #=> TypeError
Complex(1, nil)  #=> TypeError

字符串形式的语法：

string form = extra spaces , complex , extra spaces ;
complex = real part | [ sign ] , imaginary part
        | real part , sign , imaginary part
        | rational , "@" , rational ;
real part = rational ;
imaginary part = imaginary unit | unsigned rational , imaginary unit ;
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 ] ;
imaginary unit = "i" | "I" | "j" | "J" ;
sign = "-" | "+" ;
digits = digit , { digit | "_" , digit };
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
extra spaces = ? \s* ? ;

请参阅 String＃to_c。

static VALUE
nucomp_f_complex(int argc, VALUE *argv, VALUE klass)
{
    return nucomp_s_convert(argc, argv, rb_cComplex
}

Float(p1) 显示源

static VALUE rb_f_float(VALUE obj, VALUE arg))

Hash(arg) →哈希显示源文件

通过调用 arg .to_hash将 arg 转换为一个Hash。当arg是nil或[]时，返回空Hash。

Hash([])          #=> {}
Hash(nil)         #=> {}
Hash(key: :value) #=> {:key => :value}
Hash([1, 2, 3])   #=> TypeError

static VALUE
rb_f_hash(VALUE obj, VALUE arg)
{
    return rb_Hash(arg
}

Integer(arg, base=0）→整数显示源文件

将 arg 转换为Integer。数字类型直接转换（浮点数被截断）。基数（0或2和36之间）是整数字符串表示的基数。如果 ARG 是String，当基极被省略或等于零，基数指示符（0，0b，和0x）被兑现。无论如何，字符串应严格符合数字表示。这种行为不同于String#to_i。to_int然后，首先尝试转换非字符串值to_i。传递nil引发 TypeError。

Integer(123.999)    #=> 123
Integer("0x1a")     #=> 26
Integer(Time.new)   #=> 1204973019
Integer("0930", 10) #=> 930
Integer("111", 2)   #=> 7
Integer(nil)        #=> TypeError

static VALUE
rb_f_integer(int argc, VALUE *argv, VALUE obj)
{
    VALUE arg = Qnil;
    int base = 0;

    switch (argc) {
      case 2:
        base = NUM2INT(argv[1]
      case 1:
        arg = argv[0];
        break;
      default:
        /* should cause ArgumentError */
        rb_scan_args(argc, argv, "11", NULL, NULL
    }
    return rb_convert_to_integer(arg, base
}

Pathname(path) →路径名显示源

从给定字符串创建一个新的路径名对象path，并返回路径名对象。

为了使用这个构造函数，你必须首先需要 Pathname 标准库扩展。

require 'pathname'
Pathname("/home/zzak")
#=> #<Pathname:/home/zzak>

有关更多信息，另请参阅 Pathname.new。

static VALUE
path_f_pathname(VALUE self, VALUE str)
{
    return rb_class_new_instance(1, &str, rb_cPathname
}

Rational（x，y）→数字显示源

返回 x / y;

Rational(1, 2)   #=> (1/2)
Rational('1/2')  #=> (1/2)
Rational(nil)    #=> TypeError
Rational(1, nil) #=> TypeError

字符串形式的语法：

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
nurat_f_rational(int argc, VALUE *argv, VALUE klass)
{
    return nurat_s_convert(argc, argv, rb_cRational
}

String(arg) →字符串显示源文件

将arg返回为一个 String。

首先尝试调用它的to_str方法，然后调用它的to_s方法。

String(self)        #=> "main"
String(self.class)  #=> "Object"
String(123456)      #=> "123456"

static VALUE
rb_f_string(VALUE obj, VALUE arg)
{
    return rb_String(arg
}

__callee__→符号显示源

以符号形式返回当前方法的被调用名称。如果在方法之外调用，则返回nil。

static VALUE
rb_f_callee_name(void)
{
    ID fname = prev_frame_callee( /* need *callee* ID */

    if (fname) {
        return ID2SYM(fname
    }
    else {
        return Qnil;
    }
}

__dir__→字符串显示源文件

返回调用此方法的文件的目录的规范化绝对路径。这意味着路径中的符号链接已解决。如果__FILE__是nil，它会返回nil。返回值等于File.dirname(File.realpath(__FILE__))。

static VALUE
f_current_dirname(void)
{
    VALUE base = rb_current_realfilepath(
    if (NIL_P(base)) {
        return Qnil;
    }
    base = rb_file_dirname(base
    return base;
}

__method__→符号显示源代码

以符号的形式返回当前方法定义的名称。如果在方法之外调用，则返回nil。

static VALUE
rb_f_method_name(void)
{
    ID fname = prev_frame_func( /* need *method* ID */

    if (fname) {
        return ID2SYM(fname
    }
    else {
        return Qnil;
    }
}

cmd →字符串显示源

返回子 shell 中运行 cmd 的标准输出。内置的语法%x{...}使用这种方法。设置$?为进程状态。

%x`date`                   #=> "Wed Apr  9 08:56:30 CDT 2003\n"
%x`ls testdir`.split[1]    #=> "main.rb"
%x`echo oops && exit 99`   #=> "oops\n"
$?.exitstatus            #=> 99

static VALUE
rb_f_backquote(VALUE obj, VALUE str)
{
    VALUE port;
    VALUE result;
    rb_io_t *fptr;

    SafeStringValue(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_finalize(fptr
    rb_gc_force_recycle(port /* also guards from premature GC */

    return result;
}

中止显示源

Kernel::abort(msg)

abort(msg)

通过调用立即终止执行Kernel.exit(false)。如果给出 msg，则在终止之前将其写入 STDERR。

VALUE
rb_f_abort(int argc, const VALUE *argv)
{
    rb_check_arity(argc, 0, 1
    if (argc == 0) {
        if (!NIL_P(GET_THREAD()->errinfo)) {
            ruby_error_print(
        }
        rb_exit(EXIT_FAILURE
    }
    else {
        VALUE args[2];

        args[1] = args[0] = argv[0];
        StringValue(args[0]
        rb_io_puts(1, args, rb_stderr
        args[0] = INT2NUM(EXIT_FAILURE
        rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit)
    }

    UNREACHABLE;
}

at_exit {block}→proc显示源文件

将块转换为Proc对象（因此将其绑定到调用点）并在程序退出时将其注册为执行。如果注册了多个处理程序，则它们将以与注册相反的顺序执行。

def do_at_exit(str1)
  at_exit { print str1 }
end
at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit

produces:

goodbye cruel world

static VALUE
rb_f_at_exit(void)
{
    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;
}

autoload(module, filename) →无显示源

注册第一次访问该模块（可能是一个String或符号）时要加载（使用Kernel::require）的文件名。

autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")

static VALUE
rb_f_autoload(VALUE obj, VALUE sym, VALUE file)
{
    VALUE klass = rb_class_real(rb_vm_cbase()
    if (NIL_P(klass)) {
        rb_raise(rb_eTypeError, "Can not set autoload on singleton class"
    }
    return rb_mod_autoload(klass, sym, file
}

autoload?(name) →字符串或零显示源

如果名称被注册为，则返回要加载autoload的文件名。

autoload(:B, "b")
autoload?(:B)            #=> "b"

static VALUE
rb_f_autoload_p(VALUE obj, VALUE sym)
{
    /* 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(klass, sym
}

binding →a_binding显示源

返回一个Binding对象，描述调用时的变量和方法绑定。调用eval此环境中执行评估命令时可以使用此对象。另请参阅类Binding的描述。

def get_binding(param)
  binding
end
b = get_binding("hello")
eval("param", b)   #=> "hello"

static VALUE
rb_f_binding(VALUE self)
{
    return rb_binding_new(
}

block_given？→true 或 false 显示来源

如果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"

VALUE
rb_f_block_given_p(void)
{
    rb_thread_t *th = GET_THREAD(
    rb_control_frame_t *cfp = th->cfp;
    cfp = vm_get_ruby_level_caller_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)

    if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) {
        return Qtrue;
    }
    else {
        return Qfalse;
    }
}

callcc {|cont| block } →obj 显示源

生成一个 Continuation 对象，并将其传递给关联的块。您需要require 'continuation'在使用此方法之前。执行一个cont.call将导致 callcc 返回（如同在块的结尾处）。callcc 返回的值是该块的值或传递给 cont 的值.call。有关更多详细信息，请参见延续课程另请参阅 #throw，了解用于展开调用堆栈的其他机制。

static VALUE
rb_callcc(VALUE self)
{
    volatile int called;
    volatile VALUE val = cont_capture(&called

    if (called) {
        return val;
    }
    else {
        return rb_yield(val
    }
}

caller(start=1, length=nil) →数组或无显示源

caller(range) → 数组或无

返回当前执行堆栈 - 包含表单file:line或者file:line: in `method'中的字符串的数组。

可选的开始参数确定堆栈顶部要忽略的初始堆栈条目的数量。

第二个可选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(int argc, VALUE *argv)
{
    return vm_backtrace_to_ary(GET_THREAD(), argc, argv, 1, 1, 1
}

caller_locations（start = 1，length = nil）→array 或 nil 显示源文件

caller_locations（range）→array 或 nil

返回当前的执行堆栈 - 一个包含回溯位置对象的数组。

有关更多信息，请参阅 Thread :: Backtrace :: Location。

可选的开始参数确定堆栈顶部要忽略的初始堆栈条目的数量。

第二个可选length参数可用于限制从堆栈返回多少条目。

如果 start 大于当前执行堆栈的大小，则返回nil。

或者，您可以传递一个范围，它将返回一个包含指定范围内条目的数组。

static VALUE
rb_f_caller_locations(int argc, VALUE *argv)
{
    return vm_backtrace_to_ary(GET_THREAD(), argc, argv, 1, 1, 0
}

catch（tag）{| tag | 块}→ obj 显示源

catch执行其块。如果throw未被调用，则该块正常执行，并catch返回最后一个表达式的值。

catch(1) { 123 }            # => 123

如果throw(tag2, val)被调用，Ruby 搜索了它的堆栈一个catch块，其tag具有相同object_id的 TAG2。找到时，块停止执行并返回 val（或者，nil如果没有给出第二个参数throw）。

catch(1) { throw(1, 456) }  # => 456
catch(1) { throw(1) }       # => nil

当tag作为第一个参数传递时，将catch其作为该块的参数。

catch(1) {|x| x + 2 }       # => 3

如果tag未指定，则catch产生一个新的唯一对象（从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_catch(int argc, VALUE *argv)
{
    VALUE tag;

    if (argc == 0) {
        tag = rb_obj_alloc(rb_cObject
    }
    else {
        rb_scan_args(argc, argv, "01", &tag
    }
    return rb_catch_obj(tag, catch_i, 0
}

chomp→$ _显示源

chomp(string) → $_

相当于$_ = $_.chomp(string)。看String#chomp。仅在指定-p / -n命令行选项时可用。

static VALUE
rb_f_chomp(int argc, VALUE *argv)
{
    VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chomp"), argc, argv
    rb_lastline_set(str
    return str;
}

chop→$ _显示源

相当于($_.dup).chop!，除了nil永远不会返回。看String#chop!。仅在指定-p / -n命令行选项时可用。

static VALUE
rb_f_chop(void)
{
    VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chop"), 0, 0
    rb_lastline_set(str
    return str;
}

eval（string [，binding [，filename，lineno]]）→obj 显示源文件

在字符串中计算 Ruby 表达式。如果给定了绑定，那必须是一个Binding对象，评估是在其上下文中执行的。如果存在可选的文件名和 lineno 参数，则会在报告语法错误时使用它们。

def get_binding(str)
  return binding
end
str = "hello"
eval "str + ' Fred'"                      #=> "hello Fred"
eval "str + ' Fred'", get_binding("bye")  #=> "bye Fred"

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
    SafeStringValue(src
    if (argc >= 3) {
        StringValue(vfile
    }
    if (argc >= 4) {
        line = NUM2INT(vline
    }

    if (!NIL_P(vfile))
        file = vfile;
    return eval_string(self, src, scope, file, line
}

exec（env，command ...，options）显示源文件

通过运行给定的外部命令来替换当前进程，该命令可以采用以下形式之一：

exec(commandline)

传递给标准 shell 的命令行字符串

exec(cmdname, arg1, ...)

命令名称和一个或多个参数（无shell）

exec([cmdname, argv0], arg1, ...)

命令名，argv 和零个或多个参数（无 shell）

在第一种形式中，字符串被视为一个命令行，在执行之前需要进行shell扩展。

标准外壳总是意味着"/bin/sh"在类 Unix 系统上，与 Windows NT 系列相同，ENV["RUBYSHELL"]或ENV["COMSPEC"]类似。

如果来自第一个 form（exec("command")）的字符串遵循以下简单规则：

没有元字符

没有外壳保留字，也没有特殊的内置

Ruby不使用shell就直接调用该命令

一个事件名称

一个文件名

一个行号

一个对象 ID

一个绑定

一个classproc的名称

如果文件可以从现有的 Ruby 加载路径加载，那就是。

否则，会搜索已安装的宝石以查找匹配的文件。如果它在 gem'y'中找到，则激活该 gem（添加到加载路径中）。

如果该文件已被加载，则返回false 的require正常功能将被保留。

# File lib/rubygems/core_ext/kernel_require.rb, line 38
def require path
  RUBYGEMS_ACTIVATION_MONITOR.enter

  path = path.to_path if path.respond_to? :to_path

  spec = Gem.find_unresolved_default_spec(path)
  if spec
    Gem.remove_unresolved_default_spec(spec)
    Kernel.send(:gem, spec.name)
  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? then
    RUBYGEMS_ACTIVATION_MONITOR.exit
    return gem_original_require(path)
  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

  spec = Gem::Specification.find_active_stub_by_path path

  begin
    RUBYGEMS_ACTIVATION_MONITOR.exit
    return gem_original_require(path)
  end if spec

  # 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? then
    found_specs = Gem::Specification.find_in_unresolved_tree path

    found_specs.each do |found_spec|
      found_spec.activate
    end

  # 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 then
      RUBYGEMS_ACTIVATION_MONITOR.exit
      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.reject { |s| s.has_conflicts? }.first

    unless valid then
      le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
      le.name = names.first
      RUBYGEMS_ACTIVATION_MONITOR.exit
      raise le
    end

    valid.activate
  end

  RUBYGEMS_ACTIVATION_MONITOR.exit
  return gem_original_require(path)
rescue LoadError => load_error
  RUBYGEMS_ACTIVATION_MONITOR.enter

  begin
    if load_error.message.start_with?("Could not find") or
        (load_error.message.end_with?(path) and Gem.try_activate(path)) then
      require_again = true
    end
  ensure
    RUBYGEMS_ACTIVATION_MONITOR.exit
  end

  return gem_original_require(path) if require_again

  raise load_error
end

另外别名为：gem_original_require

scanf（格式，＆b）显示来源

扫描 STDIN 进行数据匹配format。有关详细信息，请参阅 IO＃scanf。

有关创建格式字符串的详细信息，请参阅 Scanf。

你将需要'scanf'来使用 #scanf。

# File lib/scanf.rb, line 772
def scanf(format, &b) #:doc:
  STDIN.scanf(format ,&b)
end

y(*objects)显示源

旨在与 IRB 一起使用的 Psych.dump_stream 的别名。

# File ext/psych/lib/psych/y.rb, line 4
def y *objects
  puts Psych.dump_stream(*objects)
end