класс ENV

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

Возвращает значение для переменной среды name, если она существует:

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

Возвращает nil, если переменная с указанным именем не существует.

Вызывает исключение, если name является недопустимым. См. Invalid Names and Values.

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

ENV.store является псевдонимом для ENV.[]=.

Создает, обновляет или удаляет переменную среды с указанным именем, возвращая значение. И name, и value могут быть экземплярами String. См. Valid Names and Values.

• Если переменная среды с указанным именем не существует:

  • Если value равно nil, ничего не делает.

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

  • Если value не равно nil, создает переменную среды с name и 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'
    

• Если переменная среды с указанным именем существует:

  • Если value не равно nil, обновляет переменную среды со значением 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'
    

  • Если value равно nil, удаляет переменную среды:

    # 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
    

Вызывает исключение, если name или value является недопустимым. См. Invalid Names and Values.

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

Возвращает 2-элементный Array, содержащий имя и значение переменной среды для name, если она существует:

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

Возвращает nil, если name является допустимым String, и такой переменной среды нет.

Возвращает nil, если name является пустой String или String, содержащей символ '='.

Вызывает исключение, если name является String, содержащей символ NUL "\0":

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

Вызывает исключение, если name имеет кодировку, несовместимую с ASCII:

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

Вызывает исключение, если name не является строкой:

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

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

Удаляет все переменные среды; возвращает ENV:

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

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

Вызывает TypeError, потому что ENV является оберткой для переменных среды всего процесса, и клон бесполезен. Используйте to_h, чтобы получить копию данных ENV в виде хэша.

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

Удаляет переменную среды с name, если она существует, и возвращает ее значение:

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

Если блок не задан, а переменная среды с указанным именем не существует, возвращает nil.

Если блок задан, а переменная среды не существует, передает name в блок и возвращает значение блока:

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

Если блок задан, а переменная среды существует, удаляет переменную среды и возвращает ее значение (игнорируя блок):

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

Вызывает исключение, если name является недопустимым. См. Invalid Names and Values.

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

Передает каждое имя переменной среды и ее значение в виде 2-элементного Array, удаляя каждую переменную среды, для которой блок возвращает истинное значение, и возвращая ENV (независимо от того, были ли произведены удаления):

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

Возвращает Enumerator, если блок не задан:

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

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

Вызывает TypeError, потому что ENV является одиночным объектом. Используйте to_h, чтобы получить копию данных ENV в виде хэша.

static VALUE
env_each_pair(VALUE ehash)
{
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

    VALUE ary = rb_ary_new();

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

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

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

Передает каждое имя переменной среды и ее значение в виде 2-элементного массива:

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

Возвращает Enumerator, если блок не задан:

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

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

Передает каждое имя переменной среды:

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

Возвращает Enumerator, если блок не задан:

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

static VALUE
env_each_pair(VALUE ehash)
{
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

    VALUE ary = rb_ary_new();

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

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

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

Передает каждое имя переменной среды и ее значение в виде 2-элементного массива:

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

Возвращает Enumerator, если блок не задан:

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

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

Передает каждое значение переменной среды:

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

Возвращает Enumerator, если блок не задан:

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

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

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

    return RBOOL(empty);
}

Возвращает true, когда переменных среды нет, false в противном случае:

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

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

Возвращает хэш, исключая заданные ключи из ENV и их значения.

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

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

Если name — имя переменной окружения, возвращает её значение:

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

Иначе, если предоставлен блок (но не значение по умолчанию), передает name в блок и возвращает значение, возвращаемое блоком:

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

Иначе, если предоставлено значение по умолчанию (но не блок), возвращает значение по умолчанию:

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

Если переменная окружения не существует, и предоставлены как значение по умолчанию, так и блок, выдает предупреждение («warning: block supersedes default value argument»), передает name в блок и возвращает значение, возвращаемое блоком:

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

Вызывает KeyError, если name является допустимым, но не найден, и не предоставлены ни значение по умолчанию, ни блок:

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

Вызывает исключение, если name является недопустимым. См. Invalid Names and Values.

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

ENV.filter является псевдонимом для ENV.select.

Передает каждое имя переменной окружения и её значение в виде 2-элементного Array, возвращая Hash имен и значений, для которых блок возвращает истинное значение:

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

Возвращает Enumerator, если блок не предоставлен:

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

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.filter! является псевдонимом для ENV.select!.

Передает каждое имя переменной окружения и её значение в виде 2-элементного Array, удаляя каждую запись, для которой блок возвращает false или nil, и возвращая ENV, если были произведены какие-либо удаления, или nil в противном случае:

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

Возвращает Enumerator, если блок не предоставлен:

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

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

Вызывает исключение:

ENV.freeze # Raises TypeError (cannot freeze ENV)

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

ENV.has_key?, ENV.member?, и ENV.key? являются псевдонимами для ENV.include?.

Возвращает true, если существует переменная окружения с заданным name:

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

Возвращает false, если name является допустимым String, и такой переменной окружения нет:

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

Возвращает false, если name является пустой String или String, содержащей символ '=':

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

Вызывает исключение, если name является String, содержащим символ NUL "\0":

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

Вызывает исключение, если name имеет кодировку, не совместимую с ASCII:

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

Вызывает исключение, если name не является строкой:

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

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_LOCK();
    {
        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);
    }
    ENV_UNLOCK();

    return ret;
}

