class ENV

Parent:: Object

ENV представляет собой доступ к переменным окружения, похожий на хеш.

Публичные методы класса

ENV[name] → value Show source

static VALUE
rb_f_getenv(VALUE obj, VALUE name)
{
    const char *nam, *env;

    nam = env_name(name);
    env = getenv(nam);
    if (env) {
        return env_name_new(nam, env);
    }
    return Qnil;
}

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

ENV[name] = value Show source

static VALUE
env_aset(VALUE obj, VALUE nm, VALUE val)
{
    char *name, *value;

    if (NIL_P(val)) {
        env_delete(obj, nm);
        return Qnil;
    }
    SafeStringValue(nm);
    SafeStringValue(val);
    /* nm can be modified in `val.to_str`, don't get `name` before
     * check for `val` */
    get_env_ptr(name, nm);
    get_env_ptr(value, val);

    ruby_setenv(name, value);
    if (ENVMATCH(name, PATH_ENV)) {
        RB_GC_GUARD(nm);
        if (OBJ_TAINTED(val)) {
            /* already tainted, no check */
            path_tainted = 1;
            return val;
        }
        else {
            path_tainted_p(value);
        }
    }
    else if (ENVMATCH(name, TZ_ENV)) {
        ruby_tz_uptodate_p = FALSE;
    }
    return val;
}

Устанавливает переменную окружения name в value. Если заданное значение равно nil, переменная окружения удаляется. name должно быть строкой.

assoc(name) → Array or nil Show source

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

    s = env_name(key);
    e = getenv(s);
    if (e) return rb_assoc_new(key, env_str_new2(e));
    return Qnil;
}

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

clear Show source

VALUE
rb_env_clear(void)
{
    VALUE keys;
    long i;

    keys = env_keys();
    for (i=0; i<RARRAY_LEN(keys); i++) {
        VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
        if (!NIL_P(val)) {
            env_delete(Qnil, RARRAY_AREF(keys, i));
        }
    }
    RB_GC_GUARD(keys);
    return envtbl;
}

Удаляет все переменные окружения.

delete(name) → value Show source

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

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

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

Удаляет переменную окружения с name и возвращает значение переменной. Если задан блок, он будет вызван, когда переменная окружения с указанным именем не существует.

delete_if { |name, value| block } → Hash Show source

delete_if → Enumerator

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

Удаляет все переменные окружения, для которых блок возвращает true.

Если блок не задан, вместо этого возвращается перечислитель.

each { |name, value| block } → Hash Show source

each → Enumerator

each_pair { |name, value| block } → Hash

each_pair → Enumerator

static VALUE
env_each_pair(VALUE ehash)
{
    char **env;
    VALUE ary;
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

    ary = rb_ary_new();
    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);

    if (rb_block_arity() > 1) {
        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;
}

Возвращает каждую переменную окружения name и value.

Если блок не задан, возвращается Enumerator.

each_key { |name| block } → Hash Show source

each_key → Enumerator

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

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

Возвращает имя каждой переменной окружения.

Если блок не задан, возвращается Enumerator.

each_pair { |name, value| block } → Hash Show source

each_pair → Enumerator

static VALUE
env_each_pair(VALUE ehash)
{
    char **env;
    VALUE ary;
    long i;

    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

    ary = rb_ary_new();
    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);

    if (rb_block_arity() > 1) {
        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;
}

Возвращает каждую переменную окружения name и value.

Если блок не задан, возвращается Enumerator.

each_value { |value| block } → Hash Show source

each_value → Enumerator

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

Возвращает значение каждой переменной окружения value.

Если блок не задан, возвращается Enumerator.

empty? → true or false Show source

static VALUE
env_empty_p(void)
{
    char **env;

    env = GET_ENVIRON(environ);
    if (env[0] == 0) {
        FREE_ENVIRON(environ);
        return Qtrue;
    }
    FREE_ENVIRON(environ);
    return Qfalse;
}

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

fetch(name) → value Show source

fetch(name, default) → value

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

static VALUE
env_fetch(int argc, VALUE *argv)
{
    VALUE key;
    long block_given;
    const char *nam, *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(nam);
    if (!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_new(nam, env);
}

Извлекает переменную окружения name.

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

filter { |name, value| block } → Hash Show source

filter → Enumerator

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

Возвращает копию окружения для записей, где блок возвращает true.

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

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

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

filter! → Enumerator

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();
    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))) {
                FL_UNSET(RARRAY_AREF(keys, i), FL_TAINT);
                env_delete(Qnil, RARRAY_AREF(keys, i));
                del++;
            }
        }
    }
    RB_GC_GUARD(keys);
    if (del == 0) return Qnil;
    return envtbl;
}

Эквивалентно ENV.keep_if, но возвращает nil, если изменений не было.

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

has_key?(name) → true or false Show source

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s;

    s = env_name(key);
    if (getenv(s)) return Qtrue;
    return Qfalse;
}

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

has_value?(value) → true or false Show source

