Ruby/Справочник/Kernel

Примесь Kernel

Since Ruby is very dynamic, methods added to the ancestors of BlankSlate after BlankSlate is defined will show up in the list of available BlankSlate methods. We handle this by defining a hook in the Object and Kernel classes that will hide any defined

Some objects are dupable, some are not. So we define a version of dup (called rake_dup) that returns self on the handful of classes that are not dupable.

Create a global fork method

Методы объекта

Array, Float, Integer, Pathname, String, URI, `, abort, at_exit, autoload?, autoload, binding, block_given?, callcc, caller, catch, chomp!, chomp, chop!, chop, eval, exec, exit!, exit, fail, fork, format, gem, getc, gets, global_variables, gsub!, gsub, iterator?, lambda, load, local_variables, loop, method_missing, open_uri_original_open, open, pp, pretty_inspect, printf, print, proc, putc, puts, p, raise, rake_dup, rand, readlines, readline, require_gem, require, scanf, scan, select, set_trace_func, sleep, split, sprintf, srand, sub!, sub, syscall, system, test, throw, to_ptr, trace_var, trap, untrace_var, warn, y

Kernel#Array

 Array(arg)    => array

Returns arg as an Array. First tries to call arg.to_ary, then arg.to_a. If both fail, creates a single element array containing arg (unless arg is nil).

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

Kernel#Float

 Float(arg)    => float

Returns arg converted to a float. Numeric types are converted directly, the rest are converted using arg.to_f. As of Ruby 1.8, converting nil generates a TypeError.

  Float(1)           #=> 1.0
  Float("123.456")   #=> 123.456

Kernel#Integer

 Integer(arg)    => integer

Converts arg to a Fixnum or Bignum. Numeric types are converted directly (with floating point numbers being truncated). If arg is a String, leading radix indicators (0, 0b, and 0x) are honored. Others are converted using to_int and to_i. This behavior is different from that of String#to_i.

  Integer(123.999)    #=> 123
  Integer("0x1a")     #=> 26
  Integer(Time.new)   #=> 1049896590

Kernel#Pathname

 Pathname(path)

create a pathname object. This method is available since 1.8.5.

Kernel#String

 String(arg)   => string

Converts arg to a String by calling its to_s method.

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

Kernel#URI

 URI(uri_str)

alias for URI.parse. This method is introduced at 1.8.2.

Kernel#`

 `cmd`    => string

Returns the standard output of running cmd in a subshell. The built-in syntax %x{...} uses this method. Sets $? to the process status.

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

Kernel#abort

 abort
 Kernel::abort
 Process::abort

Terminate execution immediately, effectively by calling Kernel.exit(1). If msg is given, it is written to STDERR prior to terminating.

Kernel#at_exit

 at_exit { block } -> 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

Kernel#autoload

 autoload(module, filename)   => nil

Registers filename to be loaded (using Kernel::require) the first time that module (which may be a String or a symbol) is accessed.

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

Kernel#autoload?

 autoload(module, filename)   => nil

Registers filename to be loaded (using Kernel::require) the first time that module (which may be a String or a symbol) is accessed.

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

Kernel#binding

 binding -> a_binding

Returns a Binding object, describing the variable and method bindings at the point of call. This object can be used when calling eval to execute the evaluated command in this environment. Also see the description of class Binding.

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

Kernel#block_given?

 block_given?   => true or false
 iterator?      => true or false

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"

Kernel#callcc

 callcc {|cont| block }   =>  obj

Generates a Continuation object, which it passes to the associated block. 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 Kernel::throw for an alternative mechanism for unwinding a call stack.

Kernel#caller

 caller(start=1)    => array

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 result.

  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"]
  c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11"]
  c(2)   #=> ["prog:8:in `c'", "prog:12"]
  c(3)   #=> ["prog:13"]

Kernel#catch

 catch(symbol) {| | block }  > obj

