ENV 類別

ENV 是環境變數的類哈希存取器。

與作業系統互動¶ ↑

ENV 物件會與作業系統的環境變數互動

當您在 ENV 中取得名稱的值時，會從目前的環境變數中擷取該值。
當您在 ENV 中建立或設定名稱/值配對時，該名稱和值會立即設定在環境變數中。
當您在 ENV 中刪除名稱/值配對時，會立即從環境變數中刪除該配對。

名稱和值¶ ↑

一般來說，名稱或值是 字串。

有效的名稱和值¶ ↑

每個名稱或值必須符合下列其中一項

一個 字串。
一個物件，它會回應 #to_str 並傳回一個 字串，在這種情況下，該 字串 會用作名稱或值。

無效的名稱和值¶ ↑

一個新名稱

不能是空字串

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

不能包含字元 "="

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

一個新名稱或值

不能是非字串且不會回應 #to_str

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)

不能包含 NUL 字元 "\0"

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

不能有與 ASCII 不相容的編碼，例如 UTF-16LE 或 ISO-2022-JP

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 會以作業系統環境變數中找到的順序列舉其名稱/值配對。因此，ENV 內容的排序取決於作業系統，且可能不確定。

這將會顯示在

由 ENV 方法傳回的 Hash。
由 ENV 方法傳回的 Enumerator。
由 ENV.keys、ENV.values 或 ENV.to_a 傳回的 Array。
由 ENV.inspect 傳回的 String。
由 ENV.shift 傳回的 Array。
由 ENV.key 傳回的名稱。

關於範例¶ ↑

ENV 中的某些方法會傳回 ENV 本身。一般來說，環境變數很多。在這裡的範例中顯示大型 ENV 沒有用，因此大多數範例片段會從重設 ENV 的內容開始

ENV.replace 會以新的項目集合取代 ENV。
ENV.clear 會清空 ENV。

這裡有什麼¶ ↑

首先，在其他地方是什麼。類別 ENV

繼承自類別 Object。
延伸模組 Enumerable，

在此，類別 ENV 提供對以下事項有用的方法

查詢的方法¶ ↑

::[]：如果存在，傳回給定環境變數名稱的值
::empty?：傳回 ENV 是否為空。
::has_value?、::value?：傳回給定的值是否在 ENV 中。
::include?、::has_key?、::key?、::member?：傳回給定的名稱是否在 ENV 中。
::key：傳回具有給定值的第 1 個項目的名稱。
::size、::length：傳回項目的數量。
::value?：傳回是否有任何項目具有給定的值。

指定的方法¶ ↑

::[]=、::store：建立、更新或刪除指定的環境變數。
::clear：移除每個環境變數；傳回 ENV
::update、::merge!：將給定雜湊中的每個金鑰/值對新增至 ENV。
::replace：以給定雜湊中的名稱/值對取代 ENV 的全部內容。

刪除的方法¶ ↑

::delete：如果存在，刪除指定的環境變數名稱。
::delete_if：刪除由區塊選取的項目。
::keep_if：刪除未由區塊選取的項目。
::reject!：類似於 delete_if，但如果沒有任何變更，則傳回 nil。
::select!、::filter!：刪除由區塊選取的項目。
::shift：移除並傳回第一個項目。

反覆運算的方法¶ ↑

::each、::each_pair：使用每個名稱/值對呼叫區塊。
::each_key：使用每個名稱呼叫區塊。
::each_value：使用每個值呼叫區塊。

轉換的方法¶ ↑

::assoc：如果命名環境變數存在，則傳回包含名稱和值的 2 元素陣列
::clone：傳回 ENV（並發出警告）。
::except：傳回一個雜湊，其中包含除了給定名稱/值對之外的所有名稱/值對。
::fetch：傳回給定名稱的值。
::inspect：傳回 ENV 的內容，格式為字串。
::invert：傳回一個雜湊，其鍵為 ENV 值，其值為對應的 ENV 名稱。
::keys：傳回所有名稱的陣列。
::rassoc：傳回第一個具有給定值的已找到項目的名稱和值。
::reject：傳回一個雜湊，其中包含未被區塊拒絕的那些項目。
::select、::filter：傳回由區塊選取的名稱/值對雜湊。
::slice：傳回給定名稱及其對應值的雜湊。
::to_a：傳回項目，格式為 2 元素陣列的陣列。
::to_h：傳回由區塊選取的項目的雜湊。
::to_hash：傳回所有項目的雜湊。
::to_s：傳回字串 'ENV'。
::values：傳回所有值，格式為陣列。
::values_at：傳回給定名稱的值陣列。

