modul Kernel

# File pathname_builtin.rb, line 1167
def Pathname(path) # :doc:
  return path if Pathname === path
  Pathname.new(path)
end

Erstellt ein Pathname-Objekt.

# File lib/uri/common.rb, line 911
def URI(uri)
  if uri.is_a?(URI::Generic)
    uri
  elsif uri = String.try_convert(uri)
    URI.parse(uri)
  else
    raise ArgumentError,
      "bad argument (expected URI object or URI string)"
  end
end

Gibt ein URI-Objekt zurück, das von der gegebenen uri abgeleitet ist, die eine URI-Zeichenkette oder ein vorhandenes URI-Objekt sein kann

require 'uri'
# Returns a new URI.
uri = URI('http://github.com/ruby/ruby')
# => #<URI::HTTP http://github.com/ruby/ruby>
# Returns the given URI.
URI(uri)
# => #<URI::HTTP http://github.com/ruby/ruby>

Sie müssen 'uri' erfordern, um diese Methode zu verwenden.

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

Gibt Argumente in schöner Form aus.

pp gibt Argument(e) zurück.

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

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

Gibt den aufgerufenen Namen der aktuellen Methode als Symbol zurück. Wenn sie außerhalb einer Methode aufgerufen wird, gibt sie nil zurück.

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

Gibt den kanonisierten absoluten Pfad des Verzeichnisses der Datei zurück, aus der diese Methode aufgerufen wird. Das bedeutet, dass Symlinks im Pfad aufgelöst werden. Wenn __FILE__ nil ist, gibt sie nil zurück. Der Rückgabewert entspricht File.dirname(File.realpath(__FILE__)).

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

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

Gibt den Namen der aktuellen Methode bei ihrer Definition als Symbol zurück. Wenn sie außerhalb einer Methode aufgerufen wird, gibt sie nil zurück.

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;
}

Gibt die $stdout-Ausgabe der Ausführung von command in einer Subshell zurück; setzt die globale Variable $? auf den Prozessstatus.

Diese Methode hat potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird. Siehe Command Injection.

Beispiele

$ `date`                 # => "Wed Apr  9 08:56:30 CDT 2003\n"
$ `echo oops && exit 99` # => "oops\n"
$ $?                     # => #<Process::Status: pid 17088 exit 99>
$ $?.exitstatus          # => 99

Die eingebaute Syntax %x{...} verwendet diese Methode.

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

Gibt ein aus object konvertiertes Array zurück.

Versucht, object zuerst mit to_ary und dann mit to_a in ein Array zu konvertieren.

Array([0, 1, 2])        # => [0, 1, 2]
Array({foo: 0, bar: 1}) # => [[:foo, 0], [:bar, 1]]
Array(0..4)             # => [0, 1, 2, 3, 4]

Gibt object in einem Array zurück, [object], wenn object nicht konvertiert werden kann.

Array(:foo)             # => [:foo]

static VALUE
nucomp_f_complex(int argc, VALUE *argv, VALUE klass)
{
    VALUE a1, a2, opts = Qnil;
    int raise = TRUE;

    if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
        a2 = Qundef;
    }
    if (!NIL_P(opts)) {
        raise = rb_opts_exception_p(opts, raise);
    }
    if (argc > 0 && CLASS_OF(a1) == rb_cComplex && UNDEF_P(a2)) {
        return a1;
    }
    return nucomp_convert(rb_cComplex, a1, a2, raise);
}

Gibt ein neues Complex-Objekt zurück, wenn die Argumente gültig sind; andernfalls wird eine Ausnahme ausgelöst, wenn exception true ist; andernfalls wird nil zurückgegeben.

Mit den numerischen Argumenten real und imag gibt es Complex.rect(real, imag) zurück, wenn die Argumente gültig sind.

Mit dem String-Argument s gibt es ein neues Complex-Objekt zurück, wenn das Argument gültig ist; der String kann haben

• Ein oder zwei numerische Teilstrings, von denen jeder einen Complex, Float, Integer, Numeric oder Rational Wert angibt, der Rechteckkoordinaten angibt.

  • Mit Vorzeichen getrennte reelle und imaginäre numerische Teilstrings (mit dem nachgestellten Zeichen 'i')

    Complex('1+2i')  # => (1+2i)
    Complex('+1+2i') # => (1+2i)
    Complex('+1-2i') # => (1-2i)
    Complex('-1+2i') # => (-1+2i)
    Complex('-1-2i') # => (-1-2i)
    

  • Nur-reelle numerische Zeichenkette (ohne nachgestelltes Zeichen 'i')

    Complex('1')  # => (1+0i)
    Complex('+1') # => (1+0i)
    Complex('-1') # => (-1+0i)
    

  • Nur-imaginäre numerische Zeichenkette (mit nachgestelltem Zeichen 'i')

    Complex('1i')  # => (0+1i)
    Complex('+1i') # => (0+1i)
    Complex('-1i') # => (0-1i)
    

• Mit @-Zeichen getrennte reelle und imaginäre rationale Teilstrings, von denen jeder einen Rational Wert angibt, der Polarkoordinaten angibt.

  Complex('1/2@3/4')   # => (0.36584443443691045+0.34081938001166706i)
  Complex('+1/2@+3/4') # => (0.36584443443691045+0.34081938001166706i)
  Complex('+1/2@-3/4') # => (0.36584443443691045-0.34081938001166706i)
  Complex('-1/2@+3/4') # => (-0.36584443443691045-0.34081938001166706i)
  Complex('-1/2@-3/4') # => (-0.36584443443691045+0.34081938001166706i)
  

# File kernel.rb, line 194
def Float(arg, exception: true)
  if Primitive.mandatory_only?
    Primitive.rb_f_float1(arg)
  else
    Primitive.rb_f_float(arg, exception)
  end
end

Gibt *arg* konvertiert in einen Float zurück. Numeric-Typen werden direkt konvertiert, und mit Ausnahme von String und nil werden die übrigen über *arg*.to_f konvertiert. Die Konvertierung eines String mit ungültigen Zeichen führt zu einem ArgumentError. Die Konvertierung von nil erzeugt einen TypeError. Ausnahmen können durch Übergabe von exception: false unterdrückt werden.

Float(1)                 #=> 1.0
Float("123.456")         #=> 123.456
Float("123.0_badstring") #=> ArgumentError: invalid value for Float(): "123.0_badstring"
Float(nil)               #=> TypeError: can't convert nil into Float
Float("123.0_badstring", exception: false)  #=> nil

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

Gibt einen aus object konvertierten Hash zurück.

• Wenn object

  • Ein Hash, gibt object zurück.

  • Ein leeres Array oder nil gibt einen leeren Hash zurück.

• Andernfalls, wenn object.to_hash einen Hash zurückgibt, wird dieser Hash zurückgegeben.

• Andernfalls wird ein TypeError zurückgegeben.

Beispiele

Hash({foo: 0, bar: 1}) # => {:foo=>0, :bar=>1}
Hash(nil)              # => {}
Hash([])               # => {}

# File kernel.rb, line 287
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

Gibt einen aus object konvertierten Integer zurück.

Versucht, object zuerst mit to_int und dann mit to_i in einen Integer zu konvertieren; siehe unten für Ausnahmen.

Mit einer Basis ungleich Null muss object eine Zeichenkette sein oder in eine Zeichenkette konvertierbar sein.

Numerische Objekte

Mit einem ganzzahligen Argument object gibt es object zurück.

Integer(1)                # => 1
Integer(-1)               # => -1

Mit einem Fließkomma-Argument object gibt es object zurück, das zu einem Integer abgerundet wird.

Integer(1.9)              # => 1  # Rounds toward zero.
Integer(-1.9)             # => -1 # Rounds toward zero.

Zeichenkettenobjekte

Mit einem Zeichenkettenargument object und einer Basis von Null gibt es object zurück, das in Basis 10 in einen Integer konvertiert wird.

Integer('100')    # => 100
Integer('-100')   # => -100

Bei Basis Null kann die Zeichenkette object führende Zeichen enthalten, um die tatsächliche Basis (Radix-Indikator) anzugeben.

Integer('0100')  # => 64  # Leading '0' specifies base 8.
Integer('0b100') # => 4   # Leading '0b' specifies base 2.
Integer('0x100') # => 256 # Leading '0x' specifies base 16.

Mit einer positiven base (im Bereich 2..36) gibt es object zurück, das in der gegebenen Basis in einen Integer konvertiert wird.

Integer('100', 2)   # => 4
Integer('100', 8)   # => 64
Integer('-100', 16) # => -256

Mit einer negativen base (im Bereich -36..-2) gibt es object zurück, das in den Radix-Indikator konvertiert wird, wenn er existiert, oder 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 entspricht dem Fall -10.

Beim Konvertieren von Zeichenketten sind umgebende Leerzeichen und eingebettete Unterstriche zulässig und werden ignoriert.

Integer(' 100 ')      # => 100
Integer('-1_0_0', 16) # => -256

Andere Klassen

Beispiele mit object verschiedener anderer Klassen.

Integer(Rational(9, 10)) # => 0  # Rounds toward zero.
Integer(Complex(2, 0))   # => 2  # Imaginary part must be zero.
Integer(Time.now)        # => 1650974042

Schlüsselwörter

Mit dem optionalen Schlüsselwortargument exception, das auf true (Standard) gesetzt ist.

• Löst TypeError aus, wenn object nicht auf to_int oder to_i reagiert.

• Löst TypeError aus, wenn object nil ist.

• Löst ArgumentError aus, wenn object eine ungültige Zeichenkette ist.

Wenn exception auf false gesetzt ist, wird eine Ausnahme jeglicher Art unterdrückt und nil zurückgegeben.

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);
}

Gibt x/y oder arg als Rational zurück.

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 der Zeichenkettenform

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* ? ;

Siehe auch String#to_r.

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

Gibt eine aus object konvertierte Zeichenkette zurück.

Versucht, object zuerst mit to_str und dann mit to_s in eine Zeichenkette zu konvertieren.