static VALUE
env_has_value(VALUE dmy, VALUE obj)
{
    char **env;

    obj = rb_check_string_type(obj);
    if (NIL_P(obj)) return Qnil;
    rb_check_safe_obj(obj);
    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) {
                FREE_ENVIRON(environ);
                return Qtrue;
            }
        }
        env++;
    }
    FREE_ENVIRON(environ);
    return Qfalse;
}

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

include?(name) → true or false Show source

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s;

    s = env_name(key);
    if (getenv(s)) return Qtrue;
    return Qfalse;
}

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

index(value) → key Show source

static VALUE
env_index(VALUE dmy, VALUE value)
{
    rb_warn("ENV.index is deprecated; use ENV.key");
    return env_key(dmy, value);
}

Устаревший метод, эквивалентный ENV.key

inspect → string Show source

static VALUE
env_inspect(void)
{
    char **env;
    VALUE str, i;

    str = rb_str_buf_new2("{");
    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);
    rb_str_buf_cat2(str, "}");
    OBJ_TAINT(str);

    return str;
}

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

invert → Hash Show source

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

Возвращает новый хеш, созданный с использованием имен переменных окружения в качестве значений и значений в качестве имен.

keep_if { |name, value| block } → Hash Показать исходный код

keep_if → Enumerator

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

Удаляет каждую переменную среды, где блок вычисляется в false.

Возвращает перечислитель, если блок не был задан.

key(value) → name Показать исходный код

static VALUE
env_key(VALUE dmy, VALUE value)
{
    char **env;
    VALUE str;

    SafeStringValue(value);
    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);
                FREE_ENVIRON(environ);
                return str;
            }
        }
        env++;
    }
    FREE_ENVIRON(environ);
    return Qnil;
}

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

key?(name) → true or false Показать исходный код

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s;

    s = env_name(key);
    if (getenv(s)) return Qtrue;
    return Qfalse;
}

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

keys → Array Показать исходный код

static VALUE
env_keys(void)
{
    char **env;
    VALUE ary;

    ary = rb_ary_new();
    env = GET_ENVIRON(environ);
    while (*env) {
        char *s = strchr(*env, '=');
        if (s) {
            rb_ary_push(ary, env_str_new(*env, s-*env));
        }
        env++;
    }
    FREE_ENVIRON(environ);
    return ary;
}

Возвращает каждое имя переменной среды в Array

length Показать исходный код

static VALUE
env_size(void)
{
    int i;
    char **env;

    env = GET_ENVIRON(environ);
    for (i=0; env[i]; i++)
        ;
    FREE_ENVIRON(environ);
    return INT2FIX(i);
}

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

member?(name) → true or false Показать исходный код

static VALUE
env_has_key(VALUE env, VALUE key)
{
    const char *s;

    s = env_name(key);
    if (getenv(s)) return Qtrue;
    return Qfalse;
}

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

rassoc(value) Показать исходный код

static VALUE
env_rassoc(VALUE dmy, VALUE obj)
{
    char **env;

    obj = rb_check_string_type(obj);
    if (NIL_P(obj)) return Qnil;
    rb_check_safe_obj(obj);
    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) {
                VALUE result = rb_assoc_new(rb_tainted_str_new(*env, s-*env-1), obj);
                FREE_ENVIRON(environ);
                return result;
            }
        }
        env++;
    }
    FREE_ENVIRON(environ);
    return Qnil;
}

Возвращает Array имени и значения переменной среды с value или nil, если значение не может быть найдено.

rehash Показать исходный код

static VALUE
env_none(void)
{
    return Qnil;
}

Перехэширование переменных среды ничего не делает. Оно предоставлено для совместимости с Hash.

reject { |name, value| block } → Hash Показать исходный код

reject → Enumerator

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

То же самое, что и ENV.delete_if, но работает с (и возвращает) копией среды.

reject! { |name, value| block } → ENV or nil Показать исходный код

reject! → Enumerator

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();
    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))) {
                FL_UNSET(RARRAY_AREF(keys, i), FL_TAINT);
                env_delete(Qnil, RARRAY_AREF(keys, i));
                del++;
            }
        }
    }
    RB_GC_GUARD(keys);
    if (del == 0) return Qnil;
    return envtbl;
}

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

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

replace(hash) → env Показать исходный код

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

    keys = env_keys();
    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(env, RARRAY_AREF(keys, i));
    }
    RB_GC_GUARD(keys);
    return env;
}

Заменяет содержимое переменных среды содержимым hash.

select { |name, value| block } → Hash Показать исходный код

select → Enumerator

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

Возвращает копию среды для записей, где блок возвращает true.

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

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

select! { |name, value| block } → ENV or nil Показать исходный код

select! → Enumerator

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();
    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))) {
                FL_UNSET(RARRAY_AREF(keys, i), FL_TAINT);
                env_delete(Qnil, RARRAY_AREF(keys, i));
                del++;
            }
        }
    }
    RB_GC_GUARD(keys);
    if (del == 0) return Qnil;
    return envtbl;
}