Возвращает true, если value является значением для некоторого имени переменной окружения, 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

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

ENV.has_key?, ENV.member?, и ENV.key? являются псевдонимами для ENV.include?.

Возвращает true, если существует переменная окружения с заданным name:

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

Возвращает false, если name является допустимым String, и такой переменной окружения нет:

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

Возвращает false, если name является пустой String или String, содержащей символ '=':

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

Вызывает исключение, если name является String, содержащим символ NUL "\0":

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

Вызывает исключение, если name имеет кодировку, не совместимую с ASCII:

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

Вызывает исключение, если name не является строкой:

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

static VALUE
env_inspect(VALUE _)
{
    VALUE i;
    VALUE str = rb_str_buf_new2("{");

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

            if (env != environ) {
                rb_str_buf_cat2(str, ", ");
            }
            if (s) {
                rb_str_buf_cat2(str, "\"");
                rb_str_buf_cat(str, *env, s-*env);
                rb_str_buf_cat2(str, "\"=>");
                i = rb_inspect(rb_str_new2(s+1));
                rb_str_buf_append(str, i);
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }
    ENV_UNLOCK();

    rb_str_buf_cat2(str, "}");

    return str;
}

Возвращает содержимое окружения в виде строки:

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

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

Возвращает Hash, ключи которого являются значениями ENV, а значения — соответствующими именами ENV:

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

Для дублирующегося значения ENV перезаписывает запись в хэше:

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

Обратите внимание, что порядок обработки ENV зависит от ОС, что означает, что порядок перезаписи также зависит от ОС. См. About Ordering.

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

Выводит имя и значение каждой переменной среды в виде 2-элементного Array, удаляя переменные среды, для которых блок возвращает false или nil, и возвращает ENV:

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

Возвращает Enumerator, если блок не задан:

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

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

    ENV_LOCK();
    {
        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);
                    break;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }
    ENV_UNLOCK();

    return str;
}

Возвращает имя первой переменной среды со значением value, если оно существует:

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

Порядок, в котором проверяются переменные среды, зависит от операционной системы. См. О порядке.

Возвращает nil если такого значения нет.

Вызывает исключение, если value является недопустимым:

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

См. Недопустимые имена и значения.

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

ENV.has_key?, ENV.member? и ENV.key? являются псевдонимами для ENV.include?.

Возвращает true , если существует переменная среды с заданным name:

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

Возвращает false , если name является допустимой String и такой переменной среды нет:

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

Возвращает false , если name является пустой String или является String, содержащей символ '=':

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

Вызывает исключение, если name является String, содержащей нулевой символ "\0":

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

Вызывает исключение, если name имеет кодировку, которая несовместима с ASCII:

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

Вызывает исключение, если name не является строкой:

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

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

Возвращает все имена переменных в массиве:

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

Порядок имен зависит от операционной системы. См. О порядке.

Возвращает пустой Array если ENV пустой.

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

Возвращает количество переменных среды:

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

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

ENV.has_key?, ENV.member? и ENV.key? являются псевдонимами для ENV.include?.

Возвращает true , если существует переменная среды с заданным name:

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

Возвращает false , если name является допустимой String и такой переменной среды нет:

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

Возвращает false , если name является пустой String или является String, содержащей символ '=':

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

Вызывает исключение, если name является String, содержащей нулевой символ "\0":

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

Вызывает исключение, если name имеет кодировку, несовместимую с ASCII:

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

Вызывает исключение, если name не является строкой:

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

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

ENV.update является псевдонимом для ENV.merge!.

Добавляет в ENV каждую пару ключ/значение из заданных hash; возвращает ENV:

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

Удаляет запись ENV для значения хэша, которое nil:

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

Для уже существующего имени, если блок не задан, перезаписывает значение ENV:

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

Для уже существующего имени, если блок задан, возвращает имя, его значение ENV и его значение в хэше; значение возвращаемое блоком становится новым именем:

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

Вызывает исключение, если имя или значение недопустимы (см. Недопустимые имена и значения);

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

Вызывает исключение, если блок возвращает недопустимое имя (см. Недопустимые имена и значения):

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

Обратите внимание, что для исключений выше, пары хэша, предшествующие недопустимому имени или значению, обрабатываются обычно; следующие игнорируются.

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

    VALUE result = Qnil;

    ENV_LOCK();
    {
        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);
    }
    ENV_UNLOCK();

    return result;
}

Возвращает 2-элементный Array, содержащий имя и значение первой найденной переменной среды, имеющей значение value, если она существует:

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

Порядок, в котором проверяются переменные среды, зависит от операционной системы. См. О порядке.

Возвращает nil если такой переменной среды нет.

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

(Предоставлено для совместимости с Hash.)