String([0, 1, 2])        # => "[0, 1, 2]"
String(0..5)             # => "0..5"
String({foo: 0, bar: 1}) # => "{foo: 0, bar: 1}"

Löst TypeError aus, wenn object nicht in eine Zeichenkette konvertiert werden kann.

static VALUE
f_abort(int c, const VALUE *a, VALUE _)
{
    rb_f_abort(c, a);
    UNREACHABLE_RETURN(Qnil);
}

Beendet die Ausführung sofort, indem effektiv Kernel.exit(false) aufgerufen wird.

Wenn das Zeichenkettenargument msg gegeben ist, wird es vor der Beendigung nach STDERR geschrieben; andernfalls, wenn eine Ausnahme ausgelöst wurde, werden ihre Nachricht und ihr Backtrace ausgegeben.

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;
}

Konvertiert *block* in ein Proc-Objekt (und bindet es daher zum Zeitpunkt des Aufrufs) und registriert es zur Ausführung, wenn das Programm beendet wird. Wenn mehrere Handler registriert sind, werden sie in umgekehrter Registrierungsreihenfolge ausgeführt.

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

ergibt

goodbye cruel world

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

Registriert filename zum Laden (mittels Kernel::require), wenn const (was eine String oder ein Symbol sein kann) zum ersten Mal zugegriffen wird.

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

Wenn const als Autoload definiert ist, wird der Dateiname zum Laden durch filename ersetzt. Wenn const definiert ist, aber nicht als Autoload, tut es nichts.

Dateien, die gerade geladen werden, dürfen nicht für Autoload registriert werden.

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);
}

Gibt filename zurück, der geladen werden soll, wenn name als autoload im aktuellen Namensraum oder einem seiner Vorfahren registriert ist.

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

module C
  autoload(:D, "d")
  autoload?(:D)          #=> "d"
  autoload?(:B)          #=> nil
end

class E
  autoload(:F, "f")
  autoload?(:F)          #=> "f"
  autoload?(:B)          #=> "b"
end

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

Gibt ein Binding-Objekt zurück, das die Variablen- und Methodenassoziationen zum Zeitpunkt des Aufrufs beschreibt. Dieses Objekt kann beim Aufrufen von Binding#eval verwendet werden, um den ausgewerteten Befehl in dieser Umgebung auszuführen oder seine lokalen Variablen zu extrahieren.

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 kann verwendet werden, um auf die Variablen zuzugreifen, deren Namen reservierte Ruby-Schlüsselwörter sind.

# This is valid parameter declaration, but `if` parameter can't
# be accessed by name, because it is a reserved word.
def validate(field, validation, if: nil)
  condition = binding.local_variable_get('if')
  return unless condition

  # ...Some implementation ...
end

validate(:name, :empty?, if: false) # skips validation
validate(:name, :empty?, if: true) # performs validation

static VALUE
rb_f_block_given_p(VALUE _)
{
    rb_execution_context_t *ec = GET_EC();
    rb_control_frame_t *cfp = ec->cfp;
    cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));

    return RBOOL(cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE);
}

Gibt true zurück, wenn yield einen Block im aktuellen Kontext ausführen würde. Die Form iterator? ist leicht veraltet.

def try
  if block_given?
    yield
  else
    "no block"
  end
end
try                  #=> "no block"
try { "hello" }      #=> "hello"
try do "hello" end   #=> "hello"

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

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

Generiert ein Continuation-Objekt, das es dem zugehörigen Block übergibt. Sie müssen 'continuation' vor der Verwendung dieser Methode erfordern. Wenn Sie *cont*.call ausführen, wird callcc zurückkehren (ebenso wie das Durchlaufen des Endes des Blocks). Der von callcc zurückgegebene Wert ist der Wert des Blocks oder der Wert, der an *cont*.call übergeben wurde. Siehe Klasse Continuation für weitere Details. Siehe auch Kernel#throw für einen alternativen Mechanismus zum Entladen eines Call-Stacks.

static VALUE
rb_f_caller(int argc, VALUE *argv, VALUE _)
{
    return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 1);
}

Gibt den aktuellen Ausführungsstapel zurück – ein Array mit Zeichenketten im Format file:line oder file:line: in `method'.

Der optionale Parameter start bestimmt die Anzahl der anfänglichen Stapel-Einträge, die vom Anfang des Stapels weggelassen werden sollen.

Ein zweiter optionaler length-Parameter kann verwendet werden, um zu begrenzen, wie viele Einträge vom Stapel zurückgegeben werden.

Gibt nil zurück, wenn start größer ist als die Größe des aktuellen Ausführungsstapels.

Optional können Sie einen Bereich übergeben, der ein Array mit den Einträgen innerhalb des angegebenen Bereichs zurückgibt.

def a(skip)
  caller(skip)
end
def b(skip)
  a(skip)
end
def c(skip)
  b(skip)
end
c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10:in `<main>'"]
c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11:in `<main>'"]
c(2)   #=> ["prog:8:in `c'", "prog:12:in `<main>'"]
c(3)   #=> ["prog:13:in `<main>'"]
c(4)   #=> []
c(5)   #=> nil

static VALUE
rb_f_caller_locations(int argc, VALUE *argv, VALUE _)
{
    return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 0);
}

Gibt den aktuellen Ausführungsstapel zurück – ein Array von Backtrace-Standortobjekten.

Siehe Thread::Backtrace::Location für weitere Informationen.

Der optionale Parameter start bestimmt die Anzahl der anfänglichen Stapel-Einträge, die vom Anfang des Stapels weggelassen werden sollen.

Ein zweiter optionaler length-Parameter kann verwendet werden, um zu begrenzen, wie viele Einträge vom Stapel zurückgegeben werden.

Gibt nil zurück, wenn start größer ist als die Größe des aktuellen Ausführungsstapels.

Optional können Sie einen Bereich übergeben, der ein Array mit den Einträgen innerhalb des angegebenen Bereichs zurückgibt.

static VALUE
rb_f_catch(int argc, VALUE *argv, VALUE self)
{
    VALUE tag = rb_check_arity(argc, 0, 1) ? argv[0] : rb_obj_alloc(rb_cObject);
    return rb_catch_obj(tag, catch_i, 0);
}

catch führt seinen Block aus. Wenn throw nicht aufgerufen wird, wird der Block normal ausgeführt und catch gibt den Wert des zuletzt ausgewerteten Ausdrucks zurück.

catch(1) { 123 }            # => 123

Wenn throw(tag2, val) aufgerufen wird, durchsucht Ruby seinen Stapel nach einem catch-Block, dessen tag dieselbe object_id wie tag2 hat. Wenn er gefunden wird, stoppt die Ausführung des Blocks und gibt val zurück (oder nil, wenn kein zweites Argument an throw übergeben wurde).

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

Wenn tag als erstes Argument übergeben wird, übergibt catch es als Parameter des Blocks.

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

Wenn kein tag angegeben wird, übergibt catch ein neues eindeutiges Objekt (wie von Object.new) als Blockparameter. Dieses Objekt kann dann als Argument für throw verwendet werden und entspricht dem korrekten 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

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;
}

Entspricht $_ = $_.chomp(string). Siehe String#chomp. Nur verfügbar, wenn die Kommandozeilenoptionen -p/-n angegeben sind.

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;
}

Entspricht ($_.dup).chop!, außer dass nil niemals zurückgegeben wird. Siehe String#chop!. Nur verfügbar, wenn die Kommandozeilenoptionen -p/-n angegeben sind.

# File kernel.rb, line 18
def class
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_obj_class_must(self)'
end

Gibt die Klasse von *obj* zurück. Diese Methode muss immer mit einem expliziten Empfänger aufgerufen werden, da class auch ein reserviertes Wort in Ruby ist.

1.class      #=> Integer
self.class   #=> Object

# File kernel.rb, line 47
def clone(freeze: nil)
  Primitive.rb_obj_clone2(freeze)
end

Erzeugt eine flache Kopie von *obj* – die Instanzvariablen von *obj* werden kopiert, aber nicht die Objekte, auf die sie verweisen. clone kopiert den eingefrorenen Zustand von *obj*, es sei denn, das Schlüsselwortargument :freeze wird mit einem falschen oder wahren Wert angegeben. Siehe auch die Diskussion unter 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\">"

Diese Methode kann klassenspezifisches Verhalten aufweisen. Falls dies der Fall ist, wird dieses Verhalten unter der Methode #initialize_copy der Klasse dokumentiert.

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);
}

Wert Ruby-Ausdrücke in *string* aus. Wenn binding gegeben ist, was ein Binding-Objekt sein muss, wird die Auswertung in dessen Kontext durchgeführt. Wenn die optionalen Parameter filename und lineno vorhanden sind, werden sie bei der Meldung von Syntaxfehlern verwendet.

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

static VALUE
f_exec(int c, const VALUE *a, VALUE _)
{
    rb_f_exec(c, a);
    UNREACHABLE_RETURN(Qnil);
}

Ersetzt den aktuellen Prozess, indem eines der folgenden ausgeführt wird.

• Übergabe einer Zeichenkette command_line an die Shell.

• Aufruf der ausführbaren Datei unter exe_path.

Diese Methode hat potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird. Siehe Command Injection.

Der neue Prozess wird unter Verwendung des exec-Systemaufrufs erstellt; er kann seine Umgebung vom aufrufenden Programm erben (möglicherweise einschließlich offener Dateideskriptoren).

Das Argument env, falls gegeben, ist ein Hash, der ENV für den neuen Prozess beeinflusst; siehe Execution Environment.

Das Argument options ist ein Hash von Optionen für den neuen Prozess; siehe Execution Options.

Das erste erforderliche Argument ist eines der folgenden:

• command_line, wenn es eine Zeichenkette ist und mit einem reservierten Shell-Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

exec('if true; then echo "Foo"; fi') # Shell reserved word.
exec('exit')                         # Built-in.
exec('date > date.tmp')              # Contains meta character.

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

exec('echo "Foo"')

Ausgabe

Foo

Siehe Execution Shell für Details zur Shell.

Löst eine Ausnahme aus, wenn der neue Prozess nicht ausgeführt werden konnte.

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

