class ENV

ENV ist ein Hash-ähnlicher Zugriff auf Umgebungsvariablen.

Interaktion mit dem Betriebssystem

Das Objekt ENV interagiert mit den Umgebungsvariablen des Betriebssystems

Wenn Sie den Wert für einen Namen in ENV abrufen, wird der Wert aus den aktuellen Umgebungsvariablen abgerufen.
Wenn Sie ein Namens-Wert-Paar in ENV erstellen oder festlegen, werden der Name und der Wert sofort in den Umgebungsvariablen festgelegt.
Wenn Sie ein Namens-Wert-Paar in ENV löschen, wird es sofort aus den Umgebungsvariablen gelöscht.

Namen und Werte

Im Allgemeinen ist ein Name oder ein Wert ein String.

Gültige Namen und Werte

Jeder Name oder Wert muss einer der folgenden sein:

Ein String.
Ein Objekt, das auf #to_str reagiert, indem es einen String zurückgibt, in diesem Fall wird dieser String als Name oder Wert verwendet.

Ungültige Namen und Werte

Ein neuer Name

Darf nicht der leere String sein

ENV[''] = '0'
# Raises Errno::EINVAL (Invalid argument - ruby_setenv())

Darf das Zeichen "=" nicht enthalten

ENV['='] = '0'
# Raises Errno::EINVAL (Invalid argument - ruby_setenv(=))

Ein neuer Name oder Wert

Darf kein Nicht-String sein, der nicht auf #to_str reagiert

ENV['foo'] = Object.new
# Raises TypeError (no implicit conversion of Object into String)
ENV[Object.new] = '0'
# Raises TypeError (no implicit conversion of Object into String)

Darf das NUL-Zeichen "\0" nicht enthalten

ENV['foo'] = "\0"
# Raises ArgumentError (bad environment variable value: contains null byte)
ENV["\0"] == '0'
# Raises ArgumentError (bad environment variable name: contains null byte)

Darf keine ASCII-inkompatible Kodierung wie UTF-16LE oder ISO-2022-JP haben

ENV['foo'] = '0'.force_encoding(Encoding::ISO_2022_JP)
# Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: ISO-2022-JP)
ENV["foo".force_encoding(Encoding::ISO_2022_JP)] = '0'
# Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: ISO-2022-JP)

ENV zählt seine Namen/Werte-Paare in der Reihenfolge auf, in der sie in den Umgebungsvariablen des Betriebssystems gefunden werden. Daher ist die Reihenfolge des Inhalts von ENV vom Betriebssystem abhängig und kann unbestimmt sein.

Dies wird in Folgendem sichtbar sein:

Ein Hash, der von einer Methode von ENV zurückgegeben wird.
Ein Enumerator, der von einer Methode von ENV zurückgegeben wird.
Ein Array, das von ENV.keys, ENV.values oder ENV.to_a zurückgegeben wird.
Der String, der von ENV.inspect zurückgegeben wird.
Das Array, das von ENV.shift zurückgegeben wird.
Der Name, der von ENV.key zurückgegeben wird.

Über die Beispiele

Einige Methoden in ENV geben ENV selbst zurück. Typischerweise gibt es viele Umgebungsvariablen. Es ist nicht nützlich, ein großes ENV hier in den Beispielen anzuzeigen, daher beginnt die meisten Beispiel-Snippets mit dem Zurücksetzen des Inhalts von ENV.

ENV.replace ersetzt ENV durch eine neue Sammlung von Einträgen.
ENV.clear leert ENV.

Was gibt es hier

Zuerst, was sonst noch. Klasse ENV

Erbt von Klasse Object.
Erweitert Modul Enumerable,

Hier bietet die Klasse ENV Methoden, die nützlich sind für

Methoden zum Abfragen

::[]: Gibt den Wert für den angegebenen Umgebungs variável Namen zurück, falls er existiert.
::empty?: Gibt zurück, ob ENV leer ist.
::has_value?, ::value?: Gibt zurück, ob der gegebene Wert in ENV vorhanden ist.
::include?, ::has_key?, ::key?, ::member?: Gibt zurück, ob der gegebene Name in ENV vorhanden ist.
::key: Gibt den Namen des ersten Eintrags mit dem gegebenen Wert zurück.
::size, ::length: Gibt die Anzahl der Einträge zurück.
::value?: Gibt zurück, ob ein Eintrag den gegebenen Wert hat.

Methoden zum Zuweisen

::[]=, ::store: Erstellt, aktualisiert oder löscht die benannte Umgebungsvariable.
::clear: Entfernt jede Umgebungsvariable; gibt ENV zurück.
::update, ::merge!: Fügt ENV jedes Schlüssel/Wert-Paar aus dem gegebenen Hash hinzu.
::replace: Ersetzt den gesamten Inhalt von ENV durch die Namen/Werte-Paare im gegebenen Hash.

Methoden zum Löschen

::delete: Löscht den Namen der Umgebungsvariablen, falls er existiert.
::delete_if: Löscht Einträge, die vom Block ausgewählt wurden.
::keep_if: Löscht Einträge, die nicht vom Block ausgewählt wurden.
::reject!: Ähnlich wie delete_if, gibt aber nil zurück, wenn keine Änderung vorgenommen wurde.
::select!, ::filter!: Löscht Einträge, die vom Block ausgewählt wurden.
::shift: Entfernt und gibt den ersten Eintrag zurück.

Methoden zur Iteration

::each, ::each_pair: Ruft den Block mit jedem Namen/Werte-Paar auf.
::each_key: Ruft den Block mit jedem Namen auf.
::each_value: Ruft den Block mit jedem Wert auf.

Methoden zur Konvertierung

::assoc: Gibt ein 2-Elemente-Array zurück, das den Namen und Wert der benannten Umgebungsvariable enthält, falls diese existiert.
::clone: Löst eine Ausnahme aus.
::except: Gibt einen Hash aller Namen/Werte-Paare zurück, außer den angegebenen.
::fetch: Gibt den Wert für den angegebenen Namen zurück.
::inspect: Gibt den Inhalt von ENV als String zurück.
::invert: Gibt einen Hash zurück, dessen Schlüssel die ENV-Werte und dessen Werte die entsprechenden ENV-Namen sind.
::keys: Gibt ein Array aller Namen zurück.
::rassoc: Gibt den Namen und Wert des ersten gefundenen Eintrags zurück, der den gegebenen Wert hat.
::reject: Gibt einen Hash der Einträge zurück, die vom Block nicht abgelehnt wurden.
::select, ::filter: Gibt einen Hash von Namen/Werte-Paaren zurück, die vom Block ausgewählt wurden.
::slice: Gibt einen Hash der angegebenen Namen und ihrer entsprechenden Werte zurück.
::to_a: Gibt die Einträge als Array von 2-Elemente-Arrays zurück.
::to_h: Gibt einen Hash der Einträge zurück, die vom Block ausgewählt wurden.
::to_hash: Gibt einen Hash aller Einträge zurück.
::to_s: Gibt den String 'ENV' zurück.
::values: Gibt alle Werte als Array zurück.
::values_at: Gibt ein Array der Werte für die angegebenen Namen zurück.