Не изменяет ENV; возвращает nil.

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

Выводит имя и значение каждой переменной среды в виде 2-элементного Array. Возвращает Hash элементы которого определяются блоком. Когда блок возвращает истинное значение, пара имя/значение добавляется к возвращаемому Hash; в противном случае пара игнорируется:

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

Возвращает Enumerator, если блок не задан:

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

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

Аналогично ENV.delete_if, но возвращает nil если изменений не было.

Передаёт имя и значение каждой переменной среды в виде 2-элементного Array, удаляя каждую переменную среды, для которой блок возвращает истинное значение, и возвращая ENV (если были удаления) или nil (если нет):

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

Возвращает Enumerator, если блок не задан:

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

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

Заменяет всё содержимое переменных среды парами имя/значение, заданными в данном hash; возвращает ENV.

Заменяет содержимое ENV заданными парами:

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

Вызывает исключение, если имя или значение некорректны (см. Некорректные имена и значения):

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

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

ENV.filter — псевдоним для ENV.select.

Передаёт имя и значение каждой переменной среды в виде 2-элементного Array, возвращая Hash имён и значений, для которых блок возвращает истинное значение:

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

Возвращает Enumerator, если блок не задан:

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

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.filter! — псевдоним для ENV.select!.

Передаёт имя и значение каждой переменной среды в виде 2-элементного Array, удаляя каждую запись, для которой блок возвращает false или nil, и возвращая ENV, если были удаления, или nil в противном случае:

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

Возвращает Enumerator, если блок не задан:

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

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

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

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

    return result;
}

Удаляет первую переменную среды из ENV и возвращает 2-элементный Array содержащий её имя и значение:

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

Точная переменная, которая является «первой», зависит от ОС. См. О порядке.

Возвращает nil если среда пуста.

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

Возвращает количество переменных среды:

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

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

Возвращает Hash заданных ENV имён и соответствующих им значений:

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

Вызывает исключение, если какое-либо из names некорректно (см. Некорректные имена и значения):

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

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

ENV.store — псевдоним для ENV.[]=.

Создаёт, обновляет или удаляет переменную среды с заданным именем, возвращая значение. И name, и value могут быть экземплярами String. См. Валидные имена и значения.

• Если переменная среды с заданным именем не существует:

  • Если value равно nil, ничего не делает.

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

  • Если value не равно nil, создаёт переменную среды со значением name и 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'
    

• Если переменная среды с заданным именем существует:

  • Если value не равно nil, обновляет переменную среды со значением 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'
    

  • Если value равно nil, удаляет переменную среды:

    # 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
    

Вызывает исключение, если name или value некорректно. См. Некорректные имена и значения.

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

    ENV_LOCK();
    {
        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),
                                              env_str_new2(s+1)));
            }
            env++;
        }
        FREE_ENVIRON(environ);
    }
    ENV_UNLOCK();

    return ary;
}

Возвращает содержимое ENV в виде Array 2-элементных массивов, каждый из которых представляет пару имя/значение:

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

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

Без блока, возвращает Hash содержащий все пары имя/значение из ENV:

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

С блоком, возвращает Hash, элементы которого определяются блоком. Каждая пара имя/значение в ENV передаётся в блок. Блок должен возвращать 2-элементный Array (пару имя/значение), который добавляется в возвращаемый Hash в качестве ключа и значения:

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

Вызывает исключение, если блок не возвращает массив:

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

Вызывает исключение, если блок возвращает Array неправильного размера:

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

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

Возвращает Hash содержащий все пары имя/значение из ENV:

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

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

Возвращает String ‘ENV’:

ENV.to_s # => "ENV"

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

ENV.update является псевдонимом для ENV.merge!.

Добавляет в ENV каждую пару «ключ/значение» из заданного hash; возвращает ENV:

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

Удаляет запись ENV для значения хэша, которое nil:

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

Для уже существующего имени, если блок не задан, перезаписывает значение ENV:

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

Для уже существующего имени, если блок задан, выводит имя, его значение ENV и его значение хэша; возвращаемое значение блока становится новым именем:

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

Вызывает исключение, если имя или значение некорректны (см. Некорректные имена и значения);

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

Вызывает исключение, если блок возвращает некорректное имя (см. Некорректные имена и значения):

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

Обратите внимание, что для исключений выше пары хэша, предшествующие некорректному имени или значению, обрабатываются нормально; последующие игнорируются.

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_LOCK();
    {
        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);
    }
    ENV_UNLOCK();

    return ret;
}

Возвращает true если value является значением для некоторого имени переменной среды, 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

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

Возвращает все значения переменных среды в массиве:

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

Порядок значений зависит от ОС. См. Об упорядочивании.

Возвращает пустой Array если ENV пуст.

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

Возвращает Array, содержащий значения переменных среды, соответствующие заданным именам:

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

Возвращает nil в Array для каждого имени, которое не является именем ENV:

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

Возвращает пустой массив, если имена не заданы.

Вызывает исключение, если какое-либо имя некорректно. См. Некорректные имена и значения.