exec('/usr/bin/date')

Ausgabe

Sat Aug 26 09:38:00 AM CDT 2023

Ruby ruft die ausführbare Datei direkt auf. Diese Form verwendet nicht die Shell; siehe Arguments args für Vorbehalte.

exec('doesnt_exist') # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

exec('echo', 'C*')
exec('echo', 'hello', 'world')

Ausgabe

C*
hello world

Löst eine Ausnahme aus, wenn der neue Prozess nicht ausgeführt werden konnte.

static VALUE
f_exit(int c, const VALUE *a, VALUE _)
{
    rb_f_exit(c, a);
    UNREACHABLE_RETURN(Qnil);
}

Leitet die Beendigung des Ruby-Skripts ein, indem SystemExit ausgelöst wird; die Ausnahme kann abgefangen werden. Gibt den Exit-Status status an das zugrunde liegende Betriebssystem zurück.

Die Werte true und false für das Argument status bedeuten jeweils Erfolg und Misserfolg; die Bedeutung von Ganzzahlwerten ist systemabhängig.

Beispiel

begin
  exit
  puts 'Never get here.'
rescue SystemExit
  puts 'Rescued a SystemExit exception.'
end
puts 'After begin block.'

Ausgabe

Rescued a SystemExit exception.
After begin block.

Unmittelbar vor der endgültigen Beendigung führt Ruby alle At-Exit-Prozeduren aus (siehe Kernel::at_exit) und alle Objektfinalisierer (siehe ObjectSpace::define_finalizer).

Beispiel

at_exit { puts 'In at_exit function.' }
ObjectSpace.define_finalizer('string', proc { puts 'In finalizer.' })
exit

Ausgabe

In at_exit function.
In finalizer.

static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
    int istatus;

    if (rb_check_arity(argc, 0, 1) == 1) {
        istatus = exit_status_code(argv[0]);
    }
    else {
        istatus = EXIT_FAILURE;
    }
    _exit(istatus);

    UNREACHABLE_RETURN(Qnil);
}

Beendet den Prozess sofort; es werden keine Exit-Handler aufgerufen. Gibt den Exit-Status status an das zugrunde liegende Betriebssystem zurück.

Process.exit!(true)

Die Werte true und false für das Argument status bedeuten jeweils Erfolg und Misserfolg; die Bedeutung von Ganzzahlwerten ist systemabhängig.

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);
}

Erstellt einen Kindprozess.

Wenn ein Block gegeben ist, wird der Block im Kindprozess ausgeführt; beim Beenden des Blocks wird das Kind mit dem Status Null beendet.

puts "Before the fork: #{Process.pid}"
fork do
  puts "In the child process: #{Process.pid}"
end                   # => 382141
puts "After the fork: #{Process.pid}"

Ausgabe

Before the fork: 420496
After the fork: 420496
In the child process: 420520

Wenn kein Block gegeben ist, gibt der fork-Aufruf zweimal zurück.

• Einmal im Elternprozess, gibt die PID des Kindprozesses zurück.

• Einmal im Kindprozess, gibt nil zurück.

Beispiel

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})"

Ausgabe

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 beiden Fällen kann der Kindprozess mit Kernel.exit! beendet werden, um den Aufruf von Kernel#at_exit zu vermeiden.

Um Zombie-Prozesse zu vermeiden, sollte der Elternprozess entweder aufrufen:

• Process.wait, um die Beendigungsstatus seiner Kinder zu erfassen.

• Process.detach, um Desinteresse an ihrem Status zu registrieren.

Der Thread, der fork aufruft, ist der einzige Thread im erstellten Kindprozess; fork kopiert keine anderen Threads.

Beachten Sie, dass die Methode fork auf einigen Plattformen verfügbar ist, auf anderen jedoch nicht.

Process.respond_to?(:fork) # => true # Would be false on some.

Wenn nicht, können Sie ::spawn anstelle von fork verwenden.

# File kernel.rb, line 67
def frozen?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_obj_frozen_p(self)'
end

Gibt den Einfrierstatus von *obj* zurück.

a = [ "a", "b", "c" ]
a.freeze    #=> ["a", "b", "c"]
a.frozen?   #=> true

static VALUE
rb_f_gets(int argc, VALUE *argv, VALUE recv)
{
    if (recv == argf) {
        return argf_gets(argc, argv, argf);
    }
    return forward(argf, idGets, argc, argv);
}

Gibt die nächste Zeile aus der Liste der Dateien in ARGV (oder $*) oder aus der Standardeingabe zurück (und weist sie $_ zu), wenn keine Dateien vorhanden sind. Gibt nil am Ende der Datei zurück. Das optionale Argument gibt den Datensatztrenner an. Der Trenner ist im Inhalt jedes Datensatzes enthalten. Ein Trenner von nil liest den gesamten Inhalt, und ein Trenner mit leerer Zeichenkette liest die Eingabe absatzweise, wobei Absätze durch zwei aufeinanderfolgende Zeilenumbrüche getrennt sind. Wenn das erste Argument eine Ganzzahl ist oder das optionale zweite Argument angegeben ist, ist die zurückgegebene Zeichenkette nicht länger als der angegebene Wert in Bytes. Wenn mehrere Dateinamen in ARGV vorhanden sind, liest gets(nil) den Inhalt nacheinander aus jeder Datei.

ARGV << "testfile"
print while gets

ergibt

This is line one
This is line two
This is line three
And so on...

Die Programmierweise, die $_ als impliziten Parameter verwendet, verliert in der Ruby-Community allmählich an Gunst.

static VALUE
f_global_variables(VALUE _)
{
    return rb_f_global_variables();
}

Gibt ein Array der Namen globaler Variablen zurück. Dies schließt spezielle Regex-Globale Variablen wie $~ und $+ ein, aber nicht die nummerierten Regex-Globale Variablen ($1, $2, etc.).

global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]

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

Entspricht $_.gsub..., außer dass $_ aktualisiert wird, wenn eine Ersetzung stattfindet. Nur verfügbar, wenn die Kommandozeilenoptionen -p/-n angegeben sind.

static VALUE
rb_f_iterator_p(VALUE self)
{
    rb_warn_deprecated("iterator?", "block_given?");
    return rb_f_block_given_p(self);
}

Veraltet. Verwenden Sie stattdessen block_given?.

static VALUE
f_lambda(VALUE _)
{
    f_lambda_filter_non_literal();
    return rb_block_lambda();
}

Entspricht Proc.new, mit der Ausnahme, dass die resultierenden Proc-Objekte die Anzahl der übergebenen Parameter beim Aufruf überprüfen.

static VALUE
rb_f_load(int argc, VALUE *argv, VALUE _)
{
    VALUE fname, wrap;
    rb_scan_args(argc, argv, "11", &fname, &wrap);
    return load_entrypoint_internal(fname, wrap);
}

Lädt und führt das Ruby-Programm in der Datei filename aus.

Wenn der Dateiname ein absoluter Pfad ist (z. B. mit „/“ beginnt), wird die Datei direkt unter Verwendung des absoluten Pfads geladen.

Wenn der Dateiname ein expliziter relativer Pfad ist (z. B. mit „./“ oder „../“ beginnt), wird die Datei unter Verwendung des relativen Pfads vom aktuellen Verzeichnis aus geladen.

Andernfalls wird die Datei in den in $LOAD_PATH ($:) aufgeführten Verzeichnissen gesucht. Wenn die Datei in einem Verzeichnis gefunden wird, wird versucht, die Datei relativ zu diesem Verzeichnis zu laden. Wenn die Datei in keinem der Verzeichnisse in $LOAD_PATH gefunden wird, wird die Datei unter Verwendung des relativen Pfads vom aktuellen Verzeichnis aus geladen.

Wenn die Datei beim Versuch, sie zu laden, nicht existiert, wird ein LoadError ausgelöst.

Wenn der optionale Parameter wrap auf true gesetzt ist, wird das geladene Skript unter einem anonymen Modul ausgeführt. Wenn der optionale Parameter wrap ein Modul ist, wird das geladene Skript unter dem gegebenen Modul ausgeführt. Unter keinen Umständen werden lokale Variablen aus der geladenen Datei in die ladende Umgebung propagiert.

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);
}

Gibt die Namen der aktuellen lokalen Variablen zurück.

fred = 1
for i in 1..10
   # ...
end
local_variables   #=> [:fred, :i]

# File kernel.rb, line 161
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

Führt den Block wiederholt aus.

Wenn kein Block angegeben wird, wird stattdessen ein Enumerator zurückgegeben.

loop do
  print "Input: "
  line = gets
  # break if q, Q is entered or EOF signal (Ctrl-D on Unix, Ctrl-Z on windows) is sent
  break if !line or line =~ /^q/i
  # ...
end

Eine in den Block ausgelöste StopIteration unterbricht die Schleife. In diesem Fall gibt loop den in der Ausnahme gespeicherten „Ergebnis“-Wert zurück.

enum = Enumerator.new { |y|
  y << "one"
  y << "two"
  :ok
}

result = loop {
  puts enum.next
} #=> :ok

static VALUE
rb_f_open(int argc, VALUE *argv, VALUE _)
{
    ID to_open = 0;
    int redirect = FALSE;

    if (argc >= 1) {
        CONST_ID(to_open, "to_open");
        if (rb_respond_to(argv[0], to_open)) {
            redirect = TRUE;
        }
        else {
            VALUE tmp = argv[0];
            FilePathValue(tmp);
            if (NIL_P(tmp)) {
                redirect = TRUE;
            }
            else {
                argv[0] = tmp;
            }
        }
    }
    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);
}

Erstellt ein IO-Objekt, das mit der gegebenen Datei verbunden ist.

Diese Methode hat potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird. Siehe Command Injection.

Wenn kein Block gegeben ist, wird der Dateistream zurückgegeben.

open('t.txt') # => #<File:t.txt>

Wenn ein Block gegeben ist, wird der Block mit dem geöffneten Dateistream aufgerufen, dann wird der Stream geschlossen.