公開類別方法

ENV[name] → value 按一下以切換來源

如果環境變數 name 存在，傳回其值

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

如果命名變數不存在，傳回 nil。

如果 name 無效，引發例外狀況。請參閱無效名稱和值。

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

ENV[name] = value → value 按一下以切換來源

store(name, value) → value

建立、更新或刪除命名環境變數，並傳回該值。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_aset_m(VALUE obj, VALUE nm, VALUE val)
{
    return env_aset(nm, val);
}

assoc(name) → [name, value] or nil 按一下以切換來源

如果環境變數 name 存在，傳回包含環境變數名稱和值的 2 元素 Array

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

如果 name 是有效的 String，但沒有此環境變數，則傳回 nil。

如果 name 是空的 String 或包含字元 '=' 的 String，則傳回 nil。

如果 name 是包含 NUL 字元 "\0" 的 String，則會引發例外狀況

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

clear → ENV 按一下以切換來源

移除所有環境變數；傳回 ENV

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

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

clone(freeze: nil) # 引發 TypeError 按一下以切換來源

引發 TypeError，因為 ENV 是處理環境變數的包裝器，而複製是沒有用的。使用 to_h 取得 ENV 資料的複本，作為雜湊。

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

delete(name) → value 按一下以切換來源

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

delete(missing_name) → nil

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

如果環境變數存在，則刪除具有 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 無效，引發例外狀況。請參閱無效名稱和值。

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

delete_if { |name, value| block } → ENV 按一下以切換來源

delete_if → an_enumerator

傳遞每個環境變數名稱及其值，作為 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_delete_if(VALUE ehash)
{
    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    env_reject_bang(ehash);
    return envtbl;
}

dup # 引發 TypeError 按一下以切換來源

引發 TypeError，因為 ENV 是單例物件。使用 to_h 取得 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");
}

each { |name, value| block } → ENV 按一下以切換來源

each → an_enumerator

each_pair { |name, value| block } → ENV

each_pair → an_enumerator

傳回每個環境變數名稱及其值，作為 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_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;
}

each_key { |name| block } → ENV 按一下以切換來源

each_key → an_enumerator

傳回每個環境變數名稱

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

each { |name, value| block } → ENV 按一下以切換來源

each → an_enumerator

each_pair { |name, value| block } → ENV

each_pair → an_enumerator

傳回每個環境變數名稱及其值，作為 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_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;
}

each_value { |value| block } → ENV 按一下以切換來源

each_value → an_enumerator

傳回每個環境變數值

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

empty? → true 或 false 按一下以切換來源

如果沒有環境變數，傳回 true，否則傳回 false

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

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

except(*keys) → a_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_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;
}

fetch(name) → value 按一下以切換來源

fetch(name, default) → value

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

如果 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

如果環境變數不存在，而且同時指定預設值和區塊，會發出警告（「警告：區塊取代預設值引數」），將 name 傳回區塊，並傳回區塊的傳回值

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

如果 name 有效，但找不到，而且未指定預設值或區塊，會引發 KeyError

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

如果 name 無效，引發例外狀況。請參閱無效名稱和值。

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

select { |name, value| block } → 名稱/值配對雜湊按一下以切換來源

select → an_enumerator

filter { |name, value| block } → 名稱/值配對雜湊

filter → an_enumerator

傳回每個環境變數名稱及其值，作為 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(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;
}

select! { |name, value| block } → ENV 或 nil 按一下以切換來源

select! → an_enumerator

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

filter! → an_enumerator

傳回每個環境變數名稱及其值，作為 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_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;
}

freeze 按一下以切換來源

引發例外

ENV.freeze # Raises TypeError (cannot freeze ENV)

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

include?(name) → true 或 false 按一下以切換來源

has_key?(name) → true 或 false

member?(name) → true 或 false

