Module: Kernel
Relationships & Source Files | |
Extension / Inclusion / Inheritance Descendants | |
Included In:
| |
Defined in: | object.c, complex.c, cont.c, eval.c, eval_jump.c, file.c, io.c, kernel.rb, load.c, object.c, prelude.rb, proc.c, process.c, random.c, rational.c, ruby.c, signal.c, vm_backtrace.c, vm_eval.c, vm_trace.c, warning.rb, yjit_hook.rb |
Overview
The Kernel module is included by class ::Object
, so its methods are available in every Ruby object.
The Kernel instance methods are documented in class ::Object
while the module methods are documented here. These methods are called without a receiver and thus can be called in functional form:
sprintf "%.1f", 1.234 #=> "1.2"
What’s Here
Module Kernel provides methods that are useful for:
-
Converting
-
Querying
-
Exiting
-
Exceptions
-
IO
-
Procs
-
Tracing
-
Subprocesses
-
Loading
-
Yielding
-
{Random
Values} -
Other
Converting
-
#Array
: Returns an .Array based on the given argument. -
#Complex
: Returns a .Complex based on the given arguments. -
#Hash
: Returns a .Hash based on the given argument. -
#Rational
: Returns a .Rational based on the given arguments. -
#String
: Returns a .String based on the given argument.
Querying
-
#__callee__
: Returns the called name of the current method as a symbol. -
#__dir__
: Returns the path to the directory from which the current method is called. -
#__method__
: Returns the name of the current method as a symbol. -
#autoload?
: Returns the file to be loaded when the given module is referenced. -
#binding
: Returns a::Binding
for the context at the point of call. -
#block_given?
: Returnstrue
if a block was passed to the calling method. -
#caller
: Returns the current execution stack as an array of strings. -
#caller_locations
: Returns the current execution stack as an array of Thread::Backtrace::Location objects. -
#class: Returns the class of
self
. -
#frozen?: Returns whether
self
is frozen. -
#global_variables
: Returns an array of global variables as symbols. -
#local_variables
: Returns an array of local variables as symbols. -
#test
: Performs specified tests on the given single file or pair of files.
Exiting
-
#abort
: Exits the current process after printing the given arguments. -
#at_exit
: Executes the given block when the process exits. -
#exit
: Exits the current process after calling any registered .at_exit handlers. -
#exit!
: Exits the current process without calling any registered .at_exit handlers.
Exceptions
-
#catch
: Executes the given block, possibly catching a thrown object. -
#raise
(aliased as#fail
): Raises an exception based on the given arguments. -
#throw
: Returns from the active catch block waiting for the given tag.
IO
-
#pp: Prints the given objects in pretty form.
-
#gets
: Returns and assigns to$_
the next line from the current input. -
#open
: Creates an::IO
object connected to the given stream, file, or subprocess. -
#p
: Prints the given objects’ inspect output to the standard output. -
#print
: Prints the given objects to standard output without a newline. -
#printf
: Prints the string resulting from applying the given format string to any additional arguments. -
#putc
: Equivalent to <tt.$stdout.putc(object)</tt> for the given object. -
#puts
: Equivalent to$stdout.puts(*objects)
for the given objects. -
#readline
: Similar to#gets
, but raises an exception at the end of file. -
#readlines
: Returns an array of the remaining lines from the current input. -
#select
: Same as IO.select.
Procs
-
#lambda
: Returns a lambda proc for the given block. -
#proc
: Returns a new Proc; equivalent to Proc.new.
Tracing
-
#set_trace_func
: Sets the given proc as the handler for tracing, or disables tracing if givennil
. -
#trace_var
: Starts tracing assignments to the given global variable. -
#untrace_var
: Disables tracing of assignments to the given global variable.
Subprocesses
-
`command`
: Returns the standard output of runningcommand
in a subshell. -
#exec
: Replaces current process with a new process. -
#fork
: Forks the current process into two processes. -
#spawn
: Executes the given command and returns its pid without waiting for completion. -
#system
: Executes the given command in a subshell.
Loading
-
#autoload
: Registers the given file to be loaded when the given constant is first referenced. -
#load
: Loads the given Ruby file. -
#require
: Loads the given Ruby file unless it has already been loaded. -
#require_relative
: Loads the Ruby file path relative to the calling file, unless it has already been loaded.
Yielding
-
#tap: Yields
self
to the given block; returnsself
. -
#then (aliased as #yield_self): Yields
self
to the block and returns the result of the block.
Random Values
-
#rand
: Returns a pseudo-random floating point number strictly between 0.0 and 1.0. -
#srand
: Seeds the pseudo-random number generator with the given number.
Other
-
#eval
: Evaluates the given string as Ruby code. -
#loop: Repeatedly executes the given block.
-
#sleep
: Suspends the current thread for the given number of seconds. -
#sprintf
(aliased as#format
): Returns the string resulting from applying the given format string to any additional arguments. -
#syscall
: Runs an operating system call. -
#trap
: Specifies the handling of system signals. -
#warn: Issue a warning based on the given messages and options.
Class Attribute Summary
-
block_given? ⇒ Boolean
readonly
Returns
true
ifyield
would execute a block in the current context. -
iterator? ⇒ Boolean
readonly
Deprecated.
Class Method Summary
-
__callee__ ⇒ Symbol
Returns the called name of the current method as a
::Symbol
. -
__dir__ ⇒ String
Returns the canonicalized absolute path of the directory of the file from which this method is called.
-
__method__ ⇒ Symbol
Returns the name at the definition of the current method as a
::Symbol
. - `(str)
-
abort
Terminates execution immediately, effectively by calling
Kernel.exit(false)
. -
Array(object) ⇒ Object, Array
Returns an array converted from
object
. -
at_exit ⇒ Proc
Converts block to a
::Proc
object (and therefore binds it at the point of call) and registers it for execution when the program exits. - autoload(const, filename) ⇒ nil
-
autoload?(name, inherit = true) ⇒ String?
Returns filename to be loaded if name is registered as .autoload in the current namespace or one of its ancestors.
-
binding ⇒ Binding
Returns a
::Binding
object, describing the variable and method bindings at the point of call. -
callcc {|cont| ... } ⇒ Object
Generates a
::Continuation
object, which it passes to the associated block. -
caller(start = 1, length = nil) ⇒ Array?
Returns the current execution stack—an array containing strings in the form
file:line
orfile:line: in `method'
. -
caller_locations(start = 1, length = nil) ⇒ Array?
Returns the current execution stack—an array containing backtrace location objects.
-
catch([tag]) {|tag| ... } ⇒ Object
.catch executes its block.
-
chomp ⇒ $_
Equivalent to
$_ = $_.chomp(string)
. -
chop ⇒ $_
Equivalent to
($_.dup).chop!
, exceptnil
is never returned. -
Complex(real, imag = 0, exception: true) ⇒ Complex?
Returns a new Complex object if the arguments are valid; otherwise raises an exception if
exception
istrue
; otherwise returnsnil
. -
eval(string [, binding [, filename [,lineno]]]) ⇒ Object
Evaluates the Ruby expression(s) in string.
-
exec([env, ] command_line, options = {})
Replaces the current process by doing one of the following:
-
exit(status = true)
Initiates termination of the Ruby script by raising SystemExit; the exception may be caught.
-
exit!(status = false)
Exits the process immediately; no exit handlers are called.
-
raise(exception, message = exception.to_s, backtrace = nil, cause: $!)
(also: .raise)
Raises an exception; see
Exceptions
. -
Process.fork ⇒ Integer?
Creates a child process.
-
format(format_string *objects) ⇒ String
(also: .sprintf)
Returns the string resulting from formatting
objects
intoformat_string
. -
gets(sep=$/ [, getline_args]) ⇒ String?
Returns (and assigns to
$_
) the next line from the list of files in ARGV (or$*
), or from standard input if no files are present on the command line. -
global_variables ⇒ Array
Returns an array of the names of global variables.
-
gsub(pattern, replacement) ⇒ $_
Equivalent to
$_.gsub...
, except that$_
will be updated if substitution occurs. -
Hash(object) ⇒ Object, Hash
Returns a hash converted from
object
. - lambda {|...| ... } ⇒ Proc
-
load(filename, wrap = false) ⇒ true
Loads and executes the Ruby program in the file filename.
-
local_variables ⇒ Array
Returns the names of the current local variables.
-
open(path, mode = 'r', perm = 0666, **opts) ⇒ IO?
Creates an
::IO
object connected to the given file. -
p(object) ⇒ Object
For each object
obj
, executes: -
print(*objects) ⇒ nil
Equivalent to
$stdout.print(*objects)
, this method is the straightforward way to write to$stdout
. -
printf(format_string, *objects) ⇒ nil
Equivalent to:
-
proc {|...| ... } ⇒ Proc
Equivalent to Proc.new.
-
putc(int) ⇒ Integer
Equivalent to:
-
puts(*objects) ⇒ nil
Equivalent to.
-
raise(exception, message = exception.to_s, backtrace = nil, cause: $!)
Alias for .fail.
-
rand(max = 0) ⇒ Numeric
If called without an argument, or if
max.to_i.abs == 0
, rand returns a pseudo-random floating point number between 0.0 and 1.0, including 0.0 and excluding 1.0. -
Rational(x, y, exception: true) ⇒ Rational?
Returns
x/y
orarg
as a .Rational. -
readline(sep = $/, chomp: false) ⇒ String
Equivalent to method .gets, except that it raises an exception if called at end-of-stream:
-
readlines(sep = $/, chomp: false, **enc_opts) ⇒ Array
Returns an array containing the lines returned by calling .gets until the end-of-stream is reached; (see
Line IO
). -
require(name) ⇒ Boolean
Loads the given
name
, returningtrue
if successful andfalse
if the feature is already loaded. -
require_relative(string) ⇒ Boolean
Ruby tries to load the library named string relative to the directory containing the requiring file.
-
IO.select(read_ios, write_ios = [], error_ios = [], timeout = nil) ⇒ Array?
Invokes system call select(2), which monitors multiple file descriptors, waiting until one or more of the file descriptors becomes ready for some class of I/O operation.
-
set_trace_func(proc) ⇒ Proc
Establishes proc as the handler for tracing, or disables tracing if the parameter is
nil
. -
sleep(secs = nil) ⇒ slept_secs
Suspends execution of the current thread for the number of seconds specified by numeric argument
secs
, or forever ifsecs
isnil
; returns the integer number of seconds suspended (rounded). -
spawn([env, ] command_line, options = {}) ⇒ pid
Creates a new child process by doing one of the following in that process:
-
sprintf(format_string *objects) ⇒ String
Alias for .format.
-
srand(number = Random.new_seed) ⇒ old_seed
Seeds the system pseudo-random number generator, with
number
. -
String(object) ⇒ Object, String
Returns a string converted from
object
. -
sub(pattern, replacement) ⇒ $_
Equivalent to
$_.sub(args)
, except that$_
will be updated if substitution occurs. -
syscall(integer_callno, *arguments) ⇒ Integer
Invokes Posix system call syscall(2), which calls a specified function.
-
system([env, ] command_line, options = {}, exception: false) ⇒ true, ...
Creates a new child process by doing one of the following in that process:
-
test(char, path0, path1 = nil) ⇒ Object
:markup: markdown.
-
throw(tag [, obj])
Transfers control to the end of the active .catch block waiting for tag.
-
trace_var(symbol, cmd) ⇒ nil
Controls tracing of assignments to global variables.
-
Signal.trap(signal, command) ⇒ Object
Specifies the handling of signals.
-
untrace_var(symbol [, cmd] ) ⇒ Array?
Removes tracing for the specified command on the given global variable and returns
nil
. -
Float(arg, exception: true) ⇒ Float?
mod_func
Returns arg converted to a float.
-
Integer(object, base = 0, exception: true) ⇒ Integer?
mod_func
Returns an integer converted from
object
. -
loop
mod_func
Repeatedly executes the block.
-
warn(*msgs, uplevel: nil, category: nil) ⇒ nil
mod_func
If warnings have been disabled (for example with the
-W0
flag), does nothing. -
with_yjit(&block)
mod_func
Internal use only
Internal helper for built-in initializations to define methods only when YJIT is enabled.
Instance Attribute Summary
-
frozen? ⇒ Boolean
readonly
Returns the freeze status of obj.
Instance Method Summary
-
class ⇒ class
Returns the class of obj.
-
clone(freeze: nil) ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.
-
tap {|x| ... } ⇒ Object
Yields self to the block and then returns self.
-
then {|x| ... } ⇒ Object
(also: #yield_self)
Yields self to the block and returns the result of the block.
-
yield_self
Alias for #then.
-
pp(*objs)
(also: #pp)
private
Alias for #pp.
Class Attribute Details
block_given? ⇒ Boolean
(readonly)
Returns true
if yield
would execute a block in the current context. The .iterator? form is mildly deprecated.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello"
# File 'vm_eval.c', line 2659
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); }
iterator? ⇒ Boolean
(readonly)
Deprecated. Use block_given? instead.
# File 'vm_eval.c', line 2676
static VALUE rb_f_iterator_p(VALUE self) { rb_warn_deprecated("iterator?", "block_given?"); return rb_f_block_given_p(self); }
Class Method Details
__callee__ ⇒ Symbol
Returns the called name of the current method as a ::Symbol
. If called outside of a method, it returns nil
.
# File 'eval.c', line 1988
static VALUE rb_f_callee_name(VALUE _) { ID fname = prev_frame_callee(); /* need *callee* ID */ if (fname) { return ID2SYM(fname); } else { return Qnil; } }
__dir__ ⇒ String
Returns the canonicalized absolute path of the directory of the file from which this method is called. It means symlinks in the path is resolved. If __FILE__
is nil
, it returns nil
. The return value equals to File.dirname(File.realpath(__FILE__))
.
# File 'eval.c', line 2011
static VALUE f_current_dirname(VALUE _) { VALUE base = rb_current_realfilepath(); if (NIL_P(base)) { return Qnil; } base = rb_file_dirname(base); return base; }
__method__ ⇒ Symbol
Returns the name at the definition of the current method as a ::Symbol
. If called outside of a method, it returns nil
.
# File 'eval.c', line 1966
static VALUE rb_f_method_name(VALUE _) { ID fname = prev_frame_func(); /* need *method* ID */ if (fname) { return ID2SYM(fname); } else { return Qnil; } }
`(str)
[ GitHub ]# File 'io.c', line 10585
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; }
abort
Process.abort(msg = nil)
Terminates execution immediately, effectively by calling Kernel.exit(false)
.
If string argument msg
is given, it is written to STDERR prior to termination; otherwise, if an exception was raised, prints its message and backtrace.
# File 'process.c', line 4573
static VALUE f_abort(int c, const VALUE *a, VALUE _) { rb_f_abort(c, a); UNREACHABLE_RETURN(Qnil); }
Array(object) ⇒ Object, Array
Returns an array converted from object
.
Tries to convert object
to an array using to_ary
first and to_a
second:
Array([0, 1, 2]) # => [0, 1, 2]
Array({foo: 0, bar: 1}) # => [[:foo, 0], [:bar, 1]]
Array(0..4) # => [0, 1, 2, 3, 4]
Returns object
in an array, [object]
, if object
cannot be converted:
Array(:foo) # => [:foo]
# File 'object.c', line 3871
static VALUE rb_f_array(VALUE obj, VALUE arg) { return rb_Array(arg); }
at_exit ⇒ Proc
Converts block to a ::Proc
object (and therefore binds it at the point of call) and registers it for execution when the program exits. If multiple handlers are registered, they are executed in reverse order of registration.
def do_at_exit(str1)
at_exit { print str1 }
end
at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit
produces:
goodbye cruel world
# File 'eval_jump.c', line 37
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; }
autoload(const, filename) ⇒ nil
Registers filename to be loaded (using .require) the first time that const (which may be a .String or a symbol) is accessed.
autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
If const is defined as autoload, the file name to be loaded is replaced with filename. If const is defined but not as autoload, does nothing.
# File 'load.c', line 1539
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); }
autoload?(name, inherit = true) ⇒ String?
Returns filename to be loaded if name is registered as .autoload in the current namespace or one of its ancestors.
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
# File 'load.c', line 1572
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); }
binding ⇒ Binding
Returns a ::Binding
object, describing the variable and method bindings at the point of call. This object can be used when calling Binding#eval to execute the evaluated command in this environment, or extracting its local variables.
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 can be used to access the variables whose names are reserved Ruby keywords:
# 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
# File 'proc.c', line 374
static VALUE rb_f_binding(VALUE self) { return rb_binding_new(); }
callcc {|cont| ... } ⇒ Object
Generates a ::Continuation
object, which it passes to the associated block. You need to require 'continuation'
before using this method. Performing a cont.call
will cause the #callcc
to return (as will falling through the end of the block). The value returned by the #callcc
is the value of the block, or the value passed to cont.call
. See class ::Continuation
for more details. Also see .throw for an alternative mechanism for unwinding a call stack.
# File 'cont.c', line 1745
static VALUE rb_callcc(VALUE self) { volatile int called; volatile VALUE val = cont_capture(&called); if (called) { return val; } else { return rb_yield(val); } }
Returns the current execution stack—an array containing strings in the form file:line
or file:line: in `method'
.
The optional start parameter determines the number of initial stack entries to omit from the top of the stack.
A second optional length
parameter can be used to limit how many entries are returned from the stack.
Returns nil
if start is greater than the size of current execution stack.
Optionally you can pass a range, which will return an array containing the entries within the specified range.
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
# File 'vm_backtrace.c', line 1359
static VALUE rb_f_caller(int argc, VALUE *argv, VALUE _) { return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 1); }
Returns the current execution stack—an array containing backtrace location objects.
See ::Thread::Backtrace::Location
for more information.
The optional start parameter determines the number of initial stack entries to omit from the top of the stack.
A second optional length
parameter can be used to limit how many entries are returned from the stack.
Returns nil
if start is greater than the size of current execution stack.
Optionally you can pass a range, which will return an array containing the entries within the specified range.
# File 'vm_backtrace.c', line 1387
static VALUE rb_f_caller_locations(int argc, VALUE *argv, VALUE _) { return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 0); }
catch([tag]) {|tag| ... } ⇒ Object
catch
executes its block. If .throw is not called, the block executes normally, and catch
returns the value of the last expression evaluated.
catch(1) { 123 } # => 123
If throw(tag2, val)
is called, Ruby searches up its stack for a catch
block whose tag
has the same object_id
as tag2. When found, the block stops executing and returns val (or nil
if no second argument was given to .throw).
catch(1) { throw(1, 456) } # => 456
catch(1) { throw(1) } # => nil
When tag
is passed as the first argument, catch
yields it as the parameter of the block.
catch(1) {|x| x + 2 } # => 3
When no tag
is given, catch
yields a new unique object (as from Object.new
) as the block parameter. This object can then be used as the argument to .throw, and will match the correct catch
block.
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
# File 'vm_eval.c', line 2497
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); }
chomp ⇒ $_
chomp(string) ⇒ $_
_
chomp(string) ⇒ $_
Equivalent to $_ = $_.chomp(string)
. See String#chomp. Available only when -p/-n command line option specified.
# File 'ruby.c', line 1946
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; }
chop ⇒ $_
Equivalent to ($_.dup).chop!
, except nil
is never returned. See String#chop!. Available only when -p/-n command line option specified.
# File 'ruby.c', line 1926
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; }
Complex(real, imag = 0, exception: true) ⇒ Complex?
Complex(s, exception: true) ⇒ Complex?
Returns a new Complex object if the arguments are valid; otherwise raises an exception if exception
is true
; otherwise returns nil
.
With Numeric arguments real
and imag
, returns Complex.rect(real, imag)
if the arguments are valid.
With string argument s
, returns a new Complex object if the argument is valid; the string may have:
-
One or two numeric substrings, each of which specifies a Complex, Float, Integer, Numeric, or Rational value, specifying
rectangular coordinates
:-
Sign-separated real and imaginary numeric substrings (with trailing character
'i'
):Complex('1+2i') # => (1+2i) Complex('12i') # => (1+2i) Complex('+1-2i') # => (1-2i) Complex('-1+2i') # => (-1+2i) Complex('-1-2i') # => (-1-2i)
-
Real-only numeric string (without trailing character
'i'
):Complex('1') # => (1+0i) Complex('+1') # => (1+0i) Complex('-1') # => (-1+0i)
-
Imaginary-only numeric string (with trailing character
'i'
):Complex('1i') # => (0+1i) Complex('+1i') # => (0+1i) Complex('-1i') # => (0-1i)
-
-
At-sign separated real and imaginary rational substrings, each of which specifies a Rational value, specifying
polar coordinates
: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 'complex.c', line 576
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); }
eval(string [, binding [, filename [,lineno]]]) ⇒ Object
Evaluates the Ruby expression(s) in string. If binding is given, which must be a ::Binding
object, the evaluation is performed in its context. If the optional filename and lineno parameters are present, they will be used when reporting syntax errors.
def get_binding(str)
return binding
end
str = "hello"
eval "str + ' Fred'" #=> "hello Fred"
eval "str + ' Fred'", get_binding("bye") #=> "bye Fred"
# File 'vm_eval.c', line 1938
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); }
exec([env, ] command_line, options = {})
exec([env, ] exe_path, *args, options = {})
Replaces the current process by doing one of the following:
-
Passing string
command_line
to the shell. -
Invoking the executable at
exe_path
.
This method has potential security vulnerabilities if called with untrusted input; see Command Injection
.
The new process is created using the exec system call; it may inherit some of its environment from the calling program (possibly including open file descriptors).
Argument env
, if given, is a hash that affects ::ENV
for the new process; see Execution Environment
.
Argument options
is a hash of options for the new process; see Execution Options
.
The first required argument is one of the following:
-
command_line
if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more meta characters. -
exe_path
otherwise.
Argument command_line
String argument command_line
is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
exec('if true; then echo "Foo"; fi') # Shell reserved word.
exec('exit') # Built-in.
exec('date > date.tmp') # Contains meta character.
The command line may also contain arguments and options for the command:
exec('echo "Foo"')
Output:
Foo
See Execution Shell
for details about the shell.
Raises an exception if the new process could not execute.
Argument exe_path
Argument exe_path
is one of the following:
-
The string path to an executable to be called.
-
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
exec('/usr/bin/date')
Output:
Sat Aug 26 09:38:00 AM CDT 2023
Ruby invokes the executable directly. This form does not use the shell; see Arguments args
for caveats.
exec('doesnt_exist') # Raises Errno::ENOENT
If one or more args
is given, each is an argument or option to be passed to the executable:
exec('echo', 'C*')
exec('echo', 'hello', 'world')
Output:
C*
hello world
Raises an exception if the new process could not execute.
# File 'process.c', line 3136
static VALUE f_exec(int c, const VALUE *a, VALUE _) { rb_f_exec(c, a); UNREACHABLE_RETURN(Qnil); }
exit(status = true)
Process.exit(status = true)
Initiates termination of the Ruby script by raising SystemExit; the exception may be caught. Returns exit status status
to the underlying operating system.
Values true
and false
for argument status
indicate, respectively, success and failure; The meanings of integer values are system-dependent.
Example:
begin
exit
puts 'Never get here.'
rescue SystemExit
puts 'Rescued a SystemExit exception.'
end
puts 'After begin block.'
Output:
Rescued a SystemExit exception.
After begin block.
Just prior to final termination, Ruby executes any at-exit procedures (see .at_exit) and any object finalizers (see ObjectSpace.define_finalizer).
Example:
at_exit { puts 'In at_exit function.' }
ObjectSpace.define_finalizer('string', proc { puts 'In finalizer.' })
exit
Output:
In at_exit function.
In finalizer.
# File 'process.c', line 4525
static VALUE f_exit(int c, const VALUE *a, VALUE _) { rb_f_exit(c, a); UNREACHABLE_RETURN(Qnil); }
exit!(status = false)
Process.exit!(status = false)
# File 'process.c', line 4434
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); }
raise(exception, message = exception.to_s, backtrace = nil, cause: $!)
raise(message = nil, cause: $!)
Also known as: .raise
Raises an exception; see Exceptions
.
Argument exception
sets the class of the new exception; it should be class ::Exception
or one of its subclasses (most commonly, ::RuntimeError
or ::StandardError
), or an instance of one of those classes:
begin
raise(StandardError)
rescue => x
p x.class
end
# => StandardError
Argument message
sets the stored message in the new exception, which may be retrieved by method Exception#message;
the message must be a string-convertible object
or nil
:
begin
raise(StandardError, 'Boom')
rescue => x
p x.
end
# => "Boom"
If argument message
is not given, the message is the exception class name.
See Messages
.
Argument backtrace
sets the stored backtrace in the new exception, which may be retrieved by method Exception#backtrace;
the backtrace must be an array of strings or nil
:
begin
raise(StandardError, 'Boom', %w[foo bar baz])
rescue => x
p x.backtrace
end
# => ["foo", "bar", "baz"]
If argument backtrace
is not given, the backtrace is set according to an array of ::Thread::Backtrace::Location
objects, as derived from the call stack.
See Backtraces
.
Keyword argument cause
sets the stored cause in the new exception, which may be retrieved by method Exception#cause;
the cause must be an exception object (Exception or one of its subclasses), or nil
:
begin
raise(StandardError, cause: RuntimeError.new)
rescue => x
p x.cause
end
# => #<RuntimeError: RuntimeError>
If keyword argument cause
is not given, the cause is the value of $!
.
See Cause
.
In the alternate calling sequence, where argument exception
not given, raises a new exception of the class given by $!
, or of class ::RuntimeError
if $!
is nil
:
begin
raise
rescue => x
p x
end
# => RuntimeError
With argument exception
not given, argument message
and keyword argument cause
may be given, but argument backtrace
may not be given.
# File 'eval.c', line 836
static VALUE f_raise(int c, VALUE *v, VALUE _) { return rb_f_raise(c, v); }
Float(arg, exception: true) ⇒ Float? (mod_func)
Returns arg converted to a float. ::Numeric
types are converted directly, and with exception to .String and nil
, the rest are converted using arg.to_f
. Converting a .String with invalid characters will result in an ::ArgumentError
. Converting nil
generates a ::TypeError
. Exceptions can be suppressed by passing 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
# 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
Creates a child process.
With a block given, runs the block in the child process; on block exit, the child terminates with a status of zero:
puts "Before the fork: #{Process.pid}"
fork do
puts "In the child process: #{Process.pid}"
end # => 382141
puts "After the fork: #{Process.pid}"
Output:
Before the fork: 420496
After the fork: 420496
In the child process: 420520
With no block given, the fork
call returns twice:
-
Once in the parent process, returning the pid of the child process.
-
Once in the child process, returning
nil
.
Example:
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})"
Output:
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)
In either case, the child process may exit using .exit! to avoid the call to .at_exit.
To avoid zombie processes, the parent process should call either:
-
Process.wait, to collect the termination statuses of its children.
-
Process.detach, to register disinterest in their status.
The thread calling fork
is the only thread in the created child process; fork
doesn’t copy other threads.
Note that method fork
is available on some platforms, but not on others:
Process.respond_to?(:fork) # => true # Would be false on some.
If not, you may use .spawn instead of fork
.
# File 'process.c', line 4371
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); }
format(format_string *objects) ⇒ String Also known as: .sprintf
Returns the string resulting from formatting objects
into format_string
.
For details on format_string
, see Format Specifications
.
# File 'object.c', line 4001
static VALUE f_sprintf(int c, const VALUE *v, VALUE _) { return rb_f_sprintf(c, v); }
Returns (and assigns to $_
) the next line from the list of files in ARGV (or $*
), or from standard input if no files are present on the command line. Returns nil
at end of file. The optional argument specifies the record separator. The separator is included with the contents of each record. A separator of nil
reads the entire contents, and a zero-length separator reads the input one paragraph at a time, where paragraphs are divided by two consecutive newlines. If the first argument is an integer, or optional second argument is given, the returning string would not be longer than the given value in bytes. If multiple filenames are present in ARGV, gets(nil)
will read the contents one file at a time.
ARGV << "testfile"
print while gets
produces:
This is line one
This is line two
This is line three
And so on...
The style of programming using $_
as an implicit parameter is gradually losing favor in the Ruby community.
# File 'io.c', line 10327
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); }
global_variables ⇒ Array
Returns an array of the names of global variables. This includes special regexp global variables such as $~
and $+
, but does not include the numbered regexp global variables ($1
, $2
, etc.).
global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
# File 'eval.c', line 2034
static VALUE f_global_variables(VALUE _) { return rb_f_global_variables(); }
gsub(pattern, replacement) ⇒ $_
gsub(pattern) {|...| ... } ⇒ $_
_
gsub(pattern) {|...| ... } ⇒ $_
Equivalent to $_.gsub...
, except that $_
will be updated if substitution occurs. Available only when -p/-n command line option specified.
# File 'ruby.c', line 1908
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; }
Hash(object) ⇒ Object, Hash
Returns a hash converted from object
.
-
If
object
is:-
A hash, returns
object
. -
An empty array or
nil
, returns an empty hash.
-
-
Otherwise, if
object.to_hash
returns a hash, returns that hash. -
Otherwise, returns
::TypeError
.
Examples:
Hash({foo: 0, bar: 1}) # => {:foo=>0, :bar=>1}
Hash(nil) # => {}
Hash([]) # => {}
# File 'object.c', line 3917
static VALUE rb_f_hash(VALUE obj, VALUE arg) { return rb_Hash(arg); }
Integer(object, base = 0, exception: true) ⇒ Integer? (mod_func)
Returns an integer converted from object
.
Tries to convert object
to an integer using to_int
first and to_i
second; see below for exceptions.
With a non-zero base
, object
must be a string or convertible to a string.
Numeric objects
With an integer argument object
given, returns object
:
Integer(1) # => 1
Integer(-1) # => -1
With a floating-point argument object
given, returns object
truncated to an integer:
Integer(1.9) # => 1 # Rounds toward zero.
Integer(-1.9) # => -1 # Rounds toward zero.
String objects
With a string argument object
and zero base
given, returns object
converted to an integer in base 10:
Integer('100') # => 100
Integer('-100') # => -100
With base
zero, string object
may contain leading characters to specify the actual base (radix indicator):
Integer('0100') # => 64 # Leading '0' specifies base 8.
Integer('0b100') # => 4 # Leading '0b' specifies base 2.
Integer('0x100') # => 256 # Leading '0x' specifies base 16.
With a positive base
(in range 2..36) given, returns object
converted to an integer in the given base:
Integer('100', 2) # => 4
Integer('100', 8) # => 64
Integer('-100', 16) # => -256
With a negative base
(in range -36..-2) given, returns object
converted to the radix indicator if it exists or 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 is equivalent to the -10 case.
When converting strings, surrounding whitespace and embedded underscores are allowed and ignored:
Integer(' 100 ') # => 100
Integer('-1_0_0', 16) # => -256
Other classes
Examples with object
of various other classes:
Integer(Rational(9, 10)) # => 0 # Rounds toward zero.
Integer(Complex(2, 0)) # => 2 # Imaginary part must be zero.
Integer(Time.now) # => 1650974042
Keywords
With the optional keyword argument exception
given as true
(the default):
-
Raises TypeError if
object
does not respond toto_int
orto_i
. -
Raises TypeError if
object
isnil
. -
Raises ArgumentError if
object
is an invalid string.
With exception
given as false
, an exception of any kind is suppressed and nil
is returned.
# 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
lambda {|...| ... } ⇒ Proc
# File 'proc.c', line 876
static VALUE f_lambda(VALUE _) { f_lambda_filter_non_literal(); return rb_block_lambda(); }
load(filename, wrap = false) ⇒ true
Loads and executes the Ruby program in the file filename.
If the filename is an absolute path (e.g. starts with ‘/’), the file will be loaded directly using the absolute path.
If the filename is an explicit relative path (e.g. starts with ‘./’ or ‘../’), the file will be loaded using the relative path from the current directory.
Otherwise, the file will be searched for in the library directories listed in $LOAD_PATH
($:
). If the file is found in a directory, it will attempt to load the file relative to that directory. If the file is not found in any of the directories in $LOAD_PATH
, the file will be loaded using the relative path from the current directory.
If the file doesn’t exist when there is an attempt to load it, a ::LoadError
will be raised.
If the optional wrap parameter is true
, the loaded script will be executed under an anonymous module. If the optional wrap parameter is a module, the loaded script will be executed under the given module. In no circumstance will any local variables in the loaded file be propagated to the loading environment.
# File 'load.c', line 907
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; }
local_variables ⇒ Array
Returns the names of the current local variables.
fred = 1
for i in 1..10
# ...
end
local_variables #=> [:fred, :i]
# File 'vm_eval.c', line 2604
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); }
loop (mod_func)
loop ⇒ Enumerator
Repeatedly executes the block.
If no block is given, an enumerator is returned instead.
loop do
print "Input: "
line = gets
break if !line or line =~ /^q/i
# ...
end
A StopIteration raised in the block breaks the loop. In this case, loop returns the “result” value stored in the exception.
enum = Enumerator.new { |y|
y << "one"
y << "two"
:ok
}
result = loop {
puts enum.next
} #=> :ok
# 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
Creates an ::IO
object connected to the given file.
This method has potential security vulnerabilities if called with untrusted input; see Command Injection
.
With no block given, file stream is returned:
open('t.txt') # => #<File:t.txt>
With a block given, calls the block with the open file stream, then closes the stream:
open('t.txt') {|f| p f } # => #<File:t.txt (closed)>
Output:
#<File:t.txt>
See File.open for details.
# File 'io.c', line 8222
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); }
For each object obj
, executes:
$stdout.write(obj.inspect, "\n")
With one object given, returns the object; with multiple objects given, returns an array containing the objects; with no object given, returns nil
.
Examples:
r = Range.new(0, 4)
p r # => 0..4
p [r, r, r] # => [0..4, 0..4, 0..4]
p # => nil
Output:
0..4
[0..4, 0..4, 0..4]
p
is designed for debugging purposes. Ruby implementations may define p
to be uninterruptible in whole or in part. On CRuby, Kernel#p’s
writing of data is uninterruptible.
# File 'io.c', line 9055
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); }
print(*objects) ⇒ nil
Equivalent to $stdout.print(*objects)
, this method is the straightforward way to write to $stdout
.
Writes the given objects to $stdout
; returns nil
. Appends the output record separator $OUTPUT_RECORD_SEPARATOR
$\
), if it is not nil
.
With argument objects
given, for each object:
-
Converts via its method
to_s
if not a string. -
Writes to
stdout
. -
If not the last object, writes the output field separator
$OUTPUT_FIELD_SEPARATOR
($,
if it is notnil
.
With default separators:
objects = [0, 0.0, Rational(0, 1), Complex(0, 0), :zero, 'zero']
$OUTPUT_RECORD_SEPARATOR
$OUTPUT_FIELD_SEPARATOR
print(*objects)
Output:
nil
nil
00/10+0izerozero
With specified separators:
$OUTPUT_RECORD_SEPARATOR = "\n"
$OUTPUT_FIELD_SEPARATOR = ','
print(*objects)
Output:
0,0.0,0/1,0+0i,zero,zero
With no argument given, writes the content of $_
(which is usually the most recent user input):
gets # Sets $_ to the most recent user input.
print # Prints $_.
# File 'io.c', line 8768
static VALUE rb_f_print(int argc, const VALUE *argv, VALUE _) { rb_io_print(argc, argv, rb_ractor_stdout()); return Qnil; }
printf(format_string, *objects) ⇒ nil
printf(io, format_string, *objects) ⇒ nil
nil
printf(io, format_string, *objects) ⇒ nil
Equivalent to:
io.write(sprintf(format_string, *objects))
For details on format_string
, see Format Specifications
.
With the single argument format_string
, formats objects
into the string, then writes the formatted string to $stdout:
printf('%4.4d %10s %2.2f', 24, 24, 24.0)
Output (on $stdout):
0024 24 24.00#
With arguments io
and format_string
, formats objects
into the string, then writes the formatted string to io
:
printf($stderr, '%4.4d %10s %2.2f', 24, 24, 24.0)
Output (on $stderr):
0024 24 24.00# => nil
With no arguments, does nothing.
# File 'io.c', line 8606
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; }
proc {|...| ... } ⇒ Proc
Equivalent to Proc.new.
# File 'proc.c', line 825
static VALUE f_proc(VALUE _) { return proc_new(rb_cProc, FALSE); }
putc(int) ⇒ Integer
Equivalent to:
$stdout.putc(int)
See IO#putc for important information regarding multi-byte characters.
# File 'io.c', line 8830
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); }
puts(*objects) ⇒ nil
Equivalent to
$stdout.puts(objects)
# File 'io.c', line 8972
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); }
raise(exception, message = exception.to_s, backtrace = nil, cause: $!)
raise(message = nil, cause: $!)
Alias for .fail.
rand(max = 0) ⇒ Numeric
If called without an argument, or if max.to_i.abs == 0
, rand returns a pseudo-random floating point number between 0.0 and 1.0, including 0.0 and excluding 1.0.
rand #=> 0.2725926052826416
When max.abs
is greater than or equal to 1, rand
returns a pseudo-random integer greater than or equal to 0 and less than max.to_i.abs
.
rand(100) #=> 12
When max
is a ::Range
, rand
returns a random number where range.member?(number) == true
.
Negative or floating point values for max
are allowed, but may give surprising results.
rand(-100) # => 87
rand(-0.5) # => 0.8130921818028143
rand(1.9) # equivalent to rand(1), which is always 0
.srand may be used to ensure that sequences of random numbers are reproducible between different runs of a program.
See also Random.rand.
# File 'random.c', line 1672
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)); }
Rational(x, y, exception: true) ⇒ Rational?
Rational(arg, exception: true) ⇒ Rational?
Returns x/y
or arg
as a 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
Syntax of the string form:
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* ? ;
See also String#to_r.
# File 'rational.c', line 559
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); }
Equivalent to method .gets, except that it raises an exception if called at end-of-stream:
$ 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)
Optional keyword argument .chomp specifies whether line separators are to be omitted.
# File 'io.c', line 10410
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); }
Returns an array containing the lines returned by calling .gets until the end-of-stream is reached; (see Line IO
).
With only string argument sep
given, returns the remaining lines as determined by line separator sep
, or nil
if none; see Line Separator
:
# 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"]
With only integer argument limit
given, limits the number of bytes in the line; see Line 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"]
With arguments sep
and limit
given, combines the two behaviors (see Line Separator and Line Limit
).
Optional keyword argument .chomp specifies whether line separators are to be omitted:
$ cat t.txt | ruby -e "p readlines(chomp: true)"
["First line", "Second line", "", "Fourth line", "Fifth line"]
Optional keyword arguments enc_opts
specify encoding options; see {Encoding
options}.
# File 'io.c', line 10513
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); }
require(name) ⇒ Boolean
Loads the given name
, returning true
if successful and false
if the feature is already loaded.
If the filename neither resolves to an absolute path nor starts with ‘./’ or ‘../’, the file will be searched for in the library directories listed in $LOAD_PATH
($:
). If the filename starts with ‘./’ or ‘../’, resolution is based on Dir.pwd.
If the filename has the extension “.rb”, it is loaded as a source file; if the extension is “.so”, “.o”, or the default shared library extension on the current platform, Ruby loads the shared library as a Ruby extension. Otherwise, Ruby tries adding “.rb”, “.so”, and so on to the name until found. If the file named cannot be found, a ::LoadError
will be raised.
For Ruby extensions the filename given may use “.so” or “.o”. For example, on macOS the socket extension is “socket.bundle” and require 'socket.so'
will load the socket extension.
The absolute path of the loaded file is added to $LOADED_FEATURES
($"
). A file will not be loaded again if its path already appears in $"
. For example, require 'a'; require './a'
will not load a.rb
again.
require "my-library.rb"
require "db-driver"
Any constants or globals within the loaded source file will be available in the calling program’s global namespace. However, local variables will not be propagated to the loading environment.
# File 'load.c', line 1026
VALUE rb_f_require(VALUE obj, VALUE fname) { return rb_require_string(fname); }
require_relative(string) ⇒ Boolean
Ruby tries to load the library named string relative to the directory containing the requiring file. If the file does not exist a ::LoadError
is raised. Returns true
if the file was loaded and false
if the file was already loaded before.
# File 'load.c', line 1041
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); }
IO.select(read_ios, write_ios = [], error_ios = [], timeout = nil) ⇒ Array?
Invokes system call select(2), which monitors multiple file descriptors, waiting until one or more of the file descriptors becomes ready for some class of I/O operation.
Not implemented on all platforms.
Each of the arguments read_ios
, write_ios
, and error_ios
is an array of ::IO
objects.
Argument timeout
is a numeric value (such as integer or float) timeout interval in seconds.
The method monitors the IO objects given in all three arrays, waiting for some to be ready; returns a 3-element array whose elements are:
-
An array of the objects in
read_ios
that are ready for reading. -
An array of the objects in
write_ios
that are ready for writing. -
An array of the objects in
error_ios
have pending exceptions.
If no object becomes ready within the given timeout
, nil
is returned.
IO.select peeks the buffer of IO objects for testing readability. If the IO buffer is not empty, IO.select immediately notifies readability. This “peek” only happens for IO objects. It does not happen for IO-like objects such as OpenSSL::SSL::SSLSocket
.
The best way to use IO.select is invoking it after non-blocking methods such as #read_nonblock
, #write_nonblock
, etc. The methods raise an exception which is extended by ::IO::WaitReadable
or ::IO::WaitWritable
. The modules notify how the caller should wait with IO.select. If ::IO::WaitReadable
is raised, the caller should wait for reading. If ::IO::WaitWritable
is raised, the caller should wait for writing.
So, blocking read (#readpartial) can be emulated using #read_nonblock
and IO.select as follows:
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
Especially, the combination of non-blocking methods and IO.select is preferred for ::IO
like objects such as OpenSSL::SSL::SSLSocket
. It has #to_io
method to return underlying ::IO
object. IO.select calls #to_io
to obtain the file descriptor to wait.
This means that readability notified by IO.select doesn’t mean readability from OpenSSL::SSL::SSLSocket
object.
The most likely situation is that OpenSSL::SSL::SSLSocket
buffers some data. IO.select doesn’t see the buffer. So IO.select can block when OpenSSL::SSL::SSLSocket#readpartial
doesn’t block.
However, several more complicated situations exist.
SSL is a protocol which is sequence of records. The record consists of multiple bytes. So, the remote side of SSL sends a partial record, IO.select notifies readability but OpenSSL::SSL::SSLSocket
cannot decrypt a byte and OpenSSL::SSL::SSLSocket#readpartial
will block.
Also, the remote side can request SSL renegotiation which forces the local SSL engine to write some data. This means OpenSSL::SSL::SSLSocket#readpartial
may invoke #write
system call and it can block. In such a situation, OpenSSL::SSL::SSLSocket#read_nonblock
raises ::IO::WaitWritable
instead of blocking. So, the caller should wait for ready for writability as above example.
The combination of non-blocking methods and IO.select is also useful for streams such as tty, pipe socket socket when multiple processes read from a stream.
Finally, Linux kernel developers don’t guarantee that readability of select(2) means readability of following read(2) even for a single process; see select(2)
Invoking IO.select before IO#readpartial works well as usual. However it is not the best way to use IO.select.
The writability notified by select(2) doesn’t show how many bytes are writable. IO#write method blocks until given whole string is written. So, IO#write(two or more bytes)
can block after writability is notified by IO.select. IO#write_nonblock is required to avoid the blocking.
Blocking write (#write) can be emulated using #write_nonblock
and IO.select as follows: ::IO::WaitReadable
should also be rescued for SSL renegotiation in OpenSSL::SSL::SSLSocket
.
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
Example:
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
}
Output:
ping pong
ping pong
ping pong
(snipped)
ping
# File 'io.c', line 11075
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); }
set_trace_func(proc) ⇒ Proc
set_trace_func(nil) ⇒ nil
nil
Establishes proc as the handler for tracing, or disables tracing if the parameter is nil
.
Note: this method is obsolete, please use ::TracePoint
instead.
proc takes up to six parameters:
-
an event name string
-
a filename string
-
a line number
-
a method name symbol, or nil
-
a binding, or nil
-
the class, module, or nil
proc is invoked whenever an event occurs.
Events are:
"c-call"
-
call a C-language routine
"c-return"
-
return from a C-language routine
"call"
-
call a Ruby method
"class"
-
start a class or module definition
"end"
-
finish a class or module definition
"line"
-
execute code on a new line
"raise"
-
raise an exception
"return"
-
return from a Ruby method
Tracing is disabled within the context of 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
Produces:
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
# File 'vm_trace.c', line 578
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; }
sleep(secs = nil) ⇒ slept_secs
Suspends execution of the current thread for the number of seconds specified by numeric argument secs
, or forever if secs
is nil
; returns the integer number of seconds suspended (rounded).
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
# File 'process.c', line 5047
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); }
spawn([env, ] command_line, options = {}) ⇒ pid
spawn([env, ] exe_path, *args, options = {}) ⇒ pid
pid
spawn([env, ] exe_path, *args, options = {}) ⇒ pid
Creates a new child process by doing one of the following in that process:
-
Passing string
command_line
to the shell. -
Invoking the executable at
exe_path
.
This method has potential security vulnerabilities if called with untrusted input; see Command Injection
.
Returns the process ID (pid) of the new process, without waiting for it to complete.
To avoid zombie processes, the parent process should call either:
-
Process.wait, to collect the termination statuses of its children.
-
Process.detach, to register disinterest in their status.
The new process is created using the exec system call; it may inherit some of its environment from the calling program (possibly including open file descriptors).
Argument env
, if given, is a hash that affects ::ENV
for the new process; see Execution Environment
.
Argument options
is a hash of options for the new process; see Execution Options
.
The first required argument is one of the following:
-
command_line
if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more meta characters. -
exe_path
otherwise.
Argument command_line
String argument command_line
is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
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
The command line may also contain arguments and options for the command:
spawn('echo "Foo"') # => 799031
Process.wait # => 799031
Output:
Foo
See Execution Shell
for details about the shell.
Raises an exception if the new process could not execute.
Argument exe_path
Argument exe_path
is one of the following:
-
The string path to an executable to be called.
-
A 2-element array containing the path to an executable to be called, and the string to be used as the name of the executing process.
spawn('/usr/bin/date') # Path to date on Unix-style system. Process.wait
Output:
Mon Aug 28 11:43:10 AM CDT 2023
Ruby invokes the executable directly. This form does not use the shell; see Arguments args
for caveats.
If one or more args
is given, each is an argument or option to be passed to the executable:
spawn('echo', 'C*') # => 799392
Process.wait # => 799392
spawn('echo', 'hello', 'world') # => 799393
Process.wait # => 799393
Output:
C*
hello world
Raises an exception if the new process could not execute.
# File 'process.c', line 5004
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 }
Alias for .format.
srand(number = Random.new_seed) ⇒ old_seed
Seeds the system pseudo-random number generator, with number
. The previous seed value is returned.
If number
is omitted, seeds the generator using a source of entropy provided by the operating system, if available (/dev/urandom on Unix systems or the RSA cryptographic provider on Windows), which is then combined with the time, the process id, and a sequence number.
srand may be used to ensure repeatable sequences of pseudo-random numbers between different runs of the program. By setting the seed to a known value, programs can be made deterministic during testing.
srand 1234 # => 268519324636777531569100071560086917274
[ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
[ rand(10), rand(1000) ] # => [4, 664]
srand 1234 # => 1234
[ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
# File 'random.c', line 958
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; }
String(object) ⇒ Object, String
Returns a string converted from object
.
Tries to convert object
to a string using to_str
first and to_s
second:
String([0, 1, 2]) # => "[0, 1, 2]"
String(0..5) # => "0..5"
String({foo: 0, bar: 1}) # => "{:foo=>0, :bar=>1}"
Raises ::TypeError
if object
cannot be converted to a string.
# File 'object.c', line 3831
static VALUE rb_f_string(VALUE obj, VALUE arg) { return rb_String(arg); }
sub(pattern, replacement) ⇒ $_
sub(pattern) {|...| ... } ⇒ $_
_
sub(pattern) {|...| ... } ⇒ $_
Equivalent to $_.sub(args)
, except that $_
will be updated if substitution occurs. Available only when -p/-n command line option specified.
# File 'ruby.c', line 1889
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; }
syscall(integer_callno, *arguments) ⇒ Integer
Invokes Posix system call syscall(2), which calls a specified function.
Calls the operating system function identified by integer_callno
; returns the result of the function or raises ::SystemCallError
if it failed. The effect of the call is platform-dependent. The arguments and returned value are platform-dependent.
For each of arguments
: if it is an integer, it is passed directly; if it is a string, it is interpreted as a binary sequence of bytes. There may be as many as nine such arguments.
Arguments integer_callno
and argument
, as well as the returned value, are platform-dependent.
Note: ::Method
syscall
is essentially unsafe and unportable. The DL (Fiddle) library is preferred for safer and a bit more portable programming.
Not implemented on all platforms.
# File 'io.c', line 11550
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 }
system([env, ] command_line, options = {}, exception: false) ⇒ true
, ...
system([env, ] exe_path, *args, options = {}, exception: false) ⇒ true
, ...
true
, ...
system([env, ] exe_path, *args, options = {}, exception: false) ⇒ true
, ...
Creates a new child process by doing one of the following in that process:
-
Passing string
command_line
to the shell. -
Invoking the executable at
exe_path
.
This method has potential security vulnerabilities if called with untrusted input; see Command Injection
.
Returns:
-
true
if the command exits with status zero. -
false
if the exit status is a non-zero integer. -
nil
if the command could not execute.
Raises an exception (instead of returning false
or nil
) if keyword argument exception
is set to true
.
Assigns the command’s error status to $?
.
The new process is created using the system system call; it may inherit some of its environment from the calling program (possibly including open file descriptors).
Argument env
, if given, is a hash that affects ::ENV
for the new process; see Execution Environment
.
Argument options
is a hash of options for the new process; see Execution Options
.
The first required argument is one of the following:
-
command_line
if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more meta characters. -
exe_path
otherwise.
Argument command_line
String argument command_line
is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
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.
Assigns the command’s error status to $?
:
system('exit') # => true # Built-in.
$? # => #<Process::Status: pid 640610 exit 0>
system('date > /nop/date.tmp') # => false
$? # => #<Process::Status: pid 640742 exit 2>
The command line may also contain arguments and options for the command:
system('echo "Foo"') # => true
Output:
Foo
See Execution Shell
for details about the shell.
Raises an exception if the new process could not execute.
Argument exe_path
Argument exe_path
is one of the following:
-
The string path to an executable to be called.
-
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
system('/usr/bin/date') # => true # Path to date on Unix-style system.
system('foo') # => nil # Command failed.
Output:
Mon Aug 28 11:43:10 AM CDT 2023
Assigns the command’s error status to $?
:
system('/usr/bin/date') # => true
$? # => #<Process::Status: pid 645605 exit 0>
system('foo') # => nil
$? # => #<Process::Status: pid 645608 exit 127>
Ruby invokes the executable directly. This form does not use the shell; see Arguments args
for caveats.
system('doesnt_exist') # => nil
If one or more args
is given, each is an argument or option to be passed to the executable:
system('echo', 'C*') # => true
system('echo', 'hello', 'world') # => true
Output:
C*
hello world
Raises an exception if the new process could not execute.
# File 'process.c', line 4839
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; } }
test(char, path0, path1 = nil) ⇒ Object
:markup: markdown
Performs a test on one or both of the filesystem entities at the given paths path0
and path1
:
-
Each path
path0
orpath1
points to a file, directory, device, pipe, etc. -
Character
char
selects a specific test.
The tests:
-
Each of these tests operates only on the entity at
path0
, and returnstrue
or ‘false`; for a non-existent entity, returnsfalse
(does not raise exception):| Character | Test | |:------------:|:--------------------------------------------------------------------------| | <tt>'b'</tt> | Whether the entity is a block device. | | <tt>'c'</tt> | Whether the entity is a character device. | | <tt>'d'</tt> | Whether the entity is a directory. | | <tt>'e'</tt> | Whether the entity is an existing entity. | | <tt>'f'</tt> | Whether the entity is an existing regular file. | | <tt>'g'</tt> | Whether the entity's setgid bit is set. | | <tt>'G'</tt> | Whether the entity's group ownership is equal to the caller's. | | <tt>'k'</tt> | Whether the entity's sticky bit is set. | | <tt>'l'</tt> | Whether the entity is a symbolic link. | | <tt>'o'</tt> | Whether the entity is owned by the caller's effective uid. | | <tt>'O'</tt> | Like <tt>'o'</tt>, but uses the real uid (not the effective uid). | | <tt>'p'</tt> | Whether the entity is a FIFO device (named pipe). | | <tt>'r'</tt> | Whether the entity is readable by the caller's effective uid/gid. | | <tt>'R'</tt> | Like <tt>'r'</tt>, but uses the real uid/gid (not the effective uid/gid). | | <tt>'S'</tt> | Whether the entity is a socket. | | <tt>'u'</tt> | Whether the entity's setuid bit is set. | | <tt>'w'</tt> | Whether the entity is writable by the caller's effective uid/gid. | | <tt>'W'</tt> | Like <tt>'w'</tt>, but uses the real uid/gid (not the effective uid/gid). | | <tt>'x'</tt> | Whether the entity is executable by the caller's effective uid/gid. | | <tt>'X'</tt> | Like <tt>'x'</tt>, but uses the real uid/gid (not the effective uid/git). | | <tt>'z'</tt> | Whether the entity exists and is of length zero. |
-
This test operates only on the entity at
path0
, and returns an integer size ornil
:| Character | Test | |:------------:|:---------------------------------------------------------------------------------------------| | <tt>'s'</tt> | Returns positive integer size if the entity exists and has non-zero length, {nil} otherwise. |
-
Each of these tests operates only on the entity at
path0
, and returns a Time object; raises an exception if the entity does not exist:| Character | Test | |:------------:|:---------------------------------------| | <tt>'A'</tt> | Last access time for the entity. | | <tt>'C'</tt> | Last change time for the entity. | | <tt>'M'</tt> | Last modification time for the entity. |
-
Each of these tests operates on the modification time (
mtime
) of each of the entities atpath0
andpath1
, and returns atrue
or ‘false`; returnsfalse
if either entity does not exist:| Character | Test | |:------------:|:----------------------------------------------------------------| | <tt>'<'</tt> | Whether the {mtime} at {path0} is less than that at {path1}. | | <tt>'='</tt> | Whether the {mtime} at {path0} is equal to that at {path1}. | | <tt>'>'</tt> | Whether the {mtime} at {path0} is greater than that at {path1}. |
-
This test operates on the content of each of the entities at
path0
andpath1
, and returns atrue
or ‘false`; returnsfalse
if either entity does not exist:| Character | Test | |:------------:|:----------------------------------------------| | <tt>'-'</tt> | Whether the entities exist and are identical. |
# File 'file.c', line 5516
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); }
throw(tag [, obj])
Transfers control to the end of the active .catch block waiting for tag. Raises ::UncaughtThrowError
if there is no .catch block for the tag. The optional second parameter supplies a return value for the .catch block, which otherwise defaults to nil
. For examples, see .catch.
# File 'vm_eval.c', line 2399
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); }
trace_var(symbol, cmd) ⇒ nil
trace_var(symbol) {|val| ... } ⇒ nil
nil
trace_var(symbol) {|val| ... } ⇒ nil
Controls tracing of assignments to global variables. The parameter symbol
identifies the variable (as either a string name or a symbol identifier). cmd (which may be a string or a ::Proc
object) or block is executed whenever the variable is assigned. The block or ::Proc
object receives the variable’s new value as a parameter. Also see #untrace_var
.
trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
$_ = ' there'
produces:
$_ is now 'hello'
$_ is now ' there'
# File 'eval.c', line 2063
static VALUE f_trace_var(int c, const VALUE *a, VALUE _) { return rb_f_trace_var(c, a); }
Specifies the handling of signals. The first parameter is a signal name (a string such as “SIGALRM”, “SIGUSR1”, and so on) or a signal number. The characters “SIG” may be omitted from the signal name. The command or block specifies code to be run when the signal is raised. If the command is the string “IGNORE” or “SIG_IGN”, the signal will be ignored. If the command is “DEFAULT” or “SIG_DFL”, the Ruby’s default handler will be invoked. If the command is “EXIT”, the script will be terminated by the signal. If the command is “SYSTEM_DEFAULT”, the operating system’s default handler will be invoked. Otherwise, the given command or block will be run. The special signal name “EXIT” or signal number zero will be invoked just prior to program termination. trap returns the previous handler for the given signal.
Signal.trap(0, proc { puts "Terminating: #{$$}" })
Signal.trap("CLD") { puts "Child died" }
fork && Process.wait
produces:
Terminating: 27461
Child died
Terminating: 27460
# File 'signal.c', line 1349
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); }
untrace_var(symbol [, cmd] ) ⇒ Array?
Removes tracing for the specified command on the given global variable and returns nil
. If no command is specified, removes all tracing for that variable and returns an array containing the commands actually removed.
# File 'eval.c', line 2079
static VALUE f_untrace_var(int c, const VALUE *a, VALUE _) { return rb_f_untrace_var(c, a); }
warn(*msgs, uplevel: nil, category: nil) ⇒ nil
(mod_func)
If warnings have been disabled (for example with the -W0
flag), does nothing. Otherwise, converts each of the messages to strings, appends a newline character to the string if the string does not end in a newline, and calls Warning#warn with the string.
warn("warning 1", "warning 2")
produces:
warning 1
warning 2
If the uplevel
keyword argument is given, the string will be prepended with information for the given caller frame in the same format used by the rb_warn
C function.
# In baz.rb
def foo
warn("invalid call to foo", uplevel: 1)
end
def
foo
end
produces:
baz.rb:6: warning: invalid call to foo
If category
keyword argument is given, passes the category to Warning#warn. The category given must be one of the following categories:
:deprecated
-
Used for warning for deprecated functionality that may
be removed in the future.
:experimental
-
Used for experimental features that may change in
future releases.
:performance
-
Used for warning about APIs or pattern that have
negative performance impact
# 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
with_yjit(&block) (mod_func)
Internal helper for built-in initializations to define methods only when YJIT is enabled. This method is removed in yjit_hook.rb.
Instance Attribute Details
frozen? ⇒ Boolean
(readonly)
Returns the freeze status of obj.
a = [ "a", "b", "c" ]
a.freeze #=> ["a", "b", "c"]
a.frozen? #=> true
# File 'kernel.rb', line 67
def frozen? Primitive.attr! :leaf Primitive.cexpr! 'rb_obj_frozen_p(self)' end
Instance Method Details
class ⇒ class
Returns the class of obj. This method must always be called with an explicit receiver, as #class
is also a reserved word in Ruby.
1.class #=> Integer
self.class #=> Object
# File 'kernel.rb', line 18
def class Primitive.attr! :leaf Primitive.cexpr! 'rb_obj_class(self)' end
clone(freeze: nil) ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. #clone
copies the frozen value state of obj, unless the :freeze
keyword argument is given with a false or true value. See also the discussion under 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\">"
This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy
method of the class.
# File 'kernel.rb', line 47
def clone(freeze: nil) Primitive.rb_obj_clone2(freeze) end
pp(*objs) (private) Also known as: #pp
Alias for pp
.
# File 'prelude.rb', line 19
def pp(*objs) require 'pp' pp(*objs) end
tap {|x| ... } ⇒ Object
Yields self to the block and then returns self. The primary purpose of this method is to “tap into” a method chain, in order to perform operations on intermediate results within the chain.
(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}" }
# File 'kernel.rb', line 89
def tap Primitive.attr! :inline_block yield(self) self end
then {|x| ... } ⇒ Object Also known as: #yield_self
Yields self to the block and returns the result of the block.
3.next.then {|x| x**x }.to_s #=> "256"
A good use of then
is value piping in method chains:
require 'open-uri'
require 'json'
construct_url(arguments)
.then {|url| URI(url).read }
.then {|response| JSON.parse(response) }
When called without a block, the method returns an ::Enumerator
, which can be used, for example, for conditional circuit-breaking:
# Meets condition, no-op
1.then.detect(&:odd?) # => 1
# Does not meet condition, drop value
2.then.detect(&:odd?) # => nil
# 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
yield_self
Alias for #then.
# File 'kernel.rb', line 129
alias yield_self then