open('t.txt') {|f| p f } # => #<File:t.txt (closed)>

Ausgabe

#<File:t.txt>

Siehe File.open für Details.

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);
}

Für jedes Objekt obj wird Folgendes ausgeführt:

$stdout.write(obj.inspect, "\n")

Wenn ein Objekt gegeben ist, gibt es das Objekt zurück; wenn mehrere Objekte gegeben sind, gibt es ein Array zurück, das die Objekte enthält; wenn kein Objekt gegeben ist, gibt es nil zurück.

Beispiele

r = Range.new(0, 4)
p r                 # => 0..4
p [r, r, r]         # => [0..4, 0..4, 0..4]
p                   # => nil

Ausgabe

0..4
[0..4, 0..4, 0..4]

Kernel#p ist für Debugging-Zwecke konzipiert. Ruby-Implementierungen können Kernel#p so definieren, dass es ganz oder teilweise nicht unterbrechbar ist. Auf CRuby ist das Schreiben von Daten durch Kernel#p nicht unterbrechbar.

# File lib/pp.rb, line 724
def pretty_inspect
  PP.pp(self, ''.dup)
end

Gibt ein hübsch formatiertes Objekt als Zeichenkette zurück.

Siehe das Modul PP für weitere Informationen.

static VALUE
rb_f_print(int argc, const VALUE *argv, VALUE _)
{
    rb_io_print(argc, argv, rb_ractor_stdout());
    return Qnil;
}

Entspricht $stdout.print(*objects), diese Methode ist der direkte Weg, um nach $stdout zu schreiben.

Schreibt die gegebenen Objekte nach $stdout; gibt nil zurück. Hängt den Ausgabedatensatztrenner $OUTPUT_RECORD_SEPARATOR $\ an, wenn er nicht nil ist.

Mit dem Argument objects, für jedes Objekt

• Konvertiert über seine Methode to_s, wenn es keine Zeichenkette ist.

• Schreibt nach stdout.

• Wenn es nicht das letzte Objekt ist, schreibt es den Ausgabefeldbegrenzer $OUTPUT_FIELD_SEPARATOR ($,, wenn er nicht nil ist.

Mit Standardtrennzeichen

objects = [0, 0.0, Rational(0, 1), Complex(0, 0), :zero, 'zero']
$OUTPUT_RECORD_SEPARATOR
$OUTPUT_FIELD_SEPARATOR
print(*objects)

Ausgabe

nil
nil
00.00/10+0izerozero

Mit spezifizierten Trennzeichen

$OUTPUT_RECORD_SEPARATOR = "\n"
$OUTPUT_FIELD_SEPARATOR = ','
print(*objects)

Ausgabe

0,0.0,0/1,0+0i,zero,zero

Ohne Argument wird der Inhalt von $_ geschrieben (was normalerweise die letzte Benutzereingabe ist).

gets  # Sets $_ to the most recent user input.
print # Prints $_.

static VALUE
rb_f_printf(int argc, VALUE *argv, VALUE _)
{
    VALUE out;

    if (argc == 0) return Qnil;
    if (RB_TYPE_P(argv[0], T_STRING)) {
        out = rb_ractor_stdout();
    }
    else {
        out = argv[0];
        argv++;
        argc--;
    }
    rb_io_write(out, rb_f_sprintf(argc, argv));

    return Qnil;
}

Entspricht

io.write(sprintf(format_string, *objects))

Details zu format_string finden Sie unter Formatangaben.

Mit dem einzelnen Argument format_string formatiert es objects in die Zeichenkette und schreibt dann die formatierte Zeichenkette nach $stdout.

printf('%4.4d %10s %2.2f', 24, 24, 24.0)

Ausgabe (auf $stdout)

0024         24 24.00#

Mit den Argumenten io und format_string formatiert es objects in die Zeichenkette und schreibt dann die formatierte Zeichenkette nach io.

printf($stderr, '%4.4d %10s %2.2f', 24, 24, 24.0)

Ausgabe (auf $stderr)

0024         24 24.00# => nil

Ohne Argumente tut es nichts.

static VALUE
f_proc(VALUE _)
{
    return proc_new(rb_cProc, FALSE);
}

Entspricht Proc.new.

static VALUE
rb_f_putc(VALUE recv, VALUE ch)
{
    VALUE r_stdout = rb_ractor_stdout();
    if (recv == r_stdout) {
        return rb_io_putc(recv, ch);
    }
    return forward(r_stdout, rb_intern("putc"), 1, &ch);
}

Entspricht

$stdout.putc(int)

Siehe IO#putc für wichtige Informationen zu Mehrbytezeichen.

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);
}

Entspricht

$stdout.puts(objects)

static VALUE
f_raise(int c, VALUE *v, VALUE _)
{
    return rb_f_raise(c, v);
}

Löst eine Ausnahme aus; siehe Exceptions.

Das Argument exception legt die Klasse der neuen Ausnahme fest; es sollte die Klasse Exception oder eine ihrer Unterklassen sein (am häufigsten RuntimeError oder StandardError) oder eine Instanz einer dieser Klassen.

begin
  raise(StandardError)
rescue => x
  p x.class
end
# => StandardError

Argument message legt die gespeicherte Nachricht in der neuen Ausnahme fest, die über die Methode Exception#message abgerufen werden kann; die Nachricht muss ein zeichenkettenkonvertierbares Objekt oder nil sein.

begin
  raise(StandardError, 'Boom')
rescue => x
  p x.message
end
# => "Boom"

Wenn das Argument message nicht angegeben wird, ist die Nachricht der Name der Ausnahmeklasse.

Siehe Nachrichten.

Das Argument backtrace kann verwendet werden, um den Backtrace der neuen Ausnahme zu ändern, wie er von Exception#backtrace und Exception#backtrace_locations gemeldet wird; der Backtrace muss ein Array von Thread::Backtrace::Location, ein Array von Zeichenketten, eine einzelne Zeichenkette oder nil sein.

Die Verwendung des Arrays von Thread::Backtrace::Location-Instanzen ist die konsistenteste Option und sollte, wenn möglich, bevorzugt werden. Der notwendige Wert kann von caller_locations erhalten oder aus Exception#backtrace_locations eines anderen Fehlers kopiert werden.

begin
  do_some_work()
rescue ZeroDivisionError => ex
  raise(LogicalError, "You have an error in your math", ex.backtrace_locations)
end

Die Art und Weise, wie sowohl Exception#backtrace als auch Exception#backtrace_locations des ausgelösten Fehlers gesetzt werden, ist derselbe Backtrace.

Wenn der gewünschte Stack von Locations nicht verfügbar ist und von Grund auf neu konstruiert werden soll, kann ein Array von Zeichenketten oder eine einzelne Zeichenkette verwendet werden. In diesem Fall wird nur Exception#backtrace gesetzt.

begin
  raise(StandardError, 'Boom', %w[dsl.rb:3 framework.rb:1])
rescue => ex
  p ex.backtrace
  # => ["dsl.rb:3", "framework.rb:1"]
  p ex.backtrace_locations
  # => nil
end

Wenn das Argument backtrace nicht angegeben wird, wird der Backtrace gemäß einem Array von Thread::Backtrace::Location-Objekten gesetzt, wie sie aus dem Aufrufstack abgeleitet werden.

Siehe Backtraces.

Das Schlüsselwortargument cause legt die gespeicherte Ursache in der neuen Ausnahme fest, die über die Methode Exception#cause abgerufen werden kann; die Ursache muss ein Ausnahmeobjekt (Exception oder eine seiner Unterklassen) oder nil sein.

begin
  raise(StandardError, cause: RuntimeError.new)
rescue => x
  p x.cause
end
# => #<RuntimeError: RuntimeError>

Wenn das Schlüsselwortargument cause nicht angegeben wird, ist die Ursache der Wert von $!.

Siehe Ursache.

In der alternativen Aufrufsequenz, bei der das Argument exception *nicht* gegeben ist, wird eine neue Ausnahme der von $! angegebenen Klasse ausgelöst, oder die Klasse RuntimeError, wenn $! nil ist.

begin
  raise
rescue => x
  p x
end
# => RuntimeError

Wenn das Argument exception nicht gegeben ist, können das Argument message und das Schlüsselwortargument cause gegeben werden, aber das Argument backtrace darf nicht gegeben werden.

cause kann nicht als einziges Argument gegeben werden.

static VALUE
rb_f_rand(int argc, VALUE *argv, VALUE obj)
{
    VALUE vmax;
    rb_random_t *rnd = default_rand_start();

    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));
}

Wenn es ohne Argument aufgerufen wird oder wenn max.to_i.abs == 0 ist, gibt rand eine pseudo-zufällige Gleitkommazahl zwischen 0,0 und 1,0 zurück, einschließlich 0,0 und ausschließlich 1,0.

rand        #=> 0.2725926052826416

Wenn max.abs größer oder gleich 1 ist, gibt rand eine pseudo-zufällige Ganzzahl zurück, die größer oder gleich 0 und kleiner als max.to_i.abs ist.

rand(100)   #=> 12

Wenn max ein Range ist, gibt rand eine zufällige Zahl zurück, bei der range.member?(number) == true gilt.

Negative oder Gleitkommawerte für max sind erlaubt, können aber zu überraschenden Ergebnissen führen.

rand(-100) # => 87
rand(-0.5) # => 0.8130921818028143
rand(1.9)  # equivalent to rand(1), which is always 0

Kernel.srand kann verwendet werden, um sicherzustellen, dass Sequenzen von Zufallszahlen zwischen verschiedenen Programmläufen reproduzierbar sind.

Verwandt: Random.rand.

rand(100.0)        # => 64 (Integer because max.to_i is 100)
Random.rand(100.0) # => 30.315320967824523

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);
}

Entspricht der Methode Kernel#gets, mit der Ausnahme, dass eine Ausnahme ausgelöst wird, wenn sie am Ende des Streams aufgerufen wird.

$ 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)

Das optionale Schlüsselwortargument chomp gibt an, ob Zeilentrennzeichen weggelassen werden sollen.

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);
}