catch executes its block. If a throw is executed, Ruby searches up its stack for a catch block with a tag corresponding to the throw's symbol. If found, that block is terminated, and catch returns the value given to throw. If throw is not called, the block terminates normally, and the value of catch is the value of the last expression evaluated. catch expressions may be nested, and the throw call need not be in lexical scope.

  def routine(n)
    puts n
    throw :done if n <= 0
    routine(n-1)
  end

  catch(:done) { routine(3) }

produces:

Kernel#chomp

 chomp            => $_
 chomp(string)    => $_

Equivalent to $_ = $_.chomp(string). See String#chomp.

$_ = "now\n" chomp #=> "now" $_ #=> "now" chomp "ow" #=> "n" $_ #=> "n" chomp "xxx" #=> "n" $_ #=> "n"Kernel#chomp! правитьchomp! => $_ or nil chomp!(string) => $_ or nil

Equivalent to $_.chomp!(string). See String#chomp!

$_ = "now\n" chomp! #=> "now" $_ #=> "now" chomp! "x" #=> nil $_ #=> "now"Kernel#chop правитьchop => string

Equivalent to ($_.dup).chop!, except nil is never returned. See String#chop!.

a = "now\r\n" $_ = a chop #=> "now" $_ #=> "now" chop #=> "no" chop #=> "n" chop #=> "" chop #=> "" a #=> "now\r\n"Kernel#chop! правитьchop! => $_ or nil

Equivalent to $_.chop!.

a = "now\r\n" $_ = a chop! #=> "now" chop! #=> "no" chop! #=> "n" chop! #=> "" chop! #=> nil $_ #=> "" a #=> ""Kernel#eval правитьeval(string [, binding [, filename [,lineno]]]) => obj

Evaluates the Ruby expression(s) in string. If binding is given, the evaluation is performed in its context. The binding may be a Binding object or a Proc object. If the optional filename and lineno parameters are present, they will be used when reporting syntax errors.

def getBinding(str) return binding end str = "hello" eval "str + ' Fred'" #=> "hello Fred" eval "str + ' Fred'", getBinding("bye") #=> "bye Fred"Kernel#exec правитьexec(command [, arg, ...])

Replaces the current process by running the given external command. If exec is given a single argument, that argument is taken as a line that is subject to shell expansion before being executed. If multiple arguments are given, the second and subsequent arguments are passed as parameters to command with no shell expansion. If the first argument is a two-element array, the first element is the command to be executed, and the second argument is used as the argv[0] value, which may show up in process listings. In MSDOS environments, the command is executed in a subshell; otherwise, one of the exec(2) system calls is used, so the running command may inherit some of the environment of the original program (including open file descriptors).

exec "echo *" # echoes list of files in current directory # never get hereexec "echo", "*" # echoes an asterisk # never get hereKernel#exit правитьexit(integer=0) Kernel::exit(integer=0) Process::exit(integer=0)

Initiates the termination of the Ruby script by raising the SystemExit exception. This exception may be caught. The optional parameter is used to return a status code to the invoking environment.

begin exit puts "never get here" rescue SystemExit puts "rescued a SystemExit exception" end puts "after begin block"

produces:

rescued a SystemExit exception after begin block

Just prior to termination, Ruby executes any at_exit functions (see Kernel::at_exit) and runs any object finalizers (see ObjectSpace::define_finalizer).

at_exit { puts "at_exit function" } ObjectSpace.define_finalizer("string", proc { puts "in finalizer" }) exit

produces:

at_exit function in finalizerKernel#exit! правитьProcess.exit!(fixnum=-1)

Exits the process immediately. No exit handlers are run. fixnum is returned to the underlying system as the exit status.

Process.exit!(0)Kernel#fail правитьraise raise(string) raise(exception [, string [, array]]) fail fail(string) fail(exception [, string [, array]])