Weitere Methoden

::dup: Löst eine Ausnahme aus.
::freeze: Löst eine Ausnahme aus.
::rehash: Gibt nil zurück, ohne ENV zu ändern.

Öffentliche Klassenmethoden

ENV[name] → value

Source

static VALUE
rb_f_getenv(VALUE obj, VALUE name)
{
    const char *nam = env_name(name);
    VALUE env = getenv_with_lock(nam);
    return env;
}

Gibt den Wert für die Umgebungsvariable name zurück, falls diese existiert.

ENV['foo'] = '0'
ENV['foo'] # => "0"

Gibt nil zurück, wenn die benannte Variable nicht existiert.

Löst eine Ausnahme aus, wenn name ungültig ist. Siehe Ungültige Namen und Werte.

ENV[name] = value → value

store(name, value) → value

Source

static VALUE
env_aset_m(VALUE obj, VALUE nm, VALUE val)
{
    return env_aset(nm, val);
}

Erstellt, aktualisiert oder löscht die benannte Umgebungsvariable und gibt den Wert zurück. Sowohl name als auch value können Instanzen von String sein. Siehe Gültige Namen und Werte.

Wenn die benannte Umgebungsvariable nicht existiert:

Wenn value nil ist, tut dies nichts.

ENV.clear
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
ENV.store('bar', nil) # => nil
ENV.include?('bar') # => false

Wenn value nicht nil ist, erstellt die Umgebungsvariable mit name und value.

# Create 'foo' using ENV.[]=.
ENV['foo'] = '0' # => '0'
ENV['foo'] # => '0'
# Create 'bar' using ENV.store.
ENV.store('bar', '1') # => '1'
ENV['bar'] # => '1'

Wenn die benannte Umgebungsvariable existiert:

Wenn value nicht nil ist, aktualisiert die Umgebungsvariable mit dem Wert value.

# Update 'foo' using ENV.[]=.
ENV['foo'] = '2' # => '2'
ENV['foo'] # => '2'
# Update 'bar' using ENV.store.
ENV.store('bar', '3') # => '3'
ENV['bar'] # => '3'

Wenn value nil ist, löscht die Umgebungsvariable.

# Delete 'foo' using ENV.[]=.
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
# Delete 'bar' using ENV.store.
ENV.store('bar', nil) # => nil
ENV.include?('bar') # => false

Löst eine Ausnahme aus, wenn name oder value ungültig ist. Siehe Ungültige Namen und Werte.

assoc(name) → [name, value] or nil

Source

static VALUE
env_assoc(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    VALUE e = getenv_with_lock(s);

    if (!NIL_P(e)) {
        return rb_assoc_new(key, e);
    }
    else {
        return Qnil;
    }
}

Gibt ein 2-Elemente-Array zurück, das den Namen und Wert der Umgebungsvariable für name enthält, falls diese existiert.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.assoc('foo') # => ['foo', '0']

Gibt nil zurück, wenn name ein gültiger String ist und keine solche Umgebungsvariable existiert.

Gibt nil zurück, wenn name der leere String ist oder ein String ist, der das Zeichen '=' enthält.

Löst eine Ausnahme aus, wenn name ein String ist, der das NUL-Zeichen "\0" enthält.

ENV.assoc("\0") # Raises ArgumentError (bad environment variable name: contains null byte)

Löst eine Ausnahme aus, wenn name eine Kodierung hat, die nicht ASCII-kompatibel ist.

ENV.assoc("\xa1\xa1".force_encoding(Encoding::UTF_16LE))
# Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)

Löst eine Ausnahme aus, wenn name kein String ist.

ENV.assoc(Object.new) # TypeError (no implicit conversion of Object into String)

clear → ENV

Source

static VALUE
env_clear(VALUE _)
{
    return rb_env_clear();
}

Entfernt jede Umgebungsvariable; gibt ENV zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.size # => 2
ENV.clear # => ENV
ENV.size # => 0

clone(freeze: nil) # löst TypeError aus

Source

static VALUE
env_clone(int argc, VALUE *argv, VALUE obj)
{
    if (argc) {
        VALUE opt;
        if (rb_scan_args(argc, argv, "0:", &opt) < argc) {
            rb_get_freeze_opt(1, &opt);
        }
    }

    rb_raise(rb_eTypeError, "Cannot clone ENV, use ENV.to_h to get a copy of ENV as a hash");
}

Löst TypeError aus, da ENV ein Wrapper für die prozessweiten Umgebungsvariablen ist und eine Kopie nutzlos ist. Verwenden Sie to_h, um eine Kopie der Daten von ENV als Hash zu erhalten.

delete(name) → value

delete(name) { |name| block } → value

delete(missing_name) → nil

delete(missing_name) { |name| block } → block_value

Source

static VALUE
env_delete_m(VALUE obj, VALUE name)
{
    VALUE val;

    val = env_delete(name);
    if (NIL_P(val) && rb_block_given_p()) val = rb_yield(name);
    return val;
}

Löscht die Umgebungsvariable mit name, falls sie existiert, und gibt ihren Wert zurück.

ENV['foo'] = '0'
ENV.delete('foo') # => '0'

Wenn kein Block gegeben ist und die benannte Umgebungsvariable nicht existiert, wird nil zurückgegeben.

Wenn ein Block gegeben ist und die Umgebungsvariable nicht existiert, wird name an den Block übergeben und der Wert des Blocks zurückgegeben.

ENV.delete('foo') { |name| name * 2 } # => "foofoo"

Wenn ein Block gegeben ist und die Umgebungsvariable existiert, wird die Umgebungsvariable gelöscht und ihr Wert zurückgegeben (wobei der Block ignoriert wird).

ENV['foo'] = '0'
ENV.delete('foo') { |name| raise 'ignored' } # => "0"

Löst eine Ausnahme aus, wenn name ungültig ist. Siehe Ungültige Namen und Werte.

delete_if { |name, value| block } → ENV

delete_if → an_enumerator

Source