Gibt ein Array zurück, das die Zeilen enthält, die durch Aufruf von Kernel#gets bis zum Ende des Streams zurückgegeben werden; (siehe Zeilen-IO).

Wenn nur das Zeichenkettenargument sep gegeben ist, werden die verbleibenden Zeilen zurückgegeben, wie durch den Zeilentrennzeichen sep bestimmt, oder nil, falls keine vorhanden sind; siehe Zeilentrennzeichen.

# 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"]

Wenn nur das Ganzzahlargument limit gegeben ist, wird die Anzahl der Bytes in der Zeile begrenzt; siehe Zeilenbegrenzung.

$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"]

Wenn die Argumente sep und limit gegeben sind, werden beide Verhaltensweisen kombiniert (siehe Zeilentrennzeichen und Zeilenbegrenzung).

Das optionale Schlüsselwortargument chomp gibt an, ob Zeilentrennzeichen weggelassen werden sollen.

$ cat t.txt | ruby -e "p readlines(chomp: true)"
["First line", "Second line", "", "Fourth line", "Fifth line"]

Optionale Schlüsselwortargumente enc_opts legen Kodierungsoptionen fest; siehe Kodierungsoptionen.

VALUE
rb_f_require_relative(VALUE obj, VALUE fname)
{
    return rb_require_relative_entrypoint(fname);
}

Ruby versucht, die Bibliothek mit dem Namen *string* relativ zum Verzeichnis der anfordernden Datei zu laden. Wenn die Datei nicht existiert, wird ein LoadError ausgelöst. Gibt true zurück, wenn die Datei geladen wurde, und false, wenn die Datei bereits zuvor geladen wurde.

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) || is_pos_inf(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);
}

Ruft den Systemaufruf select(2) auf, der mehrere Dateideskriptoren überwacht und darauf wartet, dass einer oder mehrere der Dateideskriptoren für eine bestimmte Art von I/O-Operation bereit werden.

Nicht auf allen Plattformen implementiert.

Jedes der Argumente read_ios, write_ios und error_ios ist ein Array von IO-Objekten.

Das Argument timeout ist ein numerischer Wert (wie Ganzzahl oder Gleitkommazahl) für das Zeitlimit in Sekunden. timeout kann auch nil oder Float::INFINITY sein. nil und Float::INFINITY bedeuten kein Zeitlimit.

Die Methode überwacht die in allen drei Arrays angegebenen IO-Objekte und wartet darauf, dass einige davon bereit werden; gibt ein 3-Element-Array zurück, dessen Elemente sind:

• Ein Array der Objekte in read_ios, die zum Lesen bereit sind.

• Ein Array der Objekte in write_ios, die zum Schreiben bereit sind.

• Ein Array der Objekte in error_ios, die ausstehende Ausnahmen haben.

Wenn innerhalb des angegebenen timeout kein Objekt bereit wird, wird nil zurückgegeben.

IO.select prüft den Puffer von IO-Objekten, um die Lesebereitschaft zu testen. Wenn der IO-Puffer nicht leer ist, benachrichtigt IO.select sofort die Lesebereitschaft. Dieses "Prüfen" erfolgt nur für IO-Objekte. Es erfolgt nicht für IO-ähnliche Objekte wie OpenSSL::SSL::SSLSocket.

Der beste Weg, IO.select zu verwenden, ist der Aufruf nach nicht-blockierenden Methoden wie read_nonblock, write_nonblock usw. Die Methoden lösen eine Ausnahme aus, die von IO::WaitReadable oder IO::WaitWritable erweitert wird. Die Module benachrichtigen, wie der Aufrufer mit IO.select warten soll. Wenn IO::WaitReadable ausgelöst wird, sollte der Aufrufer auf Lesen warten. Wenn IO::WaitWritable ausgelöst wird, sollte der Aufrufer auf Schreiben warten.

Daher kann blockierendes Lesen (readpartial) mit read_nonblock und IO.select wie folgt emuliert werden:

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

Insbesondere ist die Kombination von nicht-blockierenden Methoden und IO.select für IO-ähnliche Objekte wie OpenSSL::SSL::SSLSocket vorzuziehen. Diese haben eine to_io-Methode, um das zugrunde liegende IO-Objekt zurückzugeben. IO.select ruft to_io auf, um den Dateideskriptor zu erhalten, auf den gewartet werden soll.

Das bedeutet, dass die von IO.select gemeldete Lesebereitschaft keine Lesebereitschaft vom OpenSSL::SSL::SSLSocket-Objekt bedeutet.

Die wahrscheinlichste Situation ist, dass OpenSSL::SSL::SSLSocket Daten puffert. IO.select sieht den Puffer nicht. Daher kann IO.select blockieren, während OpenSSL::SSL::SSLSocket#readpartial nicht blockiert.

Es gibt jedoch einige kompliziertere Situationen.

SSL ist ein Protokoll, das eine Sequenz von Datensätzen ist. Der Datensatz besteht aus mehreren Bytes. Daher sendet die Remote-Seite von SSL einen Teil-Datensatz, IO.select meldet Lesebereitschaft, aber OpenSSL::SSL::SSLSocket kann ein Byte nicht entschlüsseln und OpenSSL::SSL::SSLSocket#readpartial blockiert.

Außerdem kann die Remote-Seite eine SSL-Neuaushandlung anfordern, die die lokale SSL-Engine zwingt, einige Daten zu schreiben. Dies bedeutet, dass OpenSSL::SSL::SSLSocket#readpartial einen Schreibsystemaufruf auslösen kann und dieser blockieren kann. In einer solchen Situation löst OpenSSL::SSL::SSLSocket#read_nonblock IO::WaitWritable aus, anstatt zu blockieren. Der Aufrufer sollte also wie im obigen Beispiel auf Schreibbereitschaft warten.

Die Kombination von nicht-blockierenden Methoden und IO.select ist auch nützlich für Streams wie tty, Pipe-Sockets, wenn mehrere Prozesse von einem Stream lesen.

Schließlich garantieren Linux-Kernel-Entwickler nicht, dass die Lesebereitschaft von select(2) auch für einen einzelnen Prozess Lesebereitschaft für nachfolgende read(2)-Aufrufe bedeutet; siehe select(2).

IO.select vor IO#readpartial aufzurufen funktioniert wie üblich gut. Es ist jedoch nicht die beste Art, IO.select zu verwenden.

Die von select(2) gemeldete Schreibbereitschaft zeigt nicht an, wie viele Bytes schreibbar sind. Die Methode IO#write blockiert, bis die angegebene gesamte Zeichenkette geschrieben ist. Daher kann IO#write(zwei oder mehr Bytes) nach Benachrichtigung der Schreibbereitschaft durch IO.select blockieren. IO#write_nonblock ist erforderlich, um das Blockieren zu vermeiden.

Blockierendes Schreiben (write) kann mit write_nonblock und IO.select wie folgt emuliert werden: IO::WaitReadable sollte auch für die SSL-Neuaushandlung in OpenSSL::SSL::SSLSocket abgefangen werden.

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

Beispiel

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
}

Ausgabe

ping pong
ping pong
ping pong
(snipped)
ping

static VALUE
set_trace_func(VALUE obj, VALUE trace)
{
    rb_remove_event_hook(call_trace_func);

    if (NIL_P(trace)) {
        return Qnil;
    }

    if (!rb_obj_is_proc(trace)) {
        rb_raise(rb_eTypeError, "trace_func needs to be Proc");
    }

    rb_add_event_hook(call_trace_func, RUBY_EVENT_ALL, trace);
    return trace;
}

Legt proc als Handler für das Tracing fest oder deaktiviert das Tracing, wenn der Parameter nil ist.

Hinweis: Diese Methode ist veraltet, bitte verwenden Sie stattdessen TracePoint.

proc nimmt bis zu sechs Parameter entgegen

• ein Ereignisname als Zeichenkette

• ein Dateiname als Zeichenkette

• eine Zeilennummer

• ein Methodensymbol oder nil

• eine Bindung oder nil

• die Klasse, das Modul oder nil

proc wird aufgerufen, wann immer ein Ereignis eintritt.

Ereignisse sind

"c-call"

Aufruf einer C-Routine

"c-return"

Rückkehr aus einer C-Routine

"call"

Aufruf einer Ruby-Methode

"class"

Start einer Klassen- oder Moduldefinition

"end"

Beendigung einer Klassen- oder Moduldefinition

"line"

Ausführung von Code in einer neuen Zeile

"raise"

Auslösen einer Ausnahme

"return"

Rückkehr aus einer Ruby-Methode

Das Tracing ist im Kontext von proc deaktiviert.

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

Erzeugt

c-return prog.rb:8   :set_trace_func         Kernel
    line prog.rb:11              nil            nil
  c-call prog.rb:11             :new          Class
  c-call prog.rb:11      :initialize    BasicObject
c-return prog.rb:11      :initialize    BasicObject
c-return prog.rb:11             :new          Class
    line prog.rb:12              nil            nil
    call prog.rb:2             :test           Test
    line prog.rb:3             :test           Test
    line prog.rb:4             :test           Test
  return prog.rb:5             :test           Test

static VALUE
rb_f_sleep(int argc, VALUE *argv, VALUE _)
{
    time_t beg = time(0);
    VALUE scheduler = rb_fiber_scheduler_current();

    if (scheduler != Qnil) {
        rb_fiber_scheduler_kernel_sleepv(scheduler, argc, argv);
    }
    else {
        if (argc == 0 || (argc == 1 && NIL_P(argv[0]))) {
            rb_thread_sleep_forever();
        }
        else {
            rb_check_arity(argc, 0, 1);
            rb_thread_wait_for(rb_time_interval(argv[0]));
        }
    }

    time_t end = time(0) - beg;

    return TIMET2NUM(end);
}

Setzt die Ausführung des aktuellen Threads für die durch das numerische Argument secs angegebene Anzahl von Sekunden aus, oder für immer, wenn secs nil ist; gibt die Anzahl der ausgesetzten Sekunden zurück (gerundet).