With no arguments, raises the exception in $! or raises a RuntimeError if $! is nil. With a single String argument, raises a RuntimeError with the string as a message. Otherwise, the first parameter should be the name of an Exception class (or an object that returns an Exception object when sent an exception message). The optional second parameter sets the message associated with the exception, and the third parameter is an array of callback information. Exceptions are caught by the rescue clause of begin...end blocks.

raise "Failed to create socket" raise ArgumentError, "No parameters", caller

Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:

Kernel#fork, Kernel#fork===Kernel#format===

format(format_string [, arguments...] ) => string sprintf(format_string [, arguments...] ) => string

Returns the string resulting from applying format_string to any additional arguments. Within the format string, any characters other than format sequences are copied to the result. A format sequence consists of a percent sign, followed by optional flags, width, and precision indicators, then terminated with a field type character. The field type controls how the corresponding sprintf argument is to be interpreted, while the flags modify that interpretation. The field type characters are listed in the table at the end of this section. The flag characters are:

Flag | Applies to | Meaning ---------+--------------+----------------------------------------- space | bdeEfgGiouxX | Leave a space at the start of | | positive numbers. ---------+--------------+----------------------------------------- (digit)$ | all | Specifies the absolute argument number | | for this field. Absolute and relative | | argument numbers cannot be mixed in a | | sprintf string. ---------+--------------+----------------------------------------- # | beEfgGoxX | Use an alternative format. For the | | conversions `o', `x', `X', and `b', | | prefix the result with ``0, ``0x, ``0X, | | and ``0b, respectively. For `e', | | `E', `f', `g', and 'G', force a decimal | | point to be added, even if no digits follow. | | For `g' and 'G', do not remove trailing zeros. ---------+--------------+----------------------------------------- + | bdeEfgGiouxX | Add a leading plus sign to positive numbers. ---------+--------------+----------------------------------------- - | all | Left-justify the result of this conversion. ---------+--------------+----------------------------------------- 0 (zero) | bdeEfgGiouxX | Pad with zeros, not spaces. ---------+--------------+----------------------------------------- * | all | Use the next argument as the field width. | | If negative, left-justify the result. If the | | asterisk is followed by a number and a dollar | | sign, use the indicated argument as the width.

The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field. For numeric fields, the precision controls the number of decimal places displayed. For string fields, the precision determines the maximum number of characters to be copied from the string. (Thus, the format sequence %10.10s will always contribute exactly ten characters to the result.) The field types are:

Field | Conversion ------+-------------------------------------------------------------- b | Convert argument as a binary number. c | Argument is the numeric code for a single character. d | Convert argument as a decimal number. E | Equivalent to `e', but uses an uppercase E to indicate | the exponent. e | Convert floating point argument into exponential notation | with one digit before the decimal point. The precision | determines the number of fractional digits (defaulting to six). f | Convert floating point argument as [-]ddd.ddd, | where the precision determines the number of digits after | the decimal point. G | Equivalent to `g', but use an uppercase `E' in exponent form. g | Convert a floating point number using exponential form | if the exponent is less than -4 or greater than or | equal to the precision, or in d.dddd form otherwise. i | Identical to `d'. o | Convert argument as an octal number. p | The valuing of argument.inspect. s | Argument is a string to be substituted. If the format | sequence contains a precision, at most that many characters | will be copied. u | Treat argument as an unsigned decimal number. Negative integers | are displayed as a 32 bit two's complement plus one for the | underlying architecture; that is, 2 ** 32 + n. However, since | Ruby has no inherent limit on bits used to represent the | integer, this value is preceded by two dots (..) in order to | indicate a infinite number of leading sign bits. X | Convert argument as a hexadecimal number using uppercase | letters. Negative numbers will be displayed with two | leading periods (representing an infinite string of | leading 'FF's. x | Convert argument as a hexadecimal number. | Negative numbers will be displayed with two | leading periods (representing an infinite string of | leading 'ff's.

Examples:

sprintf("%d %04x", 123, 123) #=> "123 007b" sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'" sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello" sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8" sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23" sprintf("%u", -123) #=> "..4294967173"Kernel#gem правитьgem(gem_name, *version_requirements)

Adds a Ruby Gem to the $LOAD_PATH. Before a Gem is loaded, its required Gems are loaded. If the version information is omitted, the highest version Gem of the supplied name is loaded. If a Gem is not found that meets the version requirement and/or a required Gem is not found, a Gem::LoadError is raised. More information on version requirements can be found in the Gem::Version documentation. The gem directive should be executed before any require statements (otherwise rubygems might select a conflicting library version). You can define the environment variable GEM_SKIP as a way to not load specified gems. you might do this to test out changes that haven't been intsalled yet. Example:

GEM_SKIP=libA:libB ruby-I../libA -I../libB ./mycode.rb[String or Gem::Dependency] The gem name or dependency instance. [default=">= 0.0.0"] The version requirement. [Boolean] true if the Gem is loaded, otherwise false. [Gem::LoadError] if Gem cannot be found, is listed in GEM_SKIP, or version requirement not met.Kernel#getc правитьgetc()

obsolete

Kernel#gets правитьgets(separator=$/) => string or nil

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 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.

Kernel#global_variables правитьglobal_variables => array

Returns an array of the names of global variables.

global_variables.grep /std/ #=> ["$stderr", "$stdout", "$stdin"]Kernel#gsub правитьgsub(pattern, replacement) => string gsub(pattern) {|...| block } => string

Equivalent to $_.gsub..., except that $_ receives the modified result.

$_ = "quick brown fox" gsub /[aeiou]/, '*' #=> "q**ck br*wn f*x" $_ #=> "q**ck br*wn f*x"Kernel#gsub! правитьgsub!(pattern, replacement) => string or nil gsub!(pattern) {|...| block } => string or nil

Equivalent to Kernel::gsub, except nil is returned if $_ is not modified.

$_ = "quick brown fox" gsub! /cat/, '*' #=> nil $_ #=> "quick brown fox"Kernel#iterator? правитьblock_given? => true or false iterator? => true or false

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"Kernel#lambda правитьproc { |...| block } => a_proc lambda { |...| block } => a_proc

Equivalent to Proc.new, except the resulting Proc objects check the number of parameters passed when called.

Kernel#load правитьload(filename, wrap=false) => true

Loads and executes the Ruby program in the file filename. If the filename does not resolve to an absolute path, the file is searched for in the library directories listed in $:. If the optional wrap parameter is true, the loaded script will be executed under an anonymous module, protecting the calling program's global namespace. In no circumstance will any local variables in the loaded file be propagated to the loading environment.

Kernel#local_variables правитьlocal_variables => array

Returns the names of the current local variables.

fred = 1 for i in 1..10 # ... end local_variables #=> ["fred", "i"]Kernel#loop правитьloop {|| block }

Repeatedly executes the block.

loop do print "Input: " line = gets break if !line or line =~ /^qQ/ # ... endKernel#method_missing правитьobj.method_missing(symbol [, *args] ) => result

Invoked by Ruby when obj is sent a message it cannot handle. symbol is the symbol for the method called, and args are any arguments that were passed to it. By default, the interpreter raises an error when this method is called. However, it is possible to override the method to provide more dynamic behavior. The example below creates a class Roman, which responds to methods with names consisting of roman numerals, returning the corresponding integer values.

class Roman def romanToInt(str) # ... end def method_missing(methId) str = methId.id2name romanToInt(str) end endr = Roman.new r.iv #=> 4 r.xxiii #=> 23 r.mm #=> 2000

Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:

Kernel#open, Kernel#open_uri_original_open, Kernel#open===Kernel#open_uri_original_open===

open_uri_original_open(...)

Alias for #open

Kernel#p правитьp(obj, ...) => nil

For each object, directly writes obj.inspect followed by the current output record separator to the program's standard output.

S = Struct.new(:name, :state) s = S['dave', 'TX'] p s

produces:

#<S name="dave", state="TX">Kernel#pp правитьpp(*objs)

prints arguments in pretty form. pp returns nil.

Kernel#pretty_inspect правитьpretty_inspect()

returns a pretty printed object as a string.

Kernel#print правитьprint(obj, ...) => nil

Prints each object in turn to $stdout. If the output field separator ($,) is not nil, its contents will appear between each field. If the output record separator ($\) is not nil, it will be appended to the output. If no arguments are given, prints $_. Objects that aren't strings will be converted by calling their to_s method.

print "cat", [1,2,3], 99, "\n" $, = ", " $\ = "\n" print "cat", [1,2,3], 99

produces:

cat12399 cat, 1, 2, 3, 99Kernel#printf правитьprintf(io, string [, obj ... ] ) => nil printf(string [, obj ... ] ) => nil

Equivalent to:

io.write(sprintf(string, obj, ...)

or

$stdout.write(sprintf(string, obj, ...)Kernel#proc правитьproc { |...| block } => a_proc lambda { |...| block } => a_proc

Equivalent to Proc.new, except the resulting Proc objects check the number of parameters passed when called.

Kernel#putc правитьputc(int) => int

Equivalent to:

$stdout.putc(int)Kernel#puts правитьputs(obj, ..., ...) => nil

Equivalent to

$stdout.puts(obj, ...)Kernel#raise правитьraise raise(string) raise(exception [, string [, array]]) fail fail(string) fail(exception [, string [, array]])

With no arguments, raises the exception in $! or raises a RuntimeError if $! is nil. With a single String argument, raises a RuntimeError with the string as a message. Otherwise, the first parameter should be the name of an Exception class (or an object that returns an Exception object when sent an exception message). The optional second parameter sets the message associated with the exception, and the third parameter is an array of callback information. Exceptions are caught by the rescue clause of begin...end blocks.

raise "Failed to create socket" raise ArgumentError, "No parameters", callerKernel#rake_dup правитьrake_dup()

Duplicate an object if it can be duplicated. If it can not be cloned or duplicated, then just return the original object.

Kernel#rand правитьrand(max=0) => number

Converts max to an integer using max1 = max.to_i.abs. If the result is zero, returns a pseudorandom floating point number greater than or equal to 0.0 and less than 1.0. Otherwise, returns a pseudorandom integer greater than or equal to zero and less than max1. Kernel::srand may be used to ensure repeatable sequences of random numbers between different runs of the program. Ruby currently uses a modified Mersenne Twister with a period of 219937-1.

srand 1234 #=> 0 [ rand, rand ] #=> [0.191519450163469, 0.49766366626136] [ rand(10), rand(1000) ] #=> [6, 817] srand 1234 #=> 1234 [ rand, rand ] #=> [0.191519450163469, 0.49766366626136]Kernel#readline правитьreadline(separator=$/) => string

Equivalent to Kernel::gets, except readline raises EOFError at end of file.

Kernel#readlines правитьreadlines(separator=$/) => array

Returns an array containing the lines returned by calling Kernel.gets(separator) until the end of file.

Kernel#require правитьrequire(string) => true or false

Ruby tries to load the library named string, returning true if successful. If the filename does not resolve to an absolute path, it will be searched for in the directories listed in $:. If the file has the extension ``.rb, it is loaded as a source file; if the extension is ``.so, ``.o, or ``.dll, or whatever the default shared library extension is 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. The name of the loaded feature is added to the array in $". A feature will not be loaded if it's name already appears in $". However, the file name is not converted to an absolute path, so that ``require 'a';require './a' will load a.rb twice.

require "my-library.rb" require "db-driver"Kernel#require_gem правитьrequire_gem(gem_name, *version_requirements)

Same as the gem command, but will also require a file if the gem provides an auto-required file name. DEPRECATED! Use gem instead.

Kernel#scan правитьscan(pattern) => array scan(pattern) {|///| block } => $_

Equivalent to calling $_.scan. See String#scan.

Kernel#scanf правитьscanf(fs,&b)

(нет описания...)

Kernel#select правитьIO.select(read_array [, write_array [, error_array [, timeout]]] ) => array or nil

See Kernel#select.

Kernel#set_trace_func правитьset_trace_func(proc) => proc set_trace_func(nil) => nil

Establishes proc as the handler for tracing, or disables tracing if the parameter is nil. proc takes up to six parameters: an event name, a filename, a line number, an object id, a binding, and the name of a class. 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), and return (return from a Ruby method). Tracing is disabled within the context of proc.

class Test def test a = 1 b = 2 end endset_trace_func proc { |event, file, line, id, binding, classname| printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname } t = Test.new t.testline prog.rb:11 false c-call prog.rb:11 new Class c-call prog.rb:11 initialize Object c-return prog.rb:11 initialize Object c-return prog.rb:11 new Class line prog.rb:12 false call prog.rb:2 test Test line prog.rb:3 test Test line prog.rb:4 test Test return prog.rb:4 test TestKernel#sleep правитьsleep([duration]) => fixnum

Suspends the current thread for duration seconds (which may be any number, including a Float with fractional seconds). Returns the actual number of seconds slept (rounded), which may be less than that asked for if another thread calls Thread#run. Zero arguments causes sleep to sleep forever.

Time.new #=> Wed Apr 09 08:56:32 CDT 2003 sleep 1.2 #=> 1 Time.new #=> Wed Apr 09 08:56:33 CDT 2003 sleep 1.9 #=> 2 Time.new #=> Wed Apr 09 08:56:35 CDT 2003Kernel#split правитьsplit([pattern [, limit]]) => array

Equivalent to $_.split(pattern, limit). See String#split.

Kernel#sprintf правитьformat(format_string [, arguments...] ) => string sprintf(format_string [, arguments...] ) => string

Returns the string resulting from applying format_string to any additional arguments. Within the format string, any characters other than format sequences are copied to the result. A format sequence consists of a percent sign, followed by optional flags, width, and precision indicators, then terminated with a field type character. The field type controls how the corresponding sprintf argument is to be interpreted, while the flags modify that interpretation. The field type characters are listed in the table at the end of this section. The flag characters are:

Flag | Applies to | Meaning ---------+--------------+----------------------------------------- space | bdeEfgGiouxX | Leave a space at the start of | | positive numbers. ---------+--------------+----------------------------------------- (digit)$ | all | Specifies the absolute argument number | | for this field. Absolute and relative | | argument numbers cannot be mixed in a | | sprintf string. ---------+--------------+----------------------------------------- # | beEfgGoxX | Use an alternative format. For the | | conversions `o', `x', `X', and `b', | | prefix the result with ``0, ``0x, ``0X, | | and ``0b, respectively. For `e', | | `E', `f', `g', and 'G', force a decimal | | point to be added, even if no digits follow. | | For `g' and 'G', do not remove trailing zeros. ---------+--------------+----------------------------------------- + | bdeEfgGiouxX | Add a leading plus sign to positive numbers. ---------+--------------+----------------------------------------- - | all | Left-justify the result of this conversion. ---------+--------------+----------------------------------------- 0 (zero) | bdeEfgGiouxX | Pad with zeros, not spaces. ---------+--------------+----------------------------------------- * | all | Use the next argument as the field width. | | If negative, left-justify the result. If the | | asterisk is followed by a number and a dollar | | sign, use the indicated argument as the width.

The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field. For numeric fields, the precision controls the number of decimal places displayed. For string fields, the precision determines the maximum number of characters to be copied from the string. (Thus, the format sequence %10.10s will always contribute exactly ten characters to the result.) The field types are:

Field | Conversion ------+-------------------------------------------------------------- b | Convert argument as a binary number. c | Argument is the numeric code for a single character. d | Convert argument as a decimal number. E | Equivalent to `e', but uses an uppercase E to indicate | the exponent. e | Convert floating point argument into exponential notation | with one digit before the decimal point. The precision | determines the number of fractional digits (defaulting to six). f | Convert floating point argument as [-]ddd.ddd, | where the precision determines the number of digits after | the decimal point. G | Equivalent to `g', but use an uppercase `E' in exponent form. g | Convert a floating point number using exponential form | if the exponent is less than -4 or greater than or | equal to the precision, or in d.dddd form otherwise. i | Identical to `d'. o | Convert argument as an octal number. p | The valuing of argument.inspect. s | Argument is a string to be substituted. If the format | sequence contains a precision, at most that many characters | will be copied. u | Treat argument as an unsigned decimal number. Negative integers | are displayed as a 32 bit two's complement plus one for the | underlying architecture; that is, 2 ** 32 + n. However, since | Ruby has no inherent limit on bits used to represent the | integer, this value is preceded by two dots (..) in order to | indicate a infinite number of leading sign bits. X | Convert argument as a hexadecimal number using uppercase | letters. Negative numbers will be displayed with two | leading periods (representing an infinite string of | leading 'FF's. x | Convert argument as a hexadecimal number. | Negative numbers will be displayed with two | leading periods (representing an infinite string of | leading 'ff's.

Examples:

sprintf("%d %04x", 123, 123) #=> "123 007b" sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'" sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello" sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8" sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23" sprintf("%u", -123) #=> "..4294967173"Kernel#srand правитьsrand(number=0) => old_seed

Seeds the pseudorandom number generator to the value of number.to_i.abs. If number is omitted or zero, seeds the generator using a combination of the time, the process id, and a sequence number. (This is also the behavior if Kernel::rand is called without previously calling srand, but without the sequence.) By setting the seed to a known value, scripts can be made deterministic during testing. The previous seed value is returned. Also see Kernel::rand.

Kernel#sub правитьsub(pattern, replacement) => $_ sub(pattern) { block } => $_

Equivalent to $_.sub(args), except that $_ will be updated if substitution occurs.

Kernel#sub! правитьsub!(pattern, replacement) => $_ or nil sub!(pattern) {|...| block } => $_ or nil

Equivalent to $_.sub!(args).

Kernel#syscall правитьsyscall(fixnum [, args...]) => integer

Calls the operating system function identified by fixnum, passing in the arguments, which must be either String objects, or Integer objects that ultimately fit within a native long. Up to nine parameters may be passed (14 on the Atari-ST). The function identified by fixnum is system dependent. On some Unix systems, the numbers may be obtained from a header file called syscall.h.

syscall 4, 1, "hello\n", 6 # '4' is write(2) on our box

produces:

helloKernel#system правитьsystem(cmd [, arg, ...]) => true or false

Executes cmd in a subshell, returning true if the command was found and ran successfully, false otherwise. An error status is available in $?. The arguments are processed in the same way as for Kernel::exec.

system("echo *") system("echo", "*")

produces:

config.h main.rb *Kernel#test правитьtest(int_cmd, file1 [, file2] ) => objUses the integer aCmd to perform various tests on file1 (first table below) or on file1 and file2 (second table).File tests on a single file:Test Returns Meaning ?A | Time | Last access time for file1 ?b | boolean | True if file1 is a block device ?c | boolean | True if file1 is a character device ?C | Time | Last change time for file1 ?d | boolean | True if file1 exists and is a directory ?e | boolean | True if file1 exists ?f | boolean | True if file1 exists and is a regular file ?g | boolean | True if file1 has the \CF{setgid} bit | | set (false under NT) ?G | boolean | True if file1 exists and has a group | | ownership equal to the caller's group ?k | boolean | True if file1 exists and has the sticky bit set ?l | boolean | True if file1 exists and is a symbolic link ?M | Time | Last modification time for file1 ?o | boolean | True if file1 exists and is owned by | | the caller's effective uid ?O | boolean | True if file1 exists and is owned by | | the caller's real uid ?p | boolean | True if file1 exists and is a fifo ?r | boolean | True if file1 is readable by the effective | | uid/gid of the caller ?R | boolean | True if file is readable by the real | | uid/gid of the caller ?s | int/nil | If file1 has nonzero size, return the size, | | otherwise return nil ?S | boolean | True if file1 exists and is a socket ?u | boolean | True if file1 has the setuid bit set ?w | boolean | True if file1 exists and is writable by | | the effective uid/gid ?W | boolean | True if file1 exists and is writable by | | the real uid/gid ?x | boolean | True if file1 exists and is executable by | | the effective uid/gid ?X | boolean | True if file1 exists and is executable by | | the real uid/gid ?z | boolean | True if file1 exists and has a zero length

Tests that take two files:

Transfers control to the end of the active catch block waiting for symbol. Raises NameError if there is no catch block for the symbol. The optional second parameter supplies a return value for the catch block, which otherwise defaults to nil. For examples, see Kernel::catch.

Kernel#to_ptr правитьto_ptr()

Allows arbitrary objects to be passed as a pointer to functions. (Probably not very GC safe, but by encapsulating it like this we can change the implementation later.)

Kernel#trace_var правитьtrace_var(symbol, cmd ) => nil trace_var(symbol) {|val| block } => 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 Kernel::untrace_var.

trace_var :$_, proc {|v| puts "$_ is now '#{v}'" } $_ = "hello" $_ = ' there'

produces:

$_ is now 'hello' $_ is now ' there'Kernel#trap правитьSignal.trap( signal, proc ) => obj Signal.trap( signal ) {| | block } => obj

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 operating system's default handler will be invoked. If the command is ``EXIT, the script will be terminated by the signal. 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: 27460Kernel#untrace_var правитьuntrace_var(symbol [, cmd] ) => array or nil

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.

Kernel#warn правитьwarn(msg)

(нет описания...)

Kernel#y правитьy( object, *objects )

Prints any supplied objects out in YAML. Intended as a variation on +Kernel::p+.

S = Struct.new(:name, :state) s = S['dave', 'TX'] y s

_produces:_

--- !ruby/struct:S name: dave state: TX

Ruby/Справочник/Kernel

Примесь Kernel

Kernel#Array

Kernel#Float

Kernel#Integer

Kernel#Pathname

Kernel#String

Kernel#URI

Kernel#`

Kernel#abort

Kernel#at_exit

Kernel#autoload

Kernel#autoload?

Kernel#binding

Kernel#block_given?

Kernel#callcc

Kernel#caller

Kernel#catch

Kernel#chomp

Kernel#chomp!

Kernel#chop

Kernel#chop!

Kernel#eval

Kernel#exec

Kernel#exit

Kernel#exit!

Kernel#fail

Kernel#gem

Kernel#getc

Kernel#gets

Kernel#global_variables

Kernel#gsub

Kernel#gsub!

Kernel#iterator?

Kernel#lambda

Kernel#load

Kernel#local_variables

Kernel#loop

Kernel#method_missing

Kernel#p

Kernel#pp

Kernel#pretty_inspect

Kernel#print

Kernel#printf

Kernel#proc

Kernel#putc

Kernel#puts

Kernel#raise

Kernel#rake_dup

Kernel#rand

Kernel#readline

Kernel#readlines

Kernel#require

Kernel#require_gem

Kernel#scan

Kernel#scanf

Kernel#select

Kernel#set_trace_func

Kernel#sleep

Kernel#split

Kernel#sprintf

Kernel#srand

Kernel#sub

Kernel#sub!

Kernel#syscall

Kernel#system

Kernel#test

Kernel#throw

Kernel#to_ptr

Kernel#trace_var

Kernel#trap

Kernel#untrace_var

Kernel#warn

Kernel#y