static VALUE
env_delete_if(VALUE ehash)
{
    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    env_reject_bang(ehash);
    return envtbl;
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array, löscht jede Umgebungsvariable, für die der Block einen wahrheitsgemäßen Wert zurückgibt, und gibt ENV zurück (unabhängig davon, ob gelöscht wurde).

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.delete_if { |name, value| name.start_with?('b') } # => ENV
ENV # => {"foo"=>"0"}
ENV.delete_if { |name, value| name.start_with?('b') } # => ENV

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
e = ENV.delete_if # => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:delete_if!>
e.each { |name, value| name.start_with?('b') } # => ENV
ENV # => {"foo"=>"0"}
e.each { |name, value| name.start_with?('b') } # => ENV

dup # löst TypeError aus

Source

static VALUE
env_dup(VALUE obj)
{
    rb_raise(rb_eTypeError, "Cannot dup ENV, use ENV.to_h to get a copy of ENV as a hash");
}

Löst TypeError aus, da ENV ein Singleton-Objekt ist. Verwenden Sie to_h, um eine Kopie der Daten von ENV als Hash zu erhalten.

each { |name, value| block } → ENV

each → an_enumerator

each_pair { |name, value| block } → ENV

each_pair → an_enumerator

Source

static VALUE
env_each_pair(VALUE ehash)
{
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

    VALUE ary = rb_ary_new();

    rb_encoding *enc = env_encoding();
    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);

        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, env_str_new(*env, s-*env, enc));
                rb_ary_push(ary, env_str_new2(s+1, enc));
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    if (rb_block_pair_yield_optimizable()) {
        for (i=0; i<RARRAY_LEN(ary); i+=2) {
            rb_yield_values(2, RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1));
        }
    }
    else {
        for (i=0; i<RARRAY_LEN(ary); i+=2) {
            rb_yield(rb_assoc_new(RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1)));
        }
    }

    return ehash;
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array.

h = {}
ENV.each_pair { |name, value| h[name] = value } # => ENV
h # => {"bar"=>"1", "foo"=>"0"}

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

h = {}
e = ENV.each_pair # => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_pair>
e.each { |name, value| h[name] = value } # => ENV
h # => {"bar"=>"1", "foo"=>"0"}

each_key { |name| block } → ENV

each_key → an_enumerator

Source

static VALUE
env_each_key(VALUE ehash)
{
    VALUE keys;
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    keys = env_keys(FALSE);
    for (i=0; i<RARRAY_LEN(keys); i++) {
        rb_yield(RARRAY_AREF(keys, i));
    }
    return ehash;
}

Übergibt jeden Namen einer Umgebungsvariable.

ENV.replace('foo' => '0', 'bar' => '1') # => ENV
names = []
ENV.each_key { |name| names.push(name) } # => ENV
names # => ["bar", "foo"]

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

e = ENV.each_key # => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_key>
names = []
e.each { |name| names.push(name) } # => ENV
names # => ["bar", "foo"]

each { |name, value| block } → ENV

each → an_enumerator

each_pair { |name, value| block } → ENV

each_pair → an_enumerator

Source

static VALUE
env_each_pair(VALUE ehash)
{
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

    VALUE ary = rb_ary_new();

    rb_encoding *enc = env_encoding();
    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);

        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, env_str_new(*env, s-*env, enc));
                rb_ary_push(ary, env_str_new2(s+1, enc));
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    if (rb_block_pair_yield_optimizable()) {
        for (i=0; i<RARRAY_LEN(ary); i+=2) {
            rb_yield_values(2, RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1));
        }
    }
    else {
        for (i=0; i<RARRAY_LEN(ary); i+=2) {
            rb_yield(rb_assoc_new(RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1)));
        }
    }

    return ehash;
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array.

h = {}
ENV.each_pair { |name, value| h[name] = value } # => ENV
h # => {"bar"=>"1", "foo"=>"0"}

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

h = {}
e = ENV.each_pair # => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_pair>
e.each { |name, value| h[name] = value } # => ENV
h # => {"bar"=>"1", "foo"=>"0"}

each_value { |value| block } → ENV

each_value → an_enumerator

Source

static VALUE
env_each_value(VALUE ehash)
{
    VALUE values;
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    values = env_values();
    for (i=0; i<RARRAY_LEN(values); i++) {
        rb_yield(RARRAY_AREF(values, i));
    }
    return ehash;
}

Übergibt jeden Wert einer Umgebungsvariable.

ENV.replace('foo' => '0', 'bar' => '1') # => ENV
values = []
ENV.each_value { |value| values.push(value) } # => ENV
values # => ["1", "0"]

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

e = ENV.each_value # => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_value>
values = []
e.each { |value| values.push(value) } # => ENV
values # => ["1", "0"]

empty? → true oder false

Source

static VALUE
env_empty_p(VALUE _)
{
    bool empty = true;

    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);
        if (env[0] != 0) {
            empty = false;
        }
        FREE_ENVIRON(environ);
    }

    return RBOOL(empty);
}

Gibt true zurück, wenn keine Umgebungsvariablen vorhanden sind, andernfalls false.

ENV.clear
ENV.empty? # => true
ENV['foo'] = '0'
ENV.empty? # => false

except(*keys) → a_hash

Source

static VALUE
env_except(int argc, VALUE *argv, VALUE _)
{
    int i;
    VALUE key, hash = env_to_hash();

    for (i = 0; i < argc; i++) {
        key = argv[i];
        rb_hash_delete(hash, key);
    }

    return hash;
}

Gibt einen Hash zurück, der alle Namen/Werte-Paare aus ENV außer den angegebenen Schlüsseln enthält.

ENV                       #=> {"LANG"=>"en_US.UTF-8", "TERM"=>"xterm-256color", "HOME"=>"/Users/rhc"}
ENV.except("TERM","HOME") #=> {"LANG"=>"en_US.UTF-8"}

fetch(name) → value

fetch(name, default) → value

fetch(name) { |name| block } → value

Source

static VALUE
env_fetch(int argc, VALUE *argv, VALUE _)
{
    VALUE key;
    long block_given;
    const char *nam;
    VALUE env;

    rb_check_arity(argc, 1, 2);
    key = argv[0];
    block_given = rb_block_given_p();
    if (block_given && argc == 2) {
        rb_warn("block supersedes default value argument");
    }
    nam = env_name(key);
    env = getenv_with_lock(nam);

    if (NIL_P(env)) {
        if (block_given) return rb_yield(key);
        if (argc == 1) {
            rb_key_err_raise(rb_sprintf("key not found: \"%"PRIsVALUE"\"", key), envtbl, key);
        }
        return argv[1];
    }
    return env;
}

Wenn name der Name einer Umgebungsvariable ist, wird ihr Wert zurückgegeben.

ENV['foo'] = '0'
ENV.fetch('foo') # => '0'

Andernfalls, wenn ein Block gegeben ist (aber kein Standardwert), wird name an den Block übergeben und der Rückgabewert des Blocks zurückgegeben.