Time.new  # => 2008-03-08 19:56:19 +0900
sleep 1.2 # => 1
Time.new  # => 2008-03-08 19:56:20 +0900
sleep 1.9 # => 2
Time.new  # => 2008-03-08 19:56:22 +0900

static VALUE
rb_f_spawn(int argc, VALUE *argv, VALUE _)
{
    rb_pid_t pid;
    char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
    VALUE execarg_obj, fail_str;
    struct rb_execarg *eargp;

    execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
    eargp = rb_execarg_get(execarg_obj);
    fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;

    pid = rb_execarg_spawn(execarg_obj, errmsg, sizeof(errmsg));

    if (pid == -1) {
        int err = errno;
        rb_exec_fail(eargp, err, errmsg);
        RB_GC_GUARD(execarg_obj);
        rb_syserr_fail_str(err, fail_str);
    }
#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
    return PIDT2NUM(pid);
#else
    return Qnil;
#endif
}

Erzeugt einen neuen Kindprozess, indem im Prozess eines der folgenden Dinge getan werden:

• Übergabe einer Zeichenkette command_line an die Shell.

• Aufruf der ausführbaren Datei unter exe_path.

Diese Methode hat potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird. Siehe Command Injection.

Gibt die Prozess-ID (PID) des neuen Prozesses zurück, ohne auf dessen Abschluss zu warten.

Um Zombie-Prozesse zu vermeiden, sollte der Elternprozess entweder aufrufen:

• Process.wait, um die Beendigungsstatus seiner Kinder zu erfassen.

• Process.detach, um Desinteresse an ihrem Status zu registrieren.

Der neue Prozess wird unter Verwendung des exec-Systemaufrufs erstellt; er kann seine Umgebung vom aufrufenden Programm erben (möglicherweise einschließlich offener Dateideskriptoren).

Das Argument env, falls gegeben, ist ein Hash, der ENV für den neuen Prozess beeinflusst; siehe Execution Environment.

Das Argument options ist ein Hash von Optionen für den neuen Prozess; siehe Execution Options.

Das erste erforderliche Argument ist eines der folgenden:

• command_line, wenn es eine Zeichenkette ist und mit einem reservierten Shell-Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

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

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

spawn('echo "Foo"') # => 799031
Process.wait        # => 799031

Ausgabe

Foo

Siehe Execution Shell für Details zur Shell.

Löst eine Ausnahme aus, wenn der neue Prozess nicht ausgeführt werden konnte.

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein 2-elementiges Array, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausführenden Prozesses verwendet werden soll.

  spawn('/usr/bin/date') # Path to date on Unix-style system.
  Process.wait
  

  Ausgabe

  Mon Aug 28 11:43:10 AM CDT 2023

Ruby ruft die ausführbare Datei direkt auf. Diese Form verwendet nicht die Shell; siehe Arguments args für Vorbehalte.

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

spawn('echo', 'C*')             # => 799392
Process.wait                    # => 799392
spawn('echo', 'hello', 'world') # => 799393
Process.wait                    # => 799393

Ausgabe

C*
hello world

Löst eine Ausnahme aus, wenn der neue Prozess nicht ausgeführt werden konnte.

static VALUE
f_sprintf(int c, const VALUE *v, VALUE _)
{
    return rb_f_sprintf(c, v);
}

Gibt die Zeichenkette zurück, die sich aus der Formatierung von objects in format_string ergibt.

Details zu format_string finden Sie unter Formatangaben.

static VALUE
rb_f_srand(int argc, VALUE *argv, VALUE obj)
{
    VALUE seed, old;
    rb_random_mt_t *r = default_mt();

    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;
}

Initialisiert den systemweiten Pseudo-Zufallszahlengenerator mit number. Der vorherige Seed-Wert wird zurückgegeben.

Wenn number weggelassen wird, wird der Generator mit einer vom Betriebssystem bereitgestellten Entropiequelle initialisiert (auf Unix-Systemen /dev/urandom oder unter Windows der RSA-Kryptografie-Provider), die dann mit der Zeit, der Prozess-ID und einer Sequenznummer kombiniert wird.

srand kann verwendet werden, um reproduzierbare Sequenzen von Pseudo-Zufallszahlen zwischen verschiedenen Programmläufen sicherzustellen. Durch das Setzen des Seeds auf einen bekannten Wert können Programme während des Testens deterministisch gemacht werden.

srand 1234               # => 268519324636777531569100071560086917274
[ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
[ rand(10), rand(1000) ] # => [4, 664]
srand 1234               # => 1234
[ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]

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

Entspricht $_.sub(args), mit der Ausnahme, dass $_ bei einer Ersetzung aktualisiert wird. Nur verfügbar, wenn die Kommandozeilenoption -p/-n angegeben ist.

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
}

Ruft den Posix-Systemaufruf syscall(2) auf, der eine angegebene Funktion aufruft.

Ruft die vom integer_callno identifizierte Betriebssystemfunktion auf; gibt das Ergebnis der Funktion zurück oder löst SystemCallError aus, wenn er fehlschlug. Die Auswirkung des Aufrufs ist plattformabhängig. Die Argumente und der Rückgabewert sind plattformabhängig.

Für jedes der arguments: Wenn es eine Ganzzahl ist, wird es direkt übergeben; wenn es eine Zeichenkette ist, wird es als Binärsequenz von Bytes interpretiert. Es können bis zu neun solcher Argumente vorhanden sein.

Die Argumente integer_callno und argument sowie der Rückgabewert sind plattformabhängig.

Hinweis: Die Methode syscall ist im Wesentlichen unsicher und nicht portabel. Die DL (Fiddle)-Bibliothek wird für sicherere und etwas portablere Programmierung bevorzugt.

Nicht auf allen Plattformen implementiert.

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;
    }
}

Erzeugt einen neuen Kindprozess, indem im Prozess eines der folgenden Dinge getan werden:

• Übergabe einer Zeichenkette command_line an die Shell.

• Aufruf der ausführbaren Datei unter exe_path.

Diese Methode hat potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird. Siehe Command Injection.

Gibt zurück

• true, wenn der Befehl mit dem Status null beendet wird.

• false, wenn der Exit-Status eine Ganzzahl ungleich null ist.

• nil, wenn der Befehl nicht ausgeführt werden konnte.

Löst eine Ausnahme aus (anstatt false oder nil zurückzugeben), wenn das Schlüsselwortargument exception auf true gesetzt ist.

Weist den Fehlerstatus des Befehls $? zu.

Der neue Prozess wird mit dem system-Systemaufruf erstellt; er kann einige seiner Umgebung vom aufrufenden Programm erben (möglicherweise einschließlich offener Dateideskriptoren).

Das Argument env, falls gegeben, ist ein Hash, der ENV für den neuen Prozess beeinflusst; siehe Execution Environment.

Das Argument options ist ein Hash von Optionen für den neuen Prozess; siehe Execution Options.

Das erste erforderliche Argument ist eines der folgenden:

• command_line, wenn es eine Zeichenkette ist und mit einem reservierten Shell-Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

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.

Weist den Fehlerstatus des Befehls $? zu.

system('exit')                             # => true  # Built-in.
$?                                         # => #<Process::Status: pid 640610 exit 0>
system('date > /nop/date.tmp')             # => false
$?                                         # => #<Process::Status: pid 640742 exit 2>

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

system('echo "Foo"') # => true

Ausgabe

Foo

Siehe Execution Shell für Details zur Shell.

Löst eine Ausnahme aus, wenn der neue Prozess nicht ausgeführt werden konnte.

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

system('/usr/bin/date') # => true # Path to date on Unix-style system.
system('foo')           # => nil  # Command failed.

Ausgabe

Mon Aug 28 11:43:10 AM CDT 2023

Weist den Fehlerstatus des Befehls $? zu.

system('/usr/bin/date') # => true
$?                      # => #<Process::Status: pid 645605 exit 0>
system('foo')           # => nil
$?                      # => #<Process::Status: pid 645608 exit 127>

Ruby ruft die ausführbare Datei direkt auf. Diese Form verwendet nicht die Shell; siehe Arguments args für Vorbehalte.

system('doesnt_exist') # => nil

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

system('echo', 'C*')             # => true
system('echo', 'hello', 'world') # => true

Ausgabe

C*
hello world

Löst eine Ausnahme aus, wenn der neue Prozess nicht ausgeführt werden konnte.

# File kernel.rb, line 89
def tap
  Primitive.attr! :inline_block
  yield(self)
  self
end

Gibt self an den Block weiter und gibt dann self zurück. Der Hauptzweck dieser Methode ist es, in eine Methodenverkettung zu "tippen", um Operationen an Zwischenergebnissen innerhalb der Kette durchzuführen.

(1..10)                  .tap {|x| puts "original: #{x}" }
  .to_a                  .tap {|x| puts "array:    #{x}" }
  .select {|x| x.even? } .tap {|x| puts "evens:    #{x}" }
  .map {|x| x*x }        .tap {|x| puts "squares:  #{x}" }