key?(name) → true 或 false

如果給定的 name 具有環境變數，則傳回 true

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

如果 name 是有效的 String 且沒有此類環境變數，則傳回 false

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

如果 name 是空的 String 或包含字元 '=' 的 String，則傳回 false

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

如果 name 是包含 NUL 字元 "\0" 的 String，則會引發例外狀況

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_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

value?(value) → true 或 false 按一下以切換來源

has_value?(value) → true 或 false

如果 value 是某些環境變數名稱的值，則傳回 true，否則傳回 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_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;
}

include?(name) → true 或 false 按一下以切換來源

has_key?(name) → true 或 false

member?(name) → true 或 false

key?(name) → true 或 false

如果給定的 name 具有環境變數，則傳回 true

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

如果 name 是有效的 String 且沒有此類環境變數，則傳回 false

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

如果 name 是空的 String 或包含字元 '=' 的 String，則傳回 false

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

如果 name 是包含 NUL 字元 "\0" 的 String，則會引發例外狀況

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_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

inspect → 字串按一下以切換來源

傳回環境的內容作為字串

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

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

invert → 值/名稱配對的雜湊按一下以切換來源

傳回 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 處理的順序取決於作業系統，這表示覆寫的順序也取決於作業系統。請參閱關於排序。

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

keep_if { |name, value| block } → ENV 按一下以切換來源

keep_if → 枚舉器

產生每個環境變數名稱及其值作為 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_keep_if(VALUE ehash)
{
    RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
    env_select_bang(ehash);
    return envtbl;
}

key(value) → 名稱或 nil 按一下以切換來源

如果存在，則傳回具有 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_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;
}

include?(name) → true 或 false 按一下以切換來源

has_key?(name) → true 或 false

member?(name) → true 或 false

key?(name) → true 或 false

如果給定的 name 具有環境變數，則傳回 true

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

如果 name 是有效的 String 且沒有此類環境變數，則傳回 false

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

如果 name 是空的 String 或包含字元 '=' 的 String，則傳回 false

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

如果 name 是包含 NUL 字元 "\0" 的 String，則會引發例外狀況

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_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

keys → 名稱陣列按一下以切換來源

傳回陣列中所有變數名稱

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

名稱的順序取決於作業系統。請參閱關於排序。

如果 ENV 為空，則傳回空的 Array。

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

length → 整數按一下以切換來源

size → 整數

傳回環境變數的計數

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

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

include?(name) → true 或 false 按一下以切換來源

has_key?(name) → true 或 false

member?(name) → true 或 false

key?(name) → true 或 false

如果給定的 name 具有環境變數，則傳回 true

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

如果 name 是有效的 String 且沒有此類環境變數，則傳回 false

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

如果 name 是空的 String 或包含字元 '=' 的 String，則傳回 false

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

如果 name 是包含 NUL 字元 "\0" 的 String，則會引發例外狀況

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_key(VALUE env, VALUE key)
{
    const char *s = env_name(key);
    return RBOOL(has_env_with_lock(s));
}

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

將指定 hash 中的每個金鑰/值對新增至 ENV；傳回 ENV

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

刪除值為 nil 的 ENV 項目

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

對於已存在的名稱，如果未指定區塊，則覆寫 ENV 值

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

對於已存在的名稱，如果指定區塊，則產生名稱、其 ENV 值和其 hash 值；區塊的傳回值會成為新的名稱

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

請注意，對於上述例外，在無效名稱或值之前的 hash 對會正常處理；在之後的則會被忽略。

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

rassoc(value) → [name, value] 或 nil 按一下以切換來源

傳回一個包含名稱和值（如果存在）的 2 元素 Array，該環境變數是 第一個 找到的值為 value 的環境變數

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

檢查環境變數的順序取決於作業系統。請參閱關於排序。

如果沒有此類環境變數，則傳回 nil。

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

rehash → nil 按一下以切換來源

（提供與 Hash 相容性。）

不修改 ENV；傳回 nil。

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

reject { |name, value| block } → 名稱/值對的 hash 按一下以切換來源

reject → enumerator

產生每個環境變數名稱及其值，作為 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(VALUE _)
{
    return rb_hash_delete_if(env_to_hash());
}