ENV.fetch('foo') { |name| :need_not_return_a_string } # => :need_not_return_a_string

Andernfalls, wenn ein Standardwert gegeben ist (aber kein Block), wird der Standardwert zurückgegeben.

ENV.delete('foo')
ENV.fetch('foo', :default_need_not_be_a_string) # => :default_need_not_be_a_string

Wenn die Umgebungsvariable nicht existiert und sowohl Standardwert als auch Block gegeben sind, wird eine Warnung ausgegeben ("warning: block supersedes default value argument"), name wird an den Block übergeben und der Rückgabewert des Blocks zurückgegeben.

ENV.fetch('foo', :default) { |name| :block_return } # => :block_return

Löst KeyError aus, wenn name gültig ist, aber nicht gefunden wird und weder ein Standardwert noch ein Block gegeben ist.

ENV.fetch('foo') # Raises KeyError (key not found: "foo")

Löst eine Ausnahme aus, wenn name ungültig ist. Siehe Ungültige Namen und Werte.

select { |name, value| block } → hash of name/value pairs

select → an_enumerator

filter { |name, value| block } → hash of name/value pairs

filter → an_enumerator

Source

static VALUE
env_select(VALUE ehash)
{
    VALUE result;
    VALUE keys;
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    result = rb_hash_new();
    keys = env_keys(FALSE);
    for (i = 0; i < RARRAY_LEN(keys); ++i) {
        VALUE key = RARRAY_AREF(keys, i);
        VALUE val = rb_f_getenv(Qnil, key);
        if (!NIL_P(val)) {
            if (RTEST(rb_yield_values(2, key, val))) {
                rb_hash_aset(result, key, val);
            }
        }
    }
    RB_GC_GUARD(keys);

    return result;
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array, gibt einen Hash der Namen und Werte zurück, für die der Block einen wahrheitsgemäßen Wert zurückgibt.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.select { |name, value| name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}
ENV.filter { |name, value| name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

e = ENV.select # => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:select>
e.each { |name, value | name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}
e = ENV.filter # => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:filter>
e.each { |name, value | name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}

select! { |name, value| block } → ENV or nil

select! → an_enumerator

filter! { |name, value| block } → ENV or nil

filter! → an_enumerator

Source

static VALUE
env_select_bang(VALUE ehash)
{
    VALUE keys;
    long i;
    int del = 0;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    keys = env_keys(FALSE);
    RBASIC_CLEAR_CLASS(keys);
    for (i=0; i<RARRAY_LEN(keys); i++) {
        VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
        if (!NIL_P(val)) {
            if (!RTEST(rb_yield_values(2, RARRAY_AREF(keys, i), val))) {
                env_delete(RARRAY_AREF(keys, i));
                del++;
            }
        }
    }
    RB_GC_GUARD(keys);
    if (del == 0) return Qnil;
    return envtbl;
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array, löscht jeden Eintrag, für den der Block false oder nil zurückgibt, und gibt ENV zurück, wenn Löschungen vorgenommen wurden, oder nil andernfalls.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.select! { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
ENV.select! { |name, value| true } # => nil

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.filter! { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
ENV.filter! { |name, value| true } # => nil

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
e = ENV.select! # => #<Enumerator: {"bar"=>"1", "baz"=>"2"}:select!>
e.each { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
e.each { |name, value| true } # => nil

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
e = ENV.filter! # => #<Enumerator: {"bar"=>"1", "baz"=>"2"}:filter!>
e.each { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
e.each { |name, value| true } # => nil

einfrieren

Source

static VALUE
env_freeze(VALUE self)
{
    rb_raise(rb_eTypeError, "cannot freeze ENV");
    UNREACHABLE_RETURN(self);
}

Löst eine Ausnahme aus.

ENV.freeze # Raises TypeError (cannot freeze ENV)

include?(name) → true or false

has_key?(name) → true or false

member?(name) → true or false

key?(name) → true or false

Source

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

Gibt true zurück, wenn es eine Umgebungsvariable mit dem gegebenen name gibt.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.include?('foo') # => true

Gibt false zurück, wenn name ein gültiger String ist und keine solche Umgebungsvariable existiert.

ENV.include?('baz') # => false

Gibt false zurück, wenn name der leere String ist oder ein String ist, der das Zeichen '=' enthält.

ENV.include?('') # => false
ENV.include?('=') # => false

Löst eine Ausnahme aus, wenn name ein String ist, der das NUL-Zeichen "\0" enthält.

ENV.include?("\0") # Raises ArgumentError (bad environment variable name: contains null byte)

Löst eine Ausnahme aus, wenn name eine Kodierung hat, die nicht ASCII-kompatibel ist.

ENV.include?("\xa1\xa1".force_encoding(Encoding::UTF_16LE))
# Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)

Löst eine Ausnahme aus, wenn name kein String ist.

ENV.include?(Object.new) # TypeError (no implicit conversion of Object into String)

value?(value) → true or false

has_value?(value) → true or false

Source

static VALUE
env_has_value(VALUE dmy, VALUE obj)
{
    obj = rb_check_string_type(obj);
    if (NIL_P(obj)) return Qnil;

    VALUE ret = Qfalse;

    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
                    ret = Qtrue;
                    break;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    return ret;
}

Gibt true zurück, wenn value der Wert für irgendeinen Namen einer Umgebungsvariable ist, andernfalls false.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.value?('0') # => true
ENV.has_value?('0') # => true
ENV.value?('2') # => false
ENV.has_value?('2') # => false

include?(name) → true or false

has_key?(name) → true or false

member?(name) → true or false

key?(name) → true or false

Source

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

Gibt true zurück, wenn es eine Umgebungsvariable mit dem gegebenen name gibt.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.include?('foo') # => true

Gibt false zurück, wenn name ein gültiger String ist und keine solche Umgebungsvariable existiert.

ENV.include?('baz') # => false

Gibt false zurück, wenn name der leere String ist oder ein String ist, der das Zeichen '=' enthält.

ENV.include?('') # => false
ENV.include?('=') # => false

Löst eine Ausnahme aus, wenn name ein String ist, der das NUL-Zeichen "\0" enthält.

ENV.include?("\0") # Raises ArgumentError (bad environment variable name: contains null byte)

Löst eine Ausnahme aus, wenn name eine Kodierung hat, die nicht ASCII-kompatibel ist.

ENV.include?("\xa1\xa1".force_encoding(Encoding::UTF_16LE))
# Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)

Löst eine Ausnahme aus, wenn name kein String ist.

ENV.include?(Object.new) # TypeError (no implicit conversion of Object into String)

inspect → a_string

Source

static VALUE
env_inspect(VALUE _)
{
    VALUE str = rb_str_buf_new2("{");
    rb_encoding *enc = env_encoding();

    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);
        while (*env) {
            const char *s = strchr(*env, '=');

            if (env != environ) {
                rb_str_buf_cat2(str, ", ");
            }
            if (s) {
                rb_str_buf_append(str, rb_str_inspect(env_enc_str_new(*env, s-*env, enc)));
                rb_str_buf_cat2(str, " => ");
                s++;
                rb_str_buf_append(str, rb_str_inspect(env_enc_str_new(s, strlen(s), enc)));
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    rb_str_buf_cat2(str, "}");

    return str;
}

Gibt den Inhalt der Umgebung als String zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.inspect # => "{\"bar\"=>\"1\", \"foo\"=>\"0\"}"

invert → hash of value/name pairs

Source

static VALUE
env_invert(VALUE _)
{
    return rb_hash_invert(env_to_hash());
}

Gibt einen Hash zurück, dessen Schlüssel die Werte von ENV sind und dessen Werte die entsprechenden Namen von ENV sind.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.invert # => {"1"=>"bar", "0"=>"foo"}

Bei einem doppelten ENV-Wert wird der Hash-Eintrag überschrieben.

ENV.replace('foo' => '0', 'bar' => '0')
ENV.invert # => {"0"=>"foo"}

Beachten Sie, dass die Reihenfolge der Verarbeitung von ENV vom Betriebssystem abhängt, was bedeutet, dass die Reihenfolge der Überschreibung ebenfalls vom Betriebssystem abhängt. Siehe Zur Reihenfolge.

keep_if { |name, value| block } → ENV

keep_if → an_enumerator

Source

static VALUE
env_keep_if(VALUE ehash)
{
    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    env_select_bang(ehash);
    return envtbl;
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array, löscht jede Umgebungsvariable, für die der Block false oder nil zurückgibt, und gibt ENV zurück.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.keep_if { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
e = ENV.keep_if # => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:keep_if>
e.each { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}

key(value) → name or nil

Source

static VALUE
env_key(VALUE dmy, VALUE value)
{
    StringValue(value);
    VALUE str = Qnil;

    rb_encoding *enc = env_encoding();
    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(value) == len && strncmp(s, RSTRING_PTR(value), len) == 0) {
                    str = env_str_new(*env, s-*env-1, enc);
                    break;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    return str;
}

Gibt den Namen der ersten Umgebungsvariable mit value zurück, falls diese existiert.

ENV.replace('foo' => '0', 'bar' => '0')
ENV.key('0') # => "foo"

Die Reihenfolge, in der Umgebungsvariablen untersucht werden, ist vom Betriebssystem abhängig. Siehe Zur Reihenfolge.

Gibt nil zurück, wenn kein solcher Wert existiert.

Löst eine Ausnahme aus, wenn value ungültig ist.

ENV.key(Object.new) # raises TypeError (no implicit conversion of Object into String)

Siehe Ungültige Namen und Werte.

include?(name) → true or false

has_key?(name) → true or false

member?(name) → true or false

key?(name) → true or false

Source

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

Gibt true zurück, wenn es eine Umgebungsvariable mit dem gegebenen name gibt.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.include?('foo') # => true

Gibt false zurück, wenn name ein gültiger String ist und keine solche Umgebungsvariable existiert.

ENV.include?('baz') # => false

Gibt false zurück, wenn name der leere String ist oder ein String ist, der das Zeichen '=' enthält.

ENV.include?('') # => false
ENV.include?('=') # => false

Löst eine Ausnahme aus, wenn name ein String ist, der das NUL-Zeichen "\0" enthält.

ENV.include?("\0") # Raises ArgumentError (bad environment variable name: contains null byte)

Löst eine Ausnahme aus, wenn name eine Kodierung hat, die nicht ASCII-kompatibel ist.

ENV.include?("\xa1\xa1".force_encoding(Encoding::UTF_16LE))
# Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)

Löst eine Ausnahme aus, wenn name kein String ist.

ENV.include?(Object.new) # TypeError (no implicit conversion of Object into String)

keys → array of names

Source

static VALUE
env_f_keys(VALUE _)
{
    return env_keys(FALSE);
}

Gibt alle Variablennamen in einem Array zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.keys # => ['bar', 'foo']

Die Reihenfolge der Namen ist vom Betriebssystem abhängig. Siehe Zur Reihenfolge.

Gibt das leere Array zurück, wenn ENV leer ist.

length → an_integer

size → an_integer

Source

static VALUE
env_size(VALUE _)
{
    return INT2FIX(env_size_with_lock());
}

Gibt die Anzahl der Umgebungsvariablen zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.length # => 2
ENV.size # => 2

include?(name) → true or false

has_key?(name) → true or false

member?(name) → true or false

key?(name) → true or false

Source

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

Gibt true zurück, wenn es eine Umgebungsvariable mit dem gegebenen name gibt.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.include?('foo') # => true

Gibt false zurück, wenn name ein gültiger String ist und keine solche Umgebungsvariable existiert.

ENV.include?('baz') # => false

Gibt false zurück, wenn name der leere String ist oder ein String ist, der das Zeichen '=' enthält.

ENV.include?('') # => false
ENV.include?('=') # => false

Löst eine Ausnahme aus, wenn name ein String ist, der das NUL-Zeichen "\0" enthält.

ENV.include?("\0") # Raises ArgumentError (bad environment variable name: contains null byte)

Löst eine Ausnahme aus, wenn name eine Kodierung hat, die nicht ASCII-kompatibel ist.

ENV.include?("\xa1\xa1".force_encoding(Encoding::UTF_16LE))
# Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)

Löst eine Ausnahme aus, wenn name kein String ist.

ENV.include?(Object.new) # TypeError (no implicit conversion of Object into String)

update → ENV

update(*hashes) → ENV

update(*hashes) { |name, env_val, hash_val| block } → ENV

merge! → ENV

merge!(*hashes) → ENV

merge!(*hashes) { |name, env_val, hash_val| block } → ENV

Source

static VALUE
env_update(int argc, VALUE *argv, VALUE env)
{
    rb_foreach_func *func = rb_block_given_p() ?
        env_update_block_i : env_update_i;
    for (int i = 0; i < argc; ++i) {
        VALUE hash = argv[i];
        if (env == hash) continue;
        hash = to_hash(hash);
        rb_hash_foreach(hash, func, 0);
    }
    return env;
}

Fügt ENV jedes Schlüssel/Wert-Paar aus dem gegebenen Hash hinzu; gibt ENV zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.merge!('baz' => '2', 'bat' => '3') # => {"bar"=>"1", "bat"=>"3", "baz"=>"2", "foo"=>"0"}

Löscht den ENV-Eintrag für einen Hash-Wert, der nil ist.

ENV.merge!('baz' => nil, 'bat' => nil) # => {"bar"=>"1", "foo"=>"0"}

Bei einem bereits vorhandenen Namen wird bei fehlendem Block der ENV-Wert überschrieben.

ENV.merge!('foo' => '4') # => {"bar"=>"1", "foo"=>"4"}

Bei einem bereits vorhandenen Namen wird bei gegebenem Block der Name, sein ENV-Wert und sein Hash-Wert übergeben; der Rückgabewert des Blocks wird zum neuen Namen.

ENV.merge!('foo' => '5') { |name, env_val, hash_val | env_val + hash_val } # => {"bar"=>"1", "foo"=>"45"}

Löst eine Ausnahme aus, wenn ein Name oder Wert ungültig ist (siehe Ungültige Namen und Werte).

ENV.replace('foo' => '0', 'bar' => '1')
ENV.merge!('foo' => '6', :bar => '7', 'baz' => '9') # Raises TypeError (no implicit conversion of Symbol into String)
ENV # => {"bar"=>"1", "foo"=>"6"}
ENV.merge!('foo' => '7', 'bar' => 8, 'baz' => '9') # Raises TypeError (no implicit conversion of Integer into String)
ENV # => {"bar"=>"1", "foo"=>"7"}

Löst eine Ausnahme aus, wenn der Block einen ungültigen Namen zurückgibt: (siehe Ungültige Namen und Werte)

ENV.merge!('bat' => '8', 'foo' => '9') { |name, env_val, hash_val | 10 } # Raises TypeError (no implicit conversion of Integer into String)
ENV # => {"bar"=>"1", "bat"=>"8", "foo"=>"7"}

Beachten Sie, dass bei den oben genannten Ausnahmen Hash-Paare, die einem ungültigen Namen oder Wert vorausgehen, normal verarbeitet werden; die folgenden werden ignoriert.

rassoc(value) → [name, value] or nil

Source

static VALUE
env_rassoc(VALUE dmy, VALUE obj)
{
    obj = rb_check_string_type(obj);
    if (NIL_P(obj)) return Qnil;

    VALUE result = Qnil;

    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);

        while (*env) {
            const char *p = *env;
            char *s = strchr(p, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
                    result = rb_assoc_new(rb_str_new(p, s-p-1), obj);
                    break;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    return result;
}

Gibt ein 2-Elemente-Array zurück, das den Namen und Wert der **ersten gefundenen** Umgebungsvariable enthält, die den Wert value hat, falls eine existiert.

ENV.replace('foo' => '0', 'bar' => '0')
ENV.rassoc('0') # => ["bar", "0"]

Die Reihenfolge, in der Umgebungsvariablen untersucht werden, ist vom Betriebssystem abhängig. Siehe Zur Reihenfolge.

Gibt nil zurück, wenn keine solche Umgebungsvariable existiert.

rehash → nil

Source

static VALUE
env_none(VALUE _)
{
    return Qnil;
}

(Bereitgestellt zur Kompatibilität mit Hash.)

Ändert ENV nicht; gibt nil zurück.

reject { |name, value| block } → hash of name/value pairs

reject → an_enumerator

Source

static VALUE
env_reject(VALUE _)
{
    return rb_hash_delete_if(env_to_hash());
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array. Gibt einen Hash zurück, dessen Elemente durch den Block bestimmt werden. Wenn der Block einen wahrheitsgemäßen Wert zurückgibt, wird das Namen/Werte-Paar zum zurückgegebenen Hash hinzugefügt; andernfalls wird das Paar ignoriert.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.reject { |name, value| name.start_with?('b') } # => {"foo"=>"0"}

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

e = ENV.reject
e.each { |name, value| name.start_with?('b') } # => {"foo"=>"0"}

reject! { |name, value| block } → ENV or nil

reject! → an_enumerator

Source

static VALUE
env_reject_bang(VALUE ehash)
{
    VALUE keys;
    long i;
    int del = 0;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    keys = env_keys(FALSE);
    RBASIC_CLEAR_CLASS(keys);
    for (i=0; i<RARRAY_LEN(keys); i++) {
        VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
        if (!NIL_P(val)) {
            if (RTEST(rb_yield_values(2, RARRAY_AREF(keys, i), val))) {
                env_delete(RARRAY_AREF(keys, i));
                del++;
            }
        }
    }
    RB_GC_GUARD(keys);
    if (del == 0) return Qnil;
    return envtbl;
}

Ähnlich wie ENV.delete_if, gibt aber nil zurück, wenn keine Änderungen vorgenommen wurden.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.reject! { |name, value| name.start_with?('b') } # => ENV
ENV # => {"foo"=>"0"}
ENV.reject! { |name, value| name.start_with?('b') } # => nil

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
e = ENV.reject! # => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:reject!>
e.each { |name, value| name.start_with?('b') } # => ENV
ENV # => {"foo"=>"0"}
e.each { |name, value| name.start_with?('b') } # => nil

replace(hash) → ENV

Source

static VALUE
env_replace(VALUE env, VALUE hash)
{
    VALUE keys;
    long i;

    keys = env_keys(TRUE);
    if (env == hash) return env;
    hash = to_hash(hash);
    rb_hash_foreach(hash, env_replace_i, keys);

    for (i=0; i<RARRAY_LEN(keys); i++) {
        env_delete(RARRAY_AREF(keys, i));
    }
    RB_GC_GUARD(keys);
    return env;
}

Ersetzt den gesamten Inhalt der Umgebungsvariablen durch die Namen/Werte-Paare im gegebenen Hash; gibt ENV zurück.

Ersetzt den Inhalt von ENV durch die gegebenen Paare.

ENV.replace('foo' => '0', 'bar' => '1') # => ENV
ENV.to_hash # => {"bar"=>"1", "foo"=>"0"}

Löst eine Ausnahme aus, wenn ein Name oder Wert ungültig ist (siehe Ungültige Namen und Werte).

ENV.replace('foo' => '0', :bar => '1') # Raises TypeError (no implicit conversion of Symbol into String)
ENV.replace('foo' => '0', 'bar' => 1) # Raises TypeError (no implicit conversion of Integer into String)
ENV.to_hash # => {"bar"=>"1", "foo"=>"0"}

select { |name, value| block } → hash of name/value pairs

select → an_enumerator

filter { |name, value| block } → hash of name/value pairs

filter → an_enumerator

Source

static VALUE
env_select(VALUE ehash)
{
    VALUE result;
    VALUE keys;
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    result = rb_hash_new();
    keys = env_keys(FALSE);
    for (i = 0; i < RARRAY_LEN(keys); ++i) {
        VALUE key = RARRAY_AREF(keys, i);
        VALUE val = rb_f_getenv(Qnil, key);
        if (!NIL_P(val)) {
            if (RTEST(rb_yield_values(2, key, val))) {
                rb_hash_aset(result, key, val);
            }
        }
    }
    RB_GC_GUARD(keys);

    return result;
}

Übergibt jeden Namen einer Umgebungsvariable und seinen Wert als 2-Elemente-Array, gibt einen Hash der Namen und Werte zurück, für die der Block einen wahrheitsgemäßen Wert zurückgibt.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.select { |name, value| name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}
ENV.filter { |name, value| name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

e = ENV.select # => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:select>
e.each { |name, value | name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}
e = ENV.filter # => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:filter>
e.each { |name, value | name.start_with?('b') } # => {"bar"=>"1", "baz"=>"2"}

select! { |name, value| block } → ENV or nil

select! → an_enumerator

filter! { |name, value| block } → ENV or nil

filter! → an_enumerator

Source

static VALUE
env_select_bang(VALUE ehash)
{
    VALUE keys;
    long i;
    int del = 0;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    keys = env_keys(FALSE);
    RBASIC_CLEAR_CLASS(keys);
    for (i=0; i<RARRAY_LEN(keys); i++) {
        VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
        if (!NIL_P(val)) {
            if (!RTEST(rb_yield_values(2, RARRAY_AREF(keys, i), val))) {
                env_delete(RARRAY_AREF(keys, i));
                del++;
            }
        }
    }
    RB_GC_GUARD(keys);
    if (del == 0) return Qnil;
    return envtbl;
}

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.select! { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
ENV.select! { |name, value| true } # => nil

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.filter! { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
ENV.filter! { |name, value| true } # => nil

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
e = ENV.select! # => #<Enumerator: {"bar"=>"1", "baz"=>"2"}:select!>
e.each { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
e.each { |name, value| true } # => nil

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
e = ENV.filter! # => #<Enumerator: {"bar"=>"1", "baz"=>"2"}:filter!>
e.each { |name, value| name.start_with?('b') } # => ENV
ENV # => {"bar"=>"1", "baz"=>"2"}
e.each { |name, value| true } # => nil

shift → [name, value] or nil

Source

static VALUE
env_shift(VALUE _)
{
    VALUE result = Qnil;
    VALUE key = Qnil;

    rb_encoding *enc = env_encoding();
    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);
        if (*env) {
            const char *p = *env;
            char *s = strchr(p, '=');
            if (s) {
                key = env_str_new(p, s-p, enc);
                VALUE val = env_str_new2(getenv(RSTRING_PTR(key)), enc);
                result = rb_assoc_new(key, val);
            }
        }
        FREE_ENVIRON(environ);
    }

    if (!NIL_P(key)) {
        env_delete(key);
    }

    return result;
}

Entfernt die erste Umgebungsvariable aus ENV und gibt ein 2-Elemente-Array zurück, das ihren Namen und Wert enthält.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.to_hash # => {'bar' => '1', 'foo' => '0'}
ENV.shift # => ['bar', '1']
ENV.to_hash # => {'foo' => '0'}

Welche Umgebungsvariable "erste" ist, ist vom Betriebssystem abhängig. Siehe Zur Reihenfolge.

Gibt nil zurück, wenn die Umgebung leer ist.

length → an_integer

size → an_integer

Source

static VALUE
env_size(VALUE _)
{
    return INT2FIX(env_size_with_lock());
}

Gibt die Anzahl der Umgebungsvariablen zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.length # => 2
ENV.size # => 2

slice(*names) → hash of name/value pairs

Source

static VALUE
env_slice(int argc, VALUE *argv, VALUE _)
{
    int i;
    VALUE key, value, result;

    if (argc == 0) {
        return rb_hash_new();
    }
    result = rb_hash_new_with_size(argc);

    for (i = 0; i < argc; i++) {
        key = argv[i];
        value = rb_f_getenv(Qnil, key);
        if (value != Qnil)
            rb_hash_aset(result, key, value);
    }

    return result;
}

Gibt einen Hash der gegebenen ENV-Namen und ihrer entsprechenden Werte zurück.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2', 'bat' => '3')
ENV.slice('foo', 'baz') # => {"foo"=>"0", "baz"=>"2"}
ENV.slice('baz', 'foo') # => {"baz"=>"2", "foo"=>"0"}

Löst eine Ausnahme aus, wenn einer der names ungültig ist (siehe Ungültige Namen und Werte).

ENV.slice('foo', 'bar', :bat) # Raises TypeError (no implicit conversion of Symbol into String)

ENV[name] = value → value

store(name, value) → value

Source

static VALUE
env_aset_m(VALUE obj, VALUE nm, VALUE val)
{
    return env_aset(nm, val);
}

Erstellt, aktualisiert oder löscht die benannte Umgebungsvariable und gibt den Wert zurück. Sowohl name als auch value können Instanzen von String sein. Siehe Gültige Namen und Werte.

Wenn die benannte Umgebungsvariable nicht existiert:

Wenn value nil ist, tut dies nichts.

ENV.clear
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
ENV.store('bar', nil) # => nil
ENV.include?('bar') # => false

Wenn value nicht nil ist, erstellt die Umgebungsvariable mit name und value.

# Create 'foo' using ENV.[]=.
ENV['foo'] = '0' # => '0'
ENV['foo'] # => '0'
# Create 'bar' using ENV.store.
ENV.store('bar', '1') # => '1'
ENV['bar'] # => '1'

Wenn die benannte Umgebungsvariable existiert:

Wenn value nicht nil ist, aktualisiert die Umgebungsvariable mit dem Wert value.

# Update 'foo' using ENV.[]=.
ENV['foo'] = '2' # => '2'
ENV['foo'] # => '2'
# Update 'bar' using ENV.store.
ENV.store('bar', '3') # => '3'
ENV['bar'] # => '3'

Wenn value nil ist, löscht die Umgebungsvariable.

# Delete 'foo' using ENV.[]=.
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
# Delete 'bar' using ENV.store.
ENV.store('bar', nil) # => nil
ENV.include?('bar') # => false

Löst eine Ausnahme aus, wenn name oder value ungültig ist. Siehe Ungültige Namen und Werte.

to_a → array of 2-element arrays

Source

static VALUE
env_to_a(VALUE _)
{
    VALUE ary = rb_ary_new();

    rb_encoding *enc = env_encoding();
    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, rb_assoc_new(env_str_new(*env, s-*env, enc),
                                              env_str_new2(s+1, enc)));
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    return ary;
}

Gibt den Inhalt von ENV als Array von 2-Elemente-Arrays zurück, die jeweils ein Namen/Werte-Paar sind.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.to_a # => [["bar", "1"], ["foo", "0"]]

to_h → hash of name/value pairs

to_h {|name, value| block } → hash of name/value pairs

Source

static VALUE
env_to_h(VALUE _)
{
    VALUE hash = env_to_hash();
    if (rb_block_given_p()) {
        hash = rb_hash_to_h_block(hash);
    }
    return hash;
}

Ohne Block gibt dies einen Hash zurück, der alle Namen/Werte-Paare aus ENV enthält.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.to_h # => {"bar"=>"1", "foo"=>"0"}

Mit einem Block gibt dies einen Hash zurück, dessen Elemente durch den Block bestimmt werden. Jedes Namen/Werte-Paar in ENV wird an den Block übergeben. Der Block muss ein 2-Elemente-Array (Namen/Werte-Paar) zurückgeben, das als Schlüssel und Wert zum zurückgegebenen Hash hinzugefügt wird.

ENV.to_h { |name, value| [name.to_sym, value.to_i] } # => {bar: 1, foo: 0}

Löst eine Ausnahme aus, wenn der Block kein Array zurückgibt.

ENV.to_h { |name, value| name } # Raises TypeError (wrong element type String (expected array))

Löst eine Ausnahme aus, wenn der Block ein Array mit der falschen Größe zurückgibt.

ENV.to_h { |name, value| [name] } # Raises ArgumentError (element has wrong array length (expected 2, was 1))

to_hash → hash of name/value pairs

Source

static VALUE
env_f_to_hash(VALUE _)
{
    return env_to_hash();
}

Gibt einen Hash zurück, der alle Namen/Werte-Paare aus ENV enthält.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.to_hash # => {"bar"=>"1", "foo"=>"0"}

to_s → "ENV"

Source

static VALUE
env_to_s(VALUE _)
{
    return rb_usascii_str_new2("ENV");
}

Gibt den String 'ENV' zurück.

ENV.to_s # => "ENV"

update → ENV

update(*hashes) → ENV

update(*hashes) { |name, env_val, hash_val| block } → ENV

merge! → ENV

merge!(*hashes) → ENV

merge!(*hashes) { |name, env_val, hash_val| block } → ENV

Source

static VALUE
env_update(int argc, VALUE *argv, VALUE env)
{
    rb_foreach_func *func = rb_block_given_p() ?
        env_update_block_i : env_update_i;
    for (int i = 0; i < argc; ++i) {
        VALUE hash = argv[i];
        if (env == hash) continue;
        hash = to_hash(hash);
        rb_hash_foreach(hash, func, 0);
    }
    return env;
}

Fügt ENV jedes Schlüssel/Wert-Paar aus dem gegebenen Hash hinzu; gibt ENV zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.merge!('baz' => '2', 'bat' => '3') # => {"bar"=>"1", "bat"=>"3", "baz"=>"2", "foo"=>"0"}

Löscht den ENV-Eintrag für einen Hash-Wert, der nil ist.

ENV.merge!('baz' => nil, 'bat' => nil) # => {"bar"=>"1", "foo"=>"0"}

Bei einem bereits vorhandenen Namen wird bei fehlendem Block der ENV-Wert überschrieben.

ENV.merge!('foo' => '4') # => {"bar"=>"1", "foo"=>"4"}

Bei einem bereits vorhandenen Namen wird bei gegebenem Block der Name, sein ENV-Wert und sein Hash-Wert übergeben; der Rückgabewert des Blocks wird zum neuen Namen.

ENV.merge!('foo' => '5') { |name, env_val, hash_val | env_val + hash_val } # => {"bar"=>"1", "foo"=>"45"}

Löst eine Ausnahme aus, wenn ein Name oder Wert ungültig ist (siehe Ungültige Namen und Werte).

ENV.replace('foo' => '0', 'bar' => '1')
ENV.merge!('foo' => '6', :bar => '7', 'baz' => '9') # Raises TypeError (no implicit conversion of Symbol into String)
ENV # => {"bar"=>"1", "foo"=>"6"}
ENV.merge!('foo' => '7', 'bar' => 8, 'baz' => '9') # Raises TypeError (no implicit conversion of Integer into String)
ENV # => {"bar"=>"1", "foo"=>"7"}

Löst eine Ausnahme aus, wenn der Block einen ungültigen Namen zurückgibt: (siehe Ungültige Namen und Werte)

ENV.merge!('bat' => '8', 'foo' => '9') { |name, env_val, hash_val | 10 } # Raises TypeError (no implicit conversion of Integer into String)
ENV # => {"bar"=>"1", "bat"=>"8", "foo"=>"7"}

Beachten Sie, dass bei den oben genannten Ausnahmen Hash-Paare, die einem ungültigen Namen oder Wert vorausgehen, normal verarbeitet werden; die folgenden werden ignoriert.

value?(value) → true or false

has_value?(value) → true or false

Source

static VALUE
env_has_value(VALUE dmy, VALUE obj)
{
    obj = rb_check_string_type(obj);
    if (NIL_P(obj)) return Qnil;

    VALUE ret = Qfalse;

    ENV_LOCKING() {
        char **env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
                    ret = Qtrue;
                    break;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }

    return ret;
}

Gibt true zurück, wenn value der Wert für irgendeinen Namen einer Umgebungsvariable ist, andernfalls false.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.value?('0') # => true
ENV.has_value?('0') # => true
ENV.value?('2') # => false
ENV.has_value?('2') # => false

values → array of values

Source

static VALUE
env_f_values(VALUE _)
{
    return env_values();
}

Gibt alle Werte von Umgebungsvariablen in einem Array zurück.

ENV.replace('foo' => '0', 'bar' => '1')
ENV.values # => ['1', '0']

Die Reihenfolge der Werte ist vom Betriebssystem abhängig. Siehe Zur Reihenfolge.

Gibt das leere Array zurück, wenn ENV leer ist.

values_at(*names) → array of values

Source

static VALUE
env_values_at(int argc, VALUE *argv, VALUE _)
{
    VALUE result;
    long i;

    result = rb_ary_new();
    for (i=0; i<argc; i++) {
        rb_ary_push(result, rb_f_getenv(Qnil, argv[i]));
    }
    return result;
}

Gibt ein Array zurück, das die den angegebenen Namen zugeordneten Umgebungsvariablenwerte enthält.

ENV.replace('foo' => '0', 'bar' => '1', 'baz' => '2')
ENV.values_at('foo', 'baz') # => ["0", "2"]

Gibt nil in dem Array für jeden Namen zurück, der kein ENV-Name ist.

ENV.values_at('foo', 'bat', 'bar', 'bam') # => ["0", nil, "1", nil]

Gibt ein leeres Array zurück, wenn keine Namen angegeben sind.

Löst eine Ausnahme aus, wenn ein Name ungültig ist. Siehe Ungültige Namen und Werte.