static VALUE
rb_f_test(int argc, VALUE *argv, VALUE _)
{
    int cmd;

    if (argc == 0) rb_check_arity(argc, 2, 3);
    cmd = NUM2CHR(argv[0]);
    if (cmd == 0) {
        goto unknown;
    }
    if (strchr("bcdefgGkloOprRsSuwWxXz", cmd)) {
        CHECK(1);
        switch (cmd) {
          case 'b':
            return rb_file_blockdev_p(0, argv[1]);

          case 'c':
            return rb_file_chardev_p(0, argv[1]);

          case 'd':
            return rb_file_directory_p(0, argv[1]);

          case 'e':
            return rb_file_exist_p(0, argv[1]);

          case 'f':
            return rb_file_file_p(0, argv[1]);

          case 'g':
            return rb_file_sgid_p(0, argv[1]);

          case 'G':
            return rb_file_grpowned_p(0, argv[1]);

          case 'k':
            return rb_file_sticky_p(0, argv[1]);

          case 'l':
            return rb_file_symlink_p(0, argv[1]);

          case 'o':
            return rb_file_owned_p(0, argv[1]);

          case 'O':
            return rb_file_rowned_p(0, argv[1]);

          case 'p':
            return rb_file_pipe_p(0, argv[1]);

          case 'r':
            return rb_file_readable_p(0, argv[1]);

          case 'R':
            return rb_file_readable_real_p(0, argv[1]);

          case 's':
            return rb_file_size_p(0, argv[1]);

          case 'S':
            return rb_file_socket_p(0, argv[1]);

          case 'u':
            return rb_file_suid_p(0, argv[1]);

          case 'w':
            return rb_file_writable_p(0, argv[1]);

          case 'W':
            return rb_file_writable_real_p(0, argv[1]);

          case 'x':
            return rb_file_executable_p(0, argv[1]);

          case 'X':
            return rb_file_executable_real_p(0, argv[1]);

          case 'z':
            return rb_file_zero_p(0, argv[1]);
        }
    }

    if (strchr("MAC", cmd)) {
        struct stat st;
        VALUE fname = argv[1];

        CHECK(1);
        if (rb_stat(fname, &st) == -1) {
            int e = errno;
            FilePathValue(fname);
            rb_syserr_fail_path(e, fname);
        }

        switch (cmd) {
          case 'A':
            return stat_atime(&st);
          case 'M':
            return stat_mtime(&st);
          case 'C':
            return stat_ctime(&st);
        }
    }

    if (cmd == '-') {
        CHECK(2);
        return rb_file_identical_p(0, argv[1], argv[2]);
    }

    if (strchr("=<>", cmd)) {
        struct stat st1, st2;
        stat_timestamp 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);
}

Führt einen Test an einer oder beiden der Dateisystementitäten an den angegebenen Pfaden path0 und path1 durch.

• Jeder Pfad path0 oder path1 verweist auf eine Datei, ein Verzeichnis, ein Gerät, eine Pipe usw.

• Das Zeichen char wählt einen spezifischen Test aus.

Die Tests

• Jeder dieser Tests operiert nur auf der Entität unter path0 und gibt true oder false zurück; für eine nicht existierende Entität gibt er false zurück (löst keine Ausnahme aus).

  Zeichen	Test
  'b'	Ob die Entität ein Blockgerät ist.
  'c'	Ob die Entität ein Zeichengerät ist.
  'd'	Ob die Entität ein Verzeichnis ist.
  'e'	Ob die Entität existiert.
  'f'	Ob die Entität eine existierende reguläre Datei ist.
  'g'	Ob das Setgid-Bit der Entität gesetzt ist.
  'G'	Ob die Gruppenzugehörigkeit der Entität mit der des Aufrufers übereinstimmt.
  'k'	Ob das Sticky-Bit der Entität gesetzt ist.
  'l'	Ob die Entität ein symbolischer Link ist.
  'o'	Ob die Entität dem effektiven UID des Aufrufers gehört.
  'O'	Ähnlich wie 'o', verwendet aber die reale UID (nicht die effektive UID).
  'p'	Ob die Entität eine FIFO-Einheit (benannte Pipe) ist.
  'r'	Ob die Entität für die effektive UID/GID des Aufrufers lesbar ist.
  'R'	Ähnlich wie 'r', verwendet aber die reale UID/GID (nicht die effektive UID/GID).
  'S'	Ob die Entität ein Socket ist.
  'u'	Ob das Setuid-Bit der Entität gesetzt ist.
  'w'	Ob die Entität für die effektive UID/GID des Aufrufers schreibbar ist.
  'W'	Ähnlich wie 'w', verwendet aber die reale UID/GID (nicht die effektive UID/GID).
  'x'	Ob die Entität für die effektive UID/GID des Aufrufers ausführbar ist.
  'X'	Ähnlich wie 'x', verwendet aber die reale UID/GID (nicht die effektive UID/GIT).
  'z'	Ob die Entität existiert und die Länge Null hat.

• Dieser Test operiert nur auf der Entität unter path0 und gibt eine Integer-Größe oder nil zurück.

  Zeichen	Test
  's'	Gibt eine positive Integer-Größe zurück, wenn die Entität existiert und eine nicht-null Länge hat, andernfalls nil.

• Jeder dieser Tests operiert nur auf der Entität unter path0 und gibt ein Time-Objekt zurück; löst eine Ausnahme aus, wenn die Entität nicht existiert.

  Zeichen	Test
  'A'	Letzte Zugriffszeit für die Entität.
  'C'	Letzte Änderungszeit für die Entität.
  'M'	Letzte Modifikationszeit für die Entität.

• Jeder dieser Tests operiert auf der Modifikationszeit (mtime) jeder der Entitäten unter path0 und path1 und gibt true oder false zurück; gibt false zurück, wenn eine der Entitäten nicht existiert.

  Zeichen	Test
  '<'	Ob die mtime unter path0 kleiner ist als die unter path1.
  '='	Ob die mtime unter path0 gleich der unter path1 ist.
  '>'	Ob die mtime unter path0 größer ist als die unter path1.

• Dieser Test operiert auf dem Inhalt jeder der Entitäten unter path0 und path1 und gibt true oder false zurück; gibt false zurück, wenn eine der Entitäten nicht existiert.

  Zeichen	Test
  '-'	Ob die Entitäten existieren und identisch sind.

# 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

Gibt self an den Block weiter und gibt das Ergebnis des Blocks zurück.

3.next.then {|x| x**x }.to_s             #=> "256"

Eine gute Verwendung von then ist das Weiterleiten von Werten in Methodenverkettungen.

require 'open-uri'
require 'json'

construct_url(arguments)
  .then {|url| URI(url).read }
  .then {|response| JSON.parse(response) }

Wenn die Methode ohne Block aufgerufen wird, gibt sie einen Enumerator zurück, der beispielsweise für bedingtes Schaltungsbrechen verwendet werden kann.

# Meets condition, no-op
1.then.detect(&:odd?)            # => 1
# Does not meet condition, drop value
2.then.detect(&:odd?)            # => nil

static VALUE
rb_f_throw(int argc, VALUE *argv, VALUE _)
{
    VALUE tag, value;

    rb_scan_args(argc, argv, "11", &tag, &value);
    rb_throw_obj(tag, value);
    UNREACHABLE_RETURN(Qnil);
}

Überträgt die Kontrolle an das Ende des aktiven catch-Blocks, der auf tag wartet. Löst UncaughtThrowError aus, wenn kein catch-Block für den tag vorhanden ist. Der optionale zweite Parameter liefert einen Rückgabewert für den catch-Block, der ansonsten nil ist. Beispiele siehe Kernel::catch.

static VALUE
f_trace_var(int c, const VALUE *a, VALUE _)
{
    return rb_f_trace_var(c, a);
}

Steuert das Tracing von Zuweisungen zu globalen Variablen. Der Parameter symbol identifiziert die Variable (entweder als Zeichenkettennamen oder als Symbolbezeichner). cmd (das eine Zeichenkette oder ein Proc-Objekt sein kann) oder der Block wird ausgeführt, wenn die Variable zugewiesen wird. Der Block oder das Proc-Objekt erhält den neuen Wert der Variablen als Parameter. Siehe auch untrace_var.

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

ergibt

$_ is now 'hello'
$_ is now ' there'

static VALUE
sig_trap(int argc, VALUE *argv, VALUE _)
{
    int sig;
    sighandler_t func;
    VALUE cmd;

    rb_check_arity(argc, 1, 2);

    sig = trap_signm(argv[0]);
    if (reserved_signal_p(sig)) {
        const char *name = signo2signm(sig);
        if (name)
            rb_raise(rb_eArgError, "can't trap reserved signal: SIG%s", name);
        else
            rb_raise(rb_eArgError, "can't trap reserved signal: %d", sig);
    }

    if (argc == 1) {
        cmd = rb_block_proc();
        func = sighandler;
    }
    else {
        cmd = argv[1];
        func = trap_handler(&cmd, sig);
    }

    if (rb_obj_is_proc(cmd) &&
        !rb_ractor_main_p() && !rb_ractor_shareable_p(cmd)) {
        cmd = rb_proc_isolate(cmd);
    }

    return trap(sig, func, cmd);
}

Legt die Behandlung von Signalen fest. Gibt den vorherigen Handler für das gegebene Signal zurück.

Das Argument signal ist ein Signalname (eine Zeichenkette oder ein Symbol wie SIGALRM oder SIGUSR1) oder eine Signalnummer als Ganzzahl. Wenn signal eine Zeichenkette oder ein Symbol ist, können die führenden Zeichen SIG weggelassen werden.

Das Argument command oder der bereitgestellte Block gibt den Code an, der ausgeführt werden soll, wenn das Signal ausgelöst wird.

Das Argument command kann auch eine Zeichenkette oder ein Symbol mit den folgenden Sonderwerten sein:

• IGNORE, SIG_IGN: Das Signal wird ignoriert.

• DEFAULT, SIG_DFL: Der Standardhandler von Ruby wird aufgerufen.

• EXIT: Der Prozess wird durch das Signal beendet.

• SYSTEM_DEFAULT: Der Standardhandler des Betriebssystems wird aufgerufen.

Der spezielle Signalname EXIT oder die Signalnummer Null wird unmittelbar vor der Programmbeendigung aufgerufen.

Signal.trap(0, proc { puts "Terminating: #{$$}" })
Signal.trap("CLD")  { puts "Child died" }
fork && Process.wait

Ausgaben

Terminating: 27461
Child died
Terminating: 27460

static VALUE
f_untrace_var(int c, const VALUE *a, VALUE _)
{
    return rb_f_untrace_var(c, a);
}

Entfernt das Tracing für den angegebenen Befehl für die gegebene globale Variable und gibt nil zurück. Wenn kein Befehl angegeben wird, werden alle Tracing für diese Variable entfernt und ein Array mit den tatsächlich entfernten Befehlen zurückgegeben.

# 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

Wenn Warnungen deaktiviert wurden (z. B. mit dem Flag -W0), tut diese Methode nichts. Andernfalls konvertiert sie jede der Nachrichten in Zeichenketten, hängt ein Zeilenumbruchzeichen an die Zeichenkette an, wenn die Zeichenkette nicht mit einem Zeilenumbruch endet, und ruft Warning.warn mit der Zeichenkette auf.