reject! { |name, value| block } → ENV 或 nil 按一下以切換來源

reject! → enumerator

類似於 ENV.delete_if，但如果沒有任何變更，則會傳回 nil。

傳回每個環境變數名稱及其值，作為 2 元素的 陣列，刪除區塊傳回真值的每個環境變數，並傳回 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_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;
}

replace(hash) → 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_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;
}

select { |name, value| block } → 名稱/值配對雜湊按一下以切換來源

select → an_enumerator

filter { |name, value| block } → 名稱/值配對雜湊

filter → an_enumerator

傳回每個環境變數名稱及其值，作為 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(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;
}

select! { |name, value| block } → ENV 或 nil 按一下以切換來源

select! → an_enumerator

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

filter! → an_enumerator

傳回每個環境變數名稱及其值，作為 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_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;
}

shift → [name, value] 或 nil 按一下以切換來源

從 ENV 中移除第一個環境變數，並傳回包含其名稱和值的 2 元素 陣列

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

length → 整數按一下以切換來源

size → 整數

傳回環境變數的計數

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

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

slice(*names) → 名稱/值對的 hash 按一下以切換來源

傳回給定 ENV 名稱及其對應值的 Hash

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

ENV[name] = value → value 按一下以切換來源

store(name, value) → value

建立、更新或刪除命名環境變數，並傳回該值。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_aset_m(VALUE obj, VALUE nm, VALUE val)
{
    return env_aset(nm, val);
}

to_a → 2 元素陣列的陣列按一下以切換來源

將 ENV 的內容傳回為 2 元素陣列的 陣列，每個陣列都是名稱/值對

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

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

to_h → 名稱/值對的 hash 按一下以切換來源

to_h {|name, value| block } → 名稱/值對的 hash

如果沒有區塊，則傳回包含來自 ENV 的所有名稱/值對的 Hash

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

如果有一個區塊，則傳回其項目由區塊決定的 Hash。每個 ENV 中的名稱/值對都會傳遞給區塊。區塊必須傳回 2 元素 陣列（名稱/值對），該陣列會新增至傳回的 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))

如果區塊傳回大小錯誤的 陣列，則會引發例外

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

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

to_hash → 名稱/值對的 hash 按一下以切換來源

傳回包含所有 ENV 名稱/值配對的 Hash

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

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

to_s → "ENV" 按一下以切換來源

傳回 String ‘ENV’

ENV.to_s # => "ENV"

static VALUE
env_to_s(VALUE _)
{
    return rb_usascii_str_new2("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

將指定 hash 中的每個金鑰/值對新增至 ENV；傳回 ENV

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

刪除值為 nil 的 ENV 項目

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

對於已存在的名稱，如果未指定區塊，則覆寫 ENV 值

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

對於已存在的名稱，如果指定區塊，則產生名稱、其 ENV 值和其 hash 值；區塊的傳回值會成為新的名稱

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

請注意，對於上述例外，在無效名稱或值之前的 hash 對會正常處理；在之後的則會被忽略。

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

value?(value) → true 或 false 按一下以切換來源

has_value?(value) → true 或 false

如果 value 是某些環境變數名稱的值，則傳回 true，否則傳回 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_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;
}

values → 值陣列按一下以切換來源

傳回陣列中的所有環境變數值

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

值的順序取決於作業系統。請參閱關於順序。

如果 ENV 為空，則傳回空的 Array。

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

values_at(*names) → 值陣列按一下以切換來源

傳回包含與給定名稱相關聯的環境變數值的 Array

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

對於每個不是 ENV 名稱的名稱，在 Array 中傳回 nil

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

如果沒有給定名稱，則傳回空的 Array。

如果任何名稱無效，則會引發例外。請參閱無效名稱和值。

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

ENV 類別

與作業系統互動¶ ↑

名稱和值¶ ↑

有效的名稱和值¶ ↑

無效的名稱和值¶ ↑

關於排序¶ ↑

關於範例¶ ↑

這裡有什麼¶ ↑

查詢的方法¶ ↑

指定的方法¶ ↑

刪除的方法¶ ↑

反覆運算的方法¶ ↑

轉換的方法¶ ↑

更多方法¶ ↑