Эквивалентно ENV.keep_if, но возвращает nil, если изменений не было.

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

shift → Array or nil Показать исходный код

static VALUE
env_shift(void)
{
    char **env;
    VALUE result = Qnil;

    env = GET_ENVIRON(environ);
    if (*env) {
        char *s = strchr(*env, '=');
        if (s) {
            VALUE key = env_str_new(*env, s-*env);
            VALUE val = env_str_new2(getenv(RSTRING_PTR(key)));
            env_delete(Qnil, key);
            result = rb_assoc_new(key, val);
        }
    }
    FREE_ENVIRON(environ);
    return result;
}

Удаляет пару имя-значение переменной среды из ENV и возвращает её как Array. Возвращает nil, если среда пуста.

size Показать исходный код

static VALUE
env_size(void)
{
    int i;
    char **env;

    env = GET_ENVIRON(environ);
    for (i=0; env[i]; i++)
        ;
    FREE_ENVIRON(environ);
    return INT2FIX(i);
}

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

slice(*keys) → a_hash Показать исходный код

static VALUE
env_slice(int argc, VALUE *argv)
{
    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;
}

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

ENV.slice("TERM","HOME")  #=> {"TERM"=>"xterm-256color", "HOME"=>"/Users/rhc"}

store(name, value) → value Показать исходный код

static VALUE
env_aset(VALUE obj, VALUE nm, VALUE val)
{
    char *name, *value;

    if (NIL_P(val)) {
        env_delete(obj, nm);
        return Qnil;
    }
    SafeStringValue(nm);
    SafeStringValue(val);
    /* nm can be modified in `val.to_str`, don't get `name` before
     * check for `val` */
    get_env_ptr(name, nm);
    get_env_ptr(value, val);

    ruby_setenv(name, value);
    if (ENVMATCH(name, PATH_ENV)) {
        RB_GC_GUARD(nm);
        if (OBJ_TAINTED(val)) {
            /* already tainted, no check */
            path_tainted = 1;
            return val;
        }
        else {
            path_tainted_p(value);
        }
    }
    else if (ENVMATCH(name, TZ_ENV)) {
        ruby_tz_uptodate_p = FALSE;
    }
    return val;
}

Устанавливает переменную среды name в value. Если заданное значение равно nil, переменная среды удаляется. name должно быть строкой.

to_a → Array Показать исходный код

static VALUE
env_to_a(void)
{
    char **env;
    VALUE ary;

    ary = rb_ary_new();
    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);
    return ary;
}

Преобразует переменные среды в массив массивов имён и значений.

ENV.to_a # => [["TERM", "xterm-color"], ["SHELL", "/bin/bash"], ...]

to_h → hash Показать исходный код

to_h {|name, value| block } → hash

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

Создаёт хэш с копией переменных среды.

to_hash → hash Показать исходный код

static VALUE
env_to_hash(void)
{
    char **env;
    VALUE hash;

    hash = rb_hash_new();
    env = GET_ENVIRON(environ);
    while (*env) {
        char *s = strchr(*env, '=');
        if (s) {
            rb_hash_aset(hash, env_str_new(*env, s-*env),
                               env_str_new2(s+1));
        }
        env++;
    }
    FREE_ENVIRON(environ);
    return hash;
}

Создаёт хэш с копией переменных среды.

to_s → "ENV" Показать исходный код

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

Возвращает “ENV”

update(hash) → Hash Показать исходный код

update(hash) { |name, old_value, new_value| block } → Hash

static VALUE
env_update(VALUE env, VALUE hash)
{
    if (env == hash) return env;
    hash = to_hash(hash);
    rb_hash_foreach(hash, env_update_i, 0);
    return env;
}

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

value?(value) → true or false Показать исходный код

static VALUE
env_has_value(VALUE dmy, VALUE obj)
{
    char **env;

    obj = rb_check_string_type(obj);
    if (NIL_P(obj)) return Qnil;
    rb_check_safe_obj(obj);
    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) {
                FREE_ENVIRON(environ);
                return Qtrue;
            }
        }
        env++;
    }
    FREE_ENVIRON(environ);
    return Qfalse;
}

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

values → Массив Показать исходный код

static VALUE
env_values(void)
{
    VALUE ary;
    char **env;

    ary = rb_ary_new();
    env = GET_ENVIRON(environ);
    while (*env) {
        char *s = strchr(*env, '=');
        if (s) {
            rb_ary_push(ary, env_str_new2(s+1));
        }
        env++;
    }
    FREE_ENVIRON(environ);
    return ary;
}

Возвращает значение каждой переменной среды в виде Array.

values_at(name, ...) → Массив Показать исходный код

static VALUE
env_values_at(int argc, VALUE *argv)
{
    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;
}

Возвращает массив, содержащий значения переменных среды, соответствующие заданным именам. См. также ENV.select.

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.