warn("warning 1", "warning 2")

ergibt

warning 1
warning 2

Wenn das Schlüsselwortargument uplevel angegeben ist, wird die Zeichenkette mit Informationen für den gegebenen Aufruferrahmen im gleichen Format wie die C-Funktion rb_warn vorangestellt.

# In baz.rb
def foo
  warn("invalid call to foo", uplevel: 1)
end

def bar
  foo
end

bar

ergibt

baz.rb:6: warning: invalid call to foo

Wenn das Schlüsselwortargument category angegeben ist, wird die Kategorie an Warning.warn übergeben. Die angegebene Kategorie muss eine der folgenden sein:

:deprecated

Wird für Warnungen über veraltete Funktionen verwendet, die möglicherweise in Zukunft entfernt werden.

:experimental

Wird für experimentelle Funktionen verwendet, die sich in zukünftigen Versionen ändern können.

:performance

Wird für Warnungen über APIs oder Muster verwendet, die negative Auswirkungen auf die Leistung haben.

# File ext/json/lib/json/common.rb, line 1139
def JSON(object, opts = nil)
  JSON[object, opts]
end

Wenn object zeichenkettenähnlich ist, wird die Zeichenkette analysiert und das analysierte Ergebnis als Ruby-Datenstruktur zurückgegeben. Andernfalls wird ein JSON-Text aus der Ruby-Datenstruktur object generiert und zurückgegeben.

Das Argument opts wird an generate/parse weitergegeben. Siehe generate und parse für deren Dokumentation.

# File pathname_builtin.rb, line 1167
def Pathname(path) # :doc:
  return path if Pathname === path
  Pathname.new(path)
end

Erstellt ein Pathname-Objekt.

# File lib/uri/common.rb, line 911
def URI(uri)
  if uri.is_a?(URI::Generic)
    uri
  elsif uri = String.try_convert(uri)
    URI.parse(uri)
  else
    raise ArgumentError,
      "bad argument (expected URI object or URI string)"
  end
end

Gibt ein URI-Objekt zurück, das von der gegebenen uri abgeleitet ist, die eine URI-Zeichenkette oder ein vorhandenes URI-Objekt sein kann

require 'uri'
# Returns a new URI.
uri = URI('http://github.com/ruby/ruby')
# => #<URI::HTTP http://github.com/ruby/ruby>
# Returns the given URI.
URI(uri)
# => #<URI::HTTP http://github.com/ruby/ruby>

Sie müssen 'uri' erfordern, um diese Methode zu verwenden.

# File lib/rubygems/core_ext/kernel_gem.rb, line 35
def gem(gem_name, *requirements) # :doc:
  skip_list = (ENV["GEM_SKIP"] || "").split(/:/)
  raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name

  if gem_name.is_a? Gem::Dependency
    unless Gem::Deprecate.skip
      warn "#{Gem.location_of_caller.join ":"}:Warning: Kernel.gem no longer "\
        "accepts a Gem::Dependency object, please pass the name "\
        "and requirements directly"
    end

    requirements = gem_name.requirement
    gem_name = gem_name.name
  end

  dep = Gem::Dependency.new(gem_name, *requirements)

  loaded = Gem.loaded_specs[gem_name]

  return false if loaded && dep.matches_spec?(loaded)

  spec = dep.to_spec

  if spec
    if Gem::LOADED_SPECS_MUTEX.owned?
      spec.activate
    else
      Gem::LOADED_SPECS_MUTEX.synchronize { spec.activate }
    end
  end
end

Verwenden Sie Kernel#gem, um eine bestimmte Version von gem_name zu aktivieren.

requirements ist eine Liste von Versionsanforderungen, die dem angegebenen Gem entsprechen müssen, am häufigsten "= example.version.number". Siehe Gem::Requirement, wie eine Versionsanforderung angegeben wird.

Wenn Sie die neueste Version eines Gems aktivieren möchten, müssen Sie Kernel#gem nicht aufrufen, Kernel#require erledigt das Richtige für Sie.

Kernel#gem gibt true zurück, wenn das Gem aktiviert wurde, andernfalls false. Wenn das Gem nicht gefunden werden konnte, die Versionsanforderungen nicht erfüllte oder eine andere Version bereits aktiviert war, wird eine Ausnahme ausgelöst.

Kernel#gem sollte *vor* allen require-Anweisungen aufgerufen werden (andernfalls lädt RubyGems möglicherweise eine widersprüchliche Bibliotheksversion).

Kernel#gem lädt nur Vorabversionen, wenn Vorab-requirements angegeben sind.

gem 'rake', '>= 1.1.a', '< 2'

In älteren RubyGems-Versionen konnte die Umgebungsvariable GEM_SKIP verwendet werden, um die Aktivierung bestimmter Gems zu überspringen, z. B. um Änderungen zu testen, die noch nicht installiert wurden. Jetzt verlässt sich RubyGems auf -I und die Umgebungsvariable RUBYLIB, um die Aktivierung eines Gems zu überspringen.

Beispiel

GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb

# File ext/json/lib/json/common.rb, line 1105
def j(*objs)
  if RUBY_VERSION >= "3.0"
    warn "Kernel#j is deprecated and will be removed in json 3.0.0", uplevel: 1, category: :deprecated
  else
    warn "Kernel#j is deprecated and will be removed in json 3.0.0", uplevel: 1
  end

  objs.each do |obj|
    puts JSON.generate(obj, :allow_nan => true, :max_nesting => false)
  end
  nil
end

Gibt objs als JSON-Strings in der kürzesten Form, d. h. einzeilig, nach STDOUT aus.

# File ext/json/lib/json/common.rb, line 1120
def jj(*objs)
  if RUBY_VERSION >= "3.0"
    warn "Kernel#jj is deprecated and will be removed in json 3.0.0", uplevel: 1, category: :deprecated
  else
    warn "Kernel#jj is deprecated and will be removed in json 3.0.0", uplevel: 1
  end

  objs.each do |obj|
    puts JSON.pretty_generate(obj, :allow_nan => true, :max_nesting => false)
  end
  nil
end

Gibt objs als JSON-Strings in einem hübschen Format mit Einrückungen und über mehrere Zeilen nach STDOUT aus.

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

Gibt Argumente in schöner Form aus.

pp gibt Argument(e) zurück.

# File lib/rubygems/core_ext/kernel_require.rb, line 36
def require(path) # :doc:
  return gem_original_require(path) unless Gem.discover_gems_on_require

  RUBYGEMS_ACTIVATION_MONITOR.synchronize do
    path = File.path(path)

    # If +path+ belongs to a default gem, we activate it and then go straight
    # to normal require

    if spec = Gem.find_default_spec(path)
      name = spec.name

      next if Gem.loaded_specs[name]

      # Ensure -I beats a default gem
      resolved_path = begin
        rp = nil
        load_path_check_index = Gem.load_path_insert_index - Gem.activated_gem_paths
        Gem.suffixes.find do |s|
          $LOAD_PATH[0...load_path_check_index].find do |lp|
            if File.symlink? lp # for backward compatibility
              next
            end

            full_path = File.expand_path(File.join(lp, "#{path}#{s}"))
            rp = full_path if File.file?(full_path)
          end
        end
        rp
      end

      next if resolved_path

      Kernel.send(:gem, name, Gem::Requirement.default_prerelease)

      Gem.load_bundler_extensions(Gem.loaded_specs[name].version) if name == "bundler"

      next
    end

    # If there are no unresolved deps, then we can use just try
    # normal require handle loading a gem from the rescue below.

    if Gem::Specification.unresolved_deps.empty?
      next
    end

    # If +path+ is for a gem that has already been loaded, don't
    # bother trying to find it in an unresolved gem, just go straight
    # to normal require.
    #--
    # TODO request access to the C implementation of this to speed up RubyGems

    if Gem::Specification.find_active_stub_by_path(path)
      next
    end

    # Attempt to find +path+ in any unresolved gems...

    found_specs = Gem::Specification.find_in_unresolved path

    # If there are no directly unresolved gems, then try and find +path+
    # in any gems that are available via the currently unresolved gems.
    # For example, given:
    #
    #   a => b => c => d
    #
    # If a and b are currently active with c being unresolved and d.rb is
    # requested, then find_in_unresolved_tree will find d.rb in d because
    # it's a dependency of c.
    #
    if found_specs.empty?
      found_specs = Gem::Specification.find_in_unresolved_tree path

      found_specs.each(&:activate)

    # We found +path+ directly in an unresolved gem. Now we figure out, of
    # the possible found specs, which one we should activate.
    else

      # Check that all the found specs are just different
      # versions of the same gem
      names = found_specs.map(&:name).uniq

      if names.size > 1
        raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ", "}"
      end

      # Ok, now find a gem that has no conflicts, starting
      # at the highest version.
      valid = found_specs.find {|s| !s.has_conflicts? }

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

      valid.activate
    end
  end

  begin
    gem_original_require(path)
  rescue LoadError => load_error
    if load_error.path == path &&
       RUBYGEMS_ACTIVATION_MONITOR.synchronize { Gem.try_activate(path) }

      return gem_original_require(path)
    end

    raise load_error
  end
end

Wenn RubyGems angefordert wird, wird Kernel#require durch unsere eigene ersetzt, die Gems bei Bedarf laden kann.

Wenn Sie require 'x' aufrufen, geschieht Folgendes:

• Wenn die Datei aus dem vorhandenen Ruby-LadePfad geladen werden kann, wird sie geladen.

• Andernfalls wird nach installierten Gems nach einer passenden Datei gesucht. Wenn sie in Gem 'y' gefunden wird, wird dieses Gem aktiviert (zum LadePfad hinzugefügt).

Die normale require-Funktionalität, die false zurückgibt, wenn die Datei bereits geladen wurde, bleibt erhalten.

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

Ein Alias für Psych.dump_stream, der für die Verwendung mit IRB gedacht ist.