File: C:/Ruby27-x64/share/doc/ruby/html/ENV.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class ENV - RDoc Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "./";
var index_rel_prefix = "./";
</script>
<script src="./js/navigation.js" defer></script>
<script src="./js/search.js" defer></script>
<script src="./js/search_index.js" defer></script>
<script src="./js/searcher.js" defer></script>
<script src="./js/darkfish.js" defer></script>
<link href="./css/fonts.css" rel="stylesheet">
<link href="./css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="class">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="./index.html" rel="home">Home</a>
</h2>
<div id="table-of-contents-navigation">
<a href="./table_of_contents.html#pages">Pages</a>
<a href="./table_of_contents.html#classes">Classes</a>
<a href="./table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="search-field-wrapper">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div class="nav-section">
<h3>Table of Contents</h3>
<ul class="link-list" role="directory">
<li><a href="#class-ENV-label-Interaction+with+the+Operating+System">Interaction with the Operating System</a>
<li><a href="#class-ENV-label-Names+and+Values">Names and Values</a>
<li><a href="#class-ENV-label-Valid+Names+and+Values">Valid Names and Values</a>
<li><a href="#class-ENV-label-Invalid+Names+and+Values">Invalid Names and Values</a>
<li><a href="#class-ENV-label-About+Ordering">About Ordering</a>
<li><a href="#class-ENV-label-About+the+Examples">About the Examples</a>
</ul>
</div>
<div id="class-metadata">
<div id="parent-class-section" class="nav-section">
<h3>Parent</h3>
<p class="link"><a href="Object.html">Object</a>
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-c-5B-5D">::[]</a>
<li ><a href="#method-c-5B-5D-3D">::[]=</a>
<li ><a href="#method-c-assoc">::assoc</a>
<li ><a href="#method-c-clear">::clear</a>
<li ><a href="#method-c-delete">::delete</a>
<li ><a href="#method-c-delete_if">::delete_if</a>
<li ><a href="#method-c-each">::each</a>
<li ><a href="#method-c-each_key">::each_key</a>
<li ><a href="#method-c-each_pair">::each_pair</a>
<li ><a href="#method-c-each_value">::each_value</a>
<li ><a href="#method-c-empty-3F">::empty?</a>
<li ><a href="#method-c-fetch">::fetch</a>
<li ><a href="#method-c-filter">::filter</a>
<li ><a href="#method-c-filter-21">::filter!</a>
<li ><a href="#method-c-freeze">::freeze</a>
<li ><a href="#method-c-has_key-3F">::has_key?</a>
<li ><a href="#method-c-has_value-3F">::has_value?</a>
<li ><a href="#method-c-include-3F">::include?</a>
<li ><a href="#method-c-index">::index</a>
<li ><a href="#method-c-inspect">::inspect</a>
<li ><a href="#method-c-invert">::invert</a>
<li ><a href="#method-c-keep_if">::keep_if</a>
<li ><a href="#method-c-key">::key</a>
<li ><a href="#method-c-key-3F">::key?</a>
<li ><a href="#method-c-keys">::keys</a>
<li ><a href="#method-c-length">::length</a>
<li ><a href="#method-c-member-3F">::member?</a>
<li ><a href="#method-c-merge-21">::merge!</a>
<li ><a href="#method-c-rassoc">::rassoc</a>
<li ><a href="#method-c-rehash">::rehash</a>
<li ><a href="#method-c-reject">::reject</a>
<li ><a href="#method-c-reject-21">::reject!</a>
<li ><a href="#method-c-replace">::replace</a>
<li ><a href="#method-c-select">::select</a>
<li ><a href="#method-c-select-21">::select!</a>
<li ><a href="#method-c-shift">::shift</a>
<li ><a href="#method-c-size">::size</a>
<li ><a href="#method-c-slice">::slice</a>
<li ><a href="#method-c-store">::store</a>
<li ><a href="#method-c-to_a">::to_a</a>
<li ><a href="#method-c-to_h">::to_h</a>
<li ><a href="#method-c-to_hash">::to_hash</a>
<li ><a href="#method-c-to_s">::to_s</a>
<li ><a href="#method-c-update">::update</a>
<li ><a href="#method-c-value-3F">::value?</a>
<li ><a href="#method-c-values">::values</a>
<li ><a href="#method-c-values_at">::values_at</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-ENV">
<h1 id="class-ENV" class="class">
class ENV
</h1>
<section class="description">
<p><a href="ENV.html"><code>ENV</code></a> is a hash-like accessor for environment variables.</p>
<h3 id="class-ENV-label-Interaction+with+the+Operating+System">Interaction with the Operating System<span><a href="#class-ENV-label-Interaction+with+the+Operating+System">¶</a> <a href="#top">↑</a></span></h3>
<p>The <a href="ENV.html"><code>ENV</code></a> object interacts with the operating system's environment variables:</p>
<ul><li>
<p>When you get the value for a name in <a href="ENV.html"><code>ENV</code></a>, the value is retrieved from among the current environment variables.</p>
</li><li>
<p>When you create or set a name-value pair in <a href="ENV.html"><code>ENV</code></a>, the name and value are immediately set in the environment variables.</p>
</li><li>
<p>When you delete a name-value pair in <a href="ENV.html"><code>ENV</code></a>, it is immediately deleted from the environment variables.</p>
</li></ul>
<h3 id="class-ENV-label-Names+and+Values">Names and Values<span><a href="#class-ENV-label-Names+and+Values">¶</a> <a href="#top">↑</a></span></h3>
<p>Generally, a name or value is a <a href="String.html"><code>String</code></a>.</p>
<h4 id="class-ENV-label-Valid+Names+and+Values">Valid Names and Values<span><a href="#class-ENV-label-Valid+Names+and+Values">¶</a> <a href="#top">↑</a></span></h4>
<p>Each name or value must be one of the following:</p>
<ul><li>
<p>A <a href="String.html"><code>String</code></a>.</p>
</li><li>
<p>An object that responds to #to_str by returning a <a href="String.html"><code>String</code></a>, in which case that <a href="String.html"><code>String</code></a> will be used as the name or value.</p>
</li></ul>
<h4 id="class-ENV-label-Invalid+Names+and+Values">Invalid Names and Values<span><a href="#class-ENV-label-Invalid+Names+and+Values">¶</a> <a href="#top">↑</a></span></h4>
<p>A new name:</p>
<ul><li>
<p>May not be the empty string:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">''</span>] = <span class="ruby-string">'0'</span>
<span class="ruby-comment"># Raises Errno::EINVAL (Invalid argument - ruby_setenv())</span>
</pre>
</li><li>
<p>May not contain character <code>"="</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'='</span>] = <span class="ruby-string">'0'</span>
<span class="ruby-comment"># Raises Errno::EINVAL (Invalid argument - ruby_setenv(=))</span>
</pre>
</li></ul>
<p>A new name or value:</p>
<ul><li>
<p>May not be a non-String that does not respond to #to_str:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>
<span class="ruby-comment"># Raises TypeError (no implicit conversion of Object into String)</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>] = <span class="ruby-string">'0'</span>
<span class="ruby-comment"># Raises TypeError (no implicit conversion of Object into String)</span>
</pre>
</li><li>
<p>May not contain the NUL character <code>"\0"</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">"\0"</span>
<span class="ruby-comment"># Raises ArgumentError (bad environment variable value: contains null byte)</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">"\0"</span>] <span class="ruby-operator">==</span> <span class="ruby-string">'0'</span>
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: contains null byte)</span>
</pre>
</li><li>
<p>May not have an ASCII-incompatible encoding such as UTF-16LE or ISO-2022-JP:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'0'</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ISO_2022_JP</span>)
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: ISO-2022-JP)</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">"foo"</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ISO_2022_JP</span>)] = <span class="ruby-string">'0'</span>
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: ISO-2022-JP)</span>
</pre>
</li></ul>
<h3 id="class-ENV-label-About+Ordering">About Ordering<span><a href="#class-ENV-label-About+Ordering">¶</a> <a href="#top">↑</a></span></h3>
<p><a href="ENV.html"><code>ENV</code></a> enumerates its name/value pairs in the order found in the operating system's environment variables. Therefore the ordering of <a href="ENV.html"><code>ENV</code></a> content is OS-dependent, and may be indeterminate.</p>
<p>This will be seen in:</p>
<ul><li>
<p>A <a href="Hash.html"><code>Hash</code></a> returned by an <a href="ENV.html"><code>ENV</code></a> method.</p>
</li><li>
<p>An <a href="Enumerator.html"><code>Enumerator</code></a> returned by an <a href="ENV.html"><code>ENV</code></a> method.</p>
</li><li>
<p>An <a href="Array.html"><code>Array</code></a> returned by <a href="ENV.html#method-c-keys"><code>ENV.keys</code></a>, <a href="ENV.html#method-c-values"><code>ENV.values</code></a>, or <a href="ENV.html#method-c-to_a"><code>ENV.to_a</code></a>.</p>
</li><li>
<p>The <a href="String.html"><code>String</code></a> returned by <a href="ENV.html#method-c-inspect"><code>ENV.inspect</code></a>.</p>
</li><li>
<p>The <a href="Array.html"><code>Array</code></a> returned by <a href="ENV.html#method-c-shift"><code>ENV.shift</code></a>.</p>
</li><li>
<p>The name returned by <a href="ENV.html#method-c-key"><code>ENV.key</code></a>.</p>
</li></ul>
<h3 id="class-ENV-label-About+the+Examples">About the Examples<span><a href="#class-ENV-label-About+the+Examples">¶</a> <a href="#top">↑</a></span></h3>
<p>Some methods in <a href="ENV.html"><code>ENV</code></a> return <a href="ENV.html"><code>ENV</code></a> itself. Typically, there are many environment variables. It's not useful to display a large <a href="ENV.html"><code>ENV</code></a> in the examples here, so most example snippets begin by resetting the contents of ENV:</p>
<ul><li>
<p><a href="ENV.html#method-c-replace"><code>ENV.replace</code></a> replaces <a href="ENV.html"><code>ENV</code></a> with a new collection of entries.</p>
</li><li>
<p><a href="ENV.html#method-c-clear"><code>ENV.clear</code></a> empties <a href="ENV.html"><code>ENV</code></a>.</p>
</li></ul>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-5B-5D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
ENV[name] → value
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the value for the environment variable <code>name</code> if it exists:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'0'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] <span class="ruby-comment"># => "0"</span>
</pre>
<p>Returns nil if the named variable does not exist:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] <span class="ruby-comment"># => nil</span>
</pre>
<p>Raises an exception if <code>name</code> is invalid. See <a href="#class-ENV-label-Invalid-Names+and+Values">Invalid Names and Values</a>.</p>
<div class="method-source-code" id="5B-5D-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-5B-5D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
ENV[name] = value → value
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p><a href="ENV.html#method-c-store"><code>ENV.store</code></a> is an alias for <a href="ENV.html#method-c-5B-5D-3D"><code>ENV.[]=</code></a>.</p>
<p>Creates, updates, or deletes the named environment variable, returning the value. Both <code>name</code> and <code>value</code> may be instances of <a href="String.html"><code>String</code></a>. See <a href="#class-ENV-label-Valid+Names+and+Values">Valid Names and Values</a>.</p>
<ul><li>
<p>If the named environment variable does not exist:</p>
<ul><li>
<p>If <code>value</code> is <code>nil</code>, does nothing.</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-keyword">nil</span> <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-keyword">nil</span>) <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'bar'</span>) <span class="ruby-comment"># => false</span>
</pre>
</li><li>
<p>If <code>value</code> is not <code>nil</code>, creates the environment variable with <code>name</code> and <code>value</code>:</p>
<pre class="ruby"><span class="ruby-comment"># Create 'foo' using ENV.[]=.</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'0'</span> <span class="ruby-comment"># => '0'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] <span class="ruby-comment"># => '0'</span>
<span class="ruby-comment"># Create 'bar' using ENV.store.</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-string">'1'</span>) <span class="ruby-comment"># => '1'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'bar'</span>] <span class="ruby-comment"># => '1'</span>
</pre>
</li></ul>
</li><li>
<p>If the named environment variable exists:</p>
<ul><li>
<p>If <code>value</code> is not <code>nil</code>, updates the environment variable with value <code>value</code>:</p>
<pre class="ruby"><span class="ruby-comment"># Update 'foo' using ENV.[]=.</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'2'</span> <span class="ruby-comment"># => '2'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] <span class="ruby-comment"># => '2'</span>
<span class="ruby-comment"># Update 'bar' using ENV.store.</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-string">'3'</span>) <span class="ruby-comment"># => '3'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'bar'</span>] <span class="ruby-comment"># => '3'</span>
</pre>
</li><li>
<p>If <code>value</code> is <code>nil</code>, deletes the environment variable:</p>
<pre class="ruby"><span class="ruby-comment"># Delete 'foo' using ENV.[]=.</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-keyword">nil</span> <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-comment"># Delete 'bar' using ENV.store.</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-keyword">nil</span>) <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'bar'</span>) <span class="ruby-comment"># => false</span>
</pre>
</li></ul>
</li></ul>
<p>Raises an exception if <code>name</code> or <code>value</code> is invalid. See <a href="#class-ENV-label-Invalid+Names+and+Values">Invalid Names and Values</a>.</p>
<div class="method-source-code" id="5B-5D-3D-source">
<pre>static VALUE
env_aset_m(VALUE obj, VALUE nm, VALUE val)
{
return env_aset(nm, val);
}</pre>
</div>
</div>
</div>
<div id="method-c-assoc" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
assoc(name) → Array or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a 2-element <a href="Array.html"><code>Array</code></a> containing the name and value of the environment variable for <code>name</code> if it exists:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">assoc</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => ['foo' '0']</span>
</pre>
<p>Returns <code>nil</code> if <code>name</code> is a valid <a href="String.html"><code>String</code></a> and there is no such environment variable:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">assoc</span>(<span class="ruby-string">'baz'</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Returns <code>nil</code> if <code>name</code> is the empty <a href="String.html"><code>String</code></a> or is a <a href="String.html"><code>String</code></a> containing character <code>'='</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">assoc</span>(<span class="ruby-string">''</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">assoc</span>(<span class="ruby-string">'='</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Raises an exception if <code>name</code> is a <a href="String.html"><code>String</code></a> containing the NUL character <code>"\0"</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">assoc</span>(<span class="ruby-string">"\0"</span>) <span class="ruby-comment"># Raises ArgumentError (bad environment variable name: contains null byte)</span>
</pre>
<p>Raises an exception if <code>name</code> has an encoding that is not ASCII-compatible:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">assoc</span>(<span class="ruby-string">"\xa1\xa1"</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">UTF_16LE</span>))
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)</span>
</pre>
<p>Raises an exception if <code>name</code> is not a String:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">assoc</span>(<span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>) <span class="ruby-comment"># TypeError (no implicit conversion of Object into String)</span>
</pre>
<div class="method-source-code" id="assoc-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-clear" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
clear → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Removes every environment variable; returns ENV:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment"># => 2</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">clear</span> <span class="ruby-comment"># => ENV</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment"># => 0</span>
</pre>
<div class="method-source-code" id="clear-source">
<pre>static VALUE
env_clear(VALUE _)
{
return rb_env_clear();
}</pre>
</div>
</div>
</div>
<div id="method-c-delete" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
delete(name) → value
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
delete(name) { |name| block } → value
</span>
</div>
<div class="method-description">
<p>Deletes the environment variable with <code>name</code> if it exists and returns its value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'0'</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => '0'</span>
</pre>
<p>Returns <code>nil</code> if the named environment variable does not exist:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => nil</span>
</pre>
<p>If a block given and the environment variable does not exist, yields <code>name</code> to the block and returns <code>nil</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-string">'foo'</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-identifier">name</span> } <span class="ruby-comment"># => nil</span>
<span class="ruby-identifier">foo</span>
</pre>
<p>If a block given and the environment variable exists, deletes the environment variable and returns its value (ignoring the block):</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'0'</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-string">'foo'</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-identifier">fail</span> <span class="ruby-string">'ignored'</span> } <span class="ruby-comment"># => "0"</span>
</pre>
<p>Raises an exception if <code>name</code> is invalid. See <a href="#class-ENV-label-Invalid-Names+and+Values">Invalid Names and Values</a>.</p>
<div class="method-source-code" id="delete-source">
<pre>static VALUE
env_delete_m(VALUE obj, VALUE name)
{
VALUE val;
val = env_delete(name);
if (NIL_P(val) && rb_block_given_p()) rb_yield(name);
return val;
}</pre>
</div>
</div>
</div>
<div id="method-c-delete_if" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
delete_if { |name, value| block } → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
delete_if → Enumerator
</span>
</div>
<div class="method-description">
<p>Deletes every environment variable for which the block evaluates to <code>true</code>.</p>
<p>If no block is given an enumerator is returned instead.</p>
<div class="method-source-code" id="delete_if-source">
<pre>static VALUE
env_delete_if(VALUE ehash)
{
RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
env_reject_bang(ehash);
return envtbl;
}</pre>
</div>
</div>
</div>
<div id="method-c-each" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
each { |name, value| block } → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
each → Enumerator
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
each_pair { |name, value| block } → ENV
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
each_pair → Enumerator
</span>
</div>
<div class="method-description">
<p>Yields each environment variable name and its value as a 2-element Array:</p>
<pre class="ruby"><span class="ruby-identifier">h</span> = {}
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_pair</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">h</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">value</span> } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">h</span> <span class="ruby-comment"># => {"bar"=>"1", "foo"=>"0"}</span>
</pre>
<p>Returns an <a href="Enumerator.html"><code>Enumerator</code></a> if no block given:</p>
<pre class="ruby"><span class="ruby-identifier">h</span> = {}
<span class="ruby-identifier">e</span> = <span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_pair</span> <span class="ruby-comment"># => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_pair></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">h</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">value</span> } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">h</span> <span class="ruby-comment"># => {"bar"=>"1", "foo"=>"0"}</span>
</pre>
<div class="method-source-code" id="each-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-each_key" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
each_key { |name| block } → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
each_key → Enumerator
</span>
</div>
<div class="method-description">
<p>Yields each environment variable name:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>) <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">names</span> = []
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_key</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-identifier">names</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">name</span>) } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">names</span> <span class="ruby-comment"># => ["bar", "foo"]</span>
</pre>
<p>Returns an <a href="Enumerator.html"><code>Enumerator</code></a> if no block given:</p>
<pre class="ruby"><span class="ruby-identifier">e</span> = <span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_key</span> <span class="ruby-comment"># => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_key></span>
<span class="ruby-identifier">names</span> = []
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-identifier">names</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">name</span>) } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">names</span> <span class="ruby-comment"># => ["bar", "foo"]</span>
</pre>
<div class="method-source-code" id="each_key-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-each_pair" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
each_pair { |name, value| block } → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
each_pair → Enumerator
</span>
</div>
<div class="method-description">
<p>Yields each environment variable name and its value as a 2-element Array:</p>
<pre class="ruby"><span class="ruby-identifier">h</span> = {}
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_pair</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">h</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">value</span> } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">h</span> <span class="ruby-comment"># => {"bar"=>"1", "foo"=>"0"}</span>
</pre>
<p>Returns an <a href="Enumerator.html"><code>Enumerator</code></a> if no block given:</p>
<pre class="ruby"><span class="ruby-identifier">h</span> = {}
<span class="ruby-identifier">e</span> = <span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_pair</span> <span class="ruby-comment"># => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_pair></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">h</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">value</span> } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">h</span> <span class="ruby-comment"># => {"bar"=>"1", "foo"=>"0"}</span>
</pre>
<div class="method-source-code" id="each_pair-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-each_value" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
each_value { |value| block } → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
each_value → Enumerator
</span>
</div>
<div class="method-description">
<p>Yields each environment variable value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>) <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">values</span> = []
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_value</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">values</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">value</span>) } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">values</span> <span class="ruby-comment"># => ["1", "0"]</span>
</pre>
<p>Returns an <a href="Enumerator.html"><code>Enumerator</code></a> if no block given:</p>
<pre class="ruby"><span class="ruby-identifier">e</span> = <span class="ruby-constant">ENV</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-comment"># => #<Enumerator: {"bar"=>"1", "foo"=>"0"}:each_value></span>
<span class="ruby-identifier">values</span> = []
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">values</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">value</span>) } <span class="ruby-comment"># => ENV</span>
<span class="ruby-identifier">values</span> <span class="ruby-comment"># => ["1", "0"]</span>
</pre>
<div class="method-source-code" id="each_value-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-empty-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
empty? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns true when there are no environment variables</p>
<div class="method-source-code" id="empty-3F-source">
<pre>static VALUE
env_empty_p(VALUE _)
{
char **env;
env = GET_ENVIRON(environ);
if (env[0] == 0) {
FREE_ENVIRON(environ);
return Qtrue;
}
FREE_ENVIRON(environ);
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-c-fetch" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
fetch(name) → value
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
fetch(name, default) → value
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
fetch(name) { |name| block } → value
</span>
</div>
<div class="method-description">
<p>If <code>name</code> is the name of an environment variable, returns its value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'0'</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">fetch</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => '0'</span>
</pre>
<p>Otherwise if a block is given (but not a default value), yields <code>name</code> to the block and returns the block's return value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">fetch</span>(<span class="ruby-string">'foo'</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-value">:need_not_return_a_string</span> } <span class="ruby-comment"># => :need_not_return_a_string</span>
</pre>
<p>Otherwise if a default value is given (but not a block), returns the default value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-string">'foo'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">fetch</span>(<span class="ruby-string">'foo'</span>, <span class="ruby-value">:default_need_not_be_a_string</span>) <span class="ruby-comment"># => :default_need_not_be_a_string</span>
</pre>
<p>If the environment variable does not exist and both default and block are given, issues a warning (“warning: block supersedes default value argument”), yields <code>name</code> to the block, and returns the block's return value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">fetch</span>(<span class="ruby-string">'foo'</span>, <span class="ruby-value">:default</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-value">:block_return</span> } <span class="ruby-comment"># => :block_return</span>
</pre>
<p>Raises <a href="KeyError.html"><code>KeyError</code></a> if <code>name</code> is valid, but not found, and neither default value nor block is given:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">fetch</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># Raises KeyError (key not found: "foo")</span>
</pre>
<p>Raises an exception if <code>name</code> is invalid. See <a href="#class-ENV-label-Invalid-Names+and+Values">Invalid Names and Values</a>.</p>
<div class="method-source-code" id="fetch-source">
<pre>static VALUE
env_fetch(int argc, VALUE *argv, VALUE _)
{
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);
}</pre>
</div>
</div>
</div>
<div id="method-c-filter" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
filter { |name, value| block } → Hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
filter → Enumerator
</span>
</div>
<div class="method-description">
<p>Returns a copy of the environment for entries where the block returns true.</p>
<p>Returns an <a href="Enumerator.html"><code>Enumerator</code></a> if no block was given.</p>
<p><a href="ENV.html#method-c-filter"><code>ENV.filter</code></a> is an alias for <a href="ENV.html#method-c-select"><code>ENV.select</code></a>.</p>
<div class="method-source-code" id="filter-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-filter-21" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
filter! { |name, value| block } → ENV or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
filter! → Enumerator
</span>
</div>
<div class="method-description">
<p>Equivalent to <a href="ENV.html#method-c-keep_if"><code>ENV.keep_if</code></a> but returns <code>nil</code> if no changes were made.</p>
<p><a href="ENV.html#method-c-filter-21"><code>ENV.filter!</code></a> is an alias for <a href="ENV.html#method-c-select-21"><code>ENV.select!</code></a>.</p>
<div class="method-source-code" id="filter-21-source">
<pre>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))) {
env_delete(RARRAY_AREF(keys, i));
del++;
}
}
}
RB_GC_GUARD(keys);
if (del == 0) return Qnil;
return envtbl;
}</pre>
</div>
</div>
</div>
<div id="method-c-freeze" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
freeze → raises TypeError
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Ruby does not allow <a href="ENV.html"><code>ENV</code></a> to be frozen, so calling <a href="ENV.html#method-c-freeze"><code>ENV.freeze</code></a> raises <a href="TypeError.html"><code>TypeError</code></a>.</p>
<div class="method-source-code" id="freeze-source">
<pre>static VALUE
env_freeze(VALUE self)
{
rb_raise(rb_eTypeError, "cannot freeze ENV");
return self; /* Not reached */
}</pre>
</div>
</div>
</div>
<div id="method-c-has_key-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
has_key?(name) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p><a href="ENV.html#method-c-has_key-3F"><code>ENV.has_key?</code></a>, <a href="ENV.html#method-c-member-3F"><code>ENV.member?</code></a>, and <a href="ENV.html#method-c-key-3F"><code>ENV.key?</code></a> are aliases for <a href="ENV.html#method-c-include-3F"><code>ENV.include?</code></a>.</p>
<p>Returns <code>true</code> if there is an environment variable with the given <code>name</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => true</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is a valid <a href="String.html"><code>String</code></a> and there is no such environment variable:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'baz'</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is the empty <a href="String.html"><code>String</code></a> or is a <a href="String.html"><code>String</code></a> containing character <code>'='</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">''</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'='</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Raises an exception if <code>name</code> is a <a href="String.html"><code>String</code></a> containing the NUL character <code>"\0"</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\0"</span>) <span class="ruby-comment"># Raises ArgumentError (bad environment variable name: contains null byte)</span>
</pre>
<p>Raises an exception if <code>name</code> has an encoding that is not ASCII-compatible:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\xa1\xa1"</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">UTF_16LE</span>))
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)</span>
</pre>
<p>Raises an exception if <code>name</code> is not a String:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>) <span class="ruby-comment"># TypeError (no implicit conversion of Object into String)</span>
</pre>
<div class="method-source-code" id="has_key-3F-source">
<pre>static VALUE
env_has_key(VALUE env, VALUE key)
{
const char *s;
s = env_name(key);
if (getenv(s)) return Qtrue;
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-c-has_value-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
has_value?(value) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if there is an environment variable with the given <code>value</code>.</p>
<div class="method-source-code" id="has_value-3F-source">
<pre>static VALUE
env_has_value(VALUE dmy, VALUE obj)
{
char **env;
obj = rb_check_string_type(obj);
if (NIL_P(obj)) return Qnil;
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;
}</pre>
</div>
</div>
</div>
<div id="method-c-include-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
include?(name) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p><a href="ENV.html#method-c-has_key-3F"><code>ENV.has_key?</code></a>, <a href="ENV.html#method-c-member-3F"><code>ENV.member?</code></a>, and <a href="ENV.html#method-c-key-3F"><code>ENV.key?</code></a> are aliases for <a href="ENV.html#method-c-include-3F"><code>ENV.include?</code></a>.</p>
<p>Returns <code>true</code> if there is an environment variable with the given <code>name</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => true</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is a valid <a href="String.html"><code>String</code></a> and there is no such environment variable:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'baz'</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is the empty <a href="String.html"><code>String</code></a> or is a <a href="String.html"><code>String</code></a> containing character <code>'='</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">''</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'='</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Raises an exception if <code>name</code> is a <a href="String.html"><code>String</code></a> containing the NUL character <code>"\0"</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\0"</span>) <span class="ruby-comment"># Raises ArgumentError (bad environment variable name: contains null byte)</span>
</pre>
<p>Raises an exception if <code>name</code> has an encoding that is not ASCII-compatible:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\xa1\xa1"</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">UTF_16LE</span>))
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)</span>
</pre>
<p>Raises an exception if <code>name</code> is not a String:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>) <span class="ruby-comment"># TypeError (no implicit conversion of Object into String)</span>
</pre>
<div class="method-source-code" id="include-3F-source">
<pre>static VALUE
env_has_key(VALUE env, VALUE key)
{
const char *s;
s = env_name(key);
if (getenv(s)) return Qtrue;
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-c-index" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
index(value) → key
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Deprecated method that is equivalent to <a href="ENV.html#method-c-key"><code>ENV.key</code></a></p>
<div class="method-source-code" id="index-source">
<pre>static VALUE
env_index(VALUE dmy, VALUE value)
{
rb_warn_deprecated("ENV.index", "ENV.key");
return env_key(dmy, value);
}</pre>
</div>
</div>
</div>
<div id="method-c-inspect" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
inspect → string
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the contents of the environment as a <a href="String.html"><code>String</code></a>.</p>
<div class="method-source-code" id="inspect-source">
<pre>static VALUE
env_inspect(VALUE _)
{
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, "}");
return str;
}</pre>
</div>
</div>
</div>
<div id="method-c-invert" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
invert → Hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a new hash created by using environment variable names as values and values as names.</p>
<div class="method-source-code" id="invert-source">
<pre>static VALUE
env_invert(VALUE _)
{
return rb_hash_invert(env_to_hash());
}</pre>
</div>
</div>
</div>
<div id="method-c-keep_if" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
keep_if { |name, value| block } → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
keep_if → Enumerator
</span>
</div>
<div class="method-description">
<p>Deletes every environment variable where the block evaluates to <code>false</code>.</p>
<p>Returns an enumerator if no block was given.</p>
<div class="method-source-code" id="keep_if-source">
<pre>static VALUE
env_keep_if(VALUE ehash)
{
RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
env_select_bang(ehash);
return envtbl;
}</pre>
</div>
</div>
</div>
<div id="method-c-key" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
key(value) → name or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the name of the first environment variable with <code>value</code> if it exists:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">key</span>(<span class="ruby-string">'0'</span>) <span class="ruby-comment"># =>'foo'</span>
</pre>
<p>The order in which environment variables are examined is OS-dependent. See <a href="#class-ENV-label-About+Ordering">About Ordering</a>.</p>
<p>Returns <code>nil</code> if there is no such value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">key</span>(<span class="ruby-string">'2'</span>) <span class="ruby-comment"># => nil</span>
</pre>
<p>Raises an exception if <code>value</code> is not a String:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">key</span>(<span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>) <span class="ruby-comment"># raises TypeError (no implicit conversion of Object into String)</span>
</pre>
<div class="method-source-code" id="key-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-key-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
key?(name) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p><a href="ENV.html#method-c-has_key-3F"><code>ENV.has_key?</code></a>, <a href="ENV.html#method-c-member-3F"><code>ENV.member?</code></a>, and <a href="ENV.html#method-c-key-3F"><code>ENV.key?</code></a> are aliases for <a href="ENV.html#method-c-include-3F"><code>ENV.include?</code></a>.</p>
<p>Returns <code>true</code> if there is an environment variable with the given <code>name</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => true</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is a valid <a href="String.html"><code>String</code></a> and there is no such environment variable:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'baz'</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is the empty <a href="String.html"><code>String</code></a> or is a <a href="String.html"><code>String</code></a> containing character <code>'='</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">''</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'='</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Raises an exception if <code>name</code> is a <a href="String.html"><code>String</code></a> containing the NUL character <code>"\0"</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\0"</span>) <span class="ruby-comment"># Raises ArgumentError (bad environment variable name: contains null byte)</span>
</pre>
<p>Raises an exception if <code>name</code> has an encoding that is not ASCII-compatible:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\xa1\xa1"</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">UTF_16LE</span>))
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)</span>
</pre>
<p>Raises an exception if <code>name</code> is not a String:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>) <span class="ruby-comment"># TypeError (no implicit conversion of Object into String)</span>
</pre>
<div class="method-source-code" id="key-3F-source">
<pre>static VALUE
env_has_key(VALUE env, VALUE key)
{
const char *s;
s = env_name(key);
if (getenv(s)) return Qtrue;
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-c-keys" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
keys → Array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns all variable names in an Array:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">keys</span> <span class="ruby-comment"># => ['bar', 'foo']</span>
</pre>
<p>The order of the names is OS-dependent. See <a href="#class-ENV-label-About+Ordering">About Ordering</a>.</p>
<p>Returns the empty <a href="Array.html"><code>Array</code></a> if <a href="ENV.html"><code>ENV</code></a> is empty:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">keys</span> <span class="ruby-comment"># => []</span>
</pre>
<div class="method-source-code" id="keys-source">
<pre>static VALUE
env_f_keys(VALUE _)
{
return env_keys();
}</pre>
</div>
</div>
</div>
<div id="method-c-length" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
length
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the number of environment variables.</p>
<div class="method-source-code" id="length-source">
<pre>static VALUE
env_size(VALUE _)
{
int i;
char **env;
env = GET_ENVIRON(environ);
for (i=0; env[i]; i++)
;
FREE_ENVIRON(environ);
return INT2FIX(i);
}</pre>
</div>
</div>
</div>
<div id="method-c-member-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
member?(name) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p><a href="ENV.html#method-c-has_key-3F"><code>ENV.has_key?</code></a>, <a href="ENV.html#method-c-member-3F"><code>ENV.member?</code></a>, and <a href="ENV.html#method-c-key-3F"><code>ENV.key?</code></a> are aliases for <a href="ENV.html#method-c-include-3F"><code>ENV.include?</code></a>.</p>
<p>Returns <code>true</code> if there is an environment variable with the given <code>name</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => true</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is a valid <a href="String.html"><code>String</code></a> and there is no such environment variable:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'baz'</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Returns <code>false</code> if <code>name</code> is the empty <a href="String.html"><code>String</code></a> or is a <a href="String.html"><code>String</code></a> containing character <code>'='</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">''</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'='</span>) <span class="ruby-comment"># => false</span>
</pre>
<p>Raises an exception if <code>name</code> is a <a href="String.html"><code>String</code></a> containing the NUL character <code>"\0"</code>:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\0"</span>) <span class="ruby-comment"># Raises ArgumentError (bad environment variable name: contains null byte)</span>
</pre>
<p>Raises an exception if <code>name</code> has an encoding that is not ASCII-compatible:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"\xa1\xa1"</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">UTF_16LE</span>))
<span class="ruby-comment"># Raises ArgumentError (bad environment variable name: ASCII incompatible encoding: UTF-16LE)</span>
</pre>
<p>Raises an exception if <code>name</code> is not a String:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>) <span class="ruby-comment"># TypeError (no implicit conversion of Object into String)</span>
</pre>
<div class="method-source-code" id="member-3F-source">
<pre>static VALUE
env_has_key(VALUE env, VALUE key)
{
const char *s;
s = env_name(key);
if (getenv(s)) return Qtrue;
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-c-merge-21" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
merge!(hash) → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
merge!(hash) { |name, old_value, new_value| block } → ENV
</span>
</div>
<div class="method-description">
<p>Adds the contents of <code>hash</code> to the environment variables. If no block is specified entries with duplicate keys are overwritten, otherwise the value of each duplicate name is determined by calling the block with the key, its value from the environment and its value from the hash.</p>
<div class="method-source-code" id="merge-21-source">
<pre>static VALUE
env_update(VALUE env, VALUE hash)
{
if (env == hash) return env;
hash = to_hash(hash);
rb_foreach_func *func = rb_block_given_p() ?
env_update_block_i : env_update_i;
rb_hash_foreach(hash, func, 0);
return env;
}</pre>
</div>
</div>
</div>
<div id="method-c-rassoc" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rassoc(value)
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns an <a href="Array.html"><code>Array</code></a> of the name and value of the environment variable with <code>value</code> or <code>nil</code> if the value cannot be found.</p>
<div class="method-source-code" id="rassoc-source">
<pre>static VALUE
env_rassoc(VALUE dmy, VALUE obj)
{
char **env;
obj = rb_check_string_type(obj);
if (NIL_P(obj)) return Qnil;
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_str_new(*env, s-*env-1), obj);
FREE_ENVIRON(environ);
return result;
}
}
env++;
}
FREE_ENVIRON(environ);
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-c-rehash" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
rehash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Re-hashing the environment variables does nothing. It is provided for compatibility with <a href="Hash.html"><code>Hash</code></a>.</p>
<div class="method-source-code" id="rehash-source">
<pre>static VALUE
env_none(VALUE _)
{
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-c-reject" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
reject { |name, value| block } → Hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
reject → Enumerator
</span>
</div>
<div class="method-description">
<p>Same as <a href="ENV.html#method-c-delete_if"><code>ENV.delete_if</code></a>, but works on (and returns) a copy of the environment.</p>
<div class="method-source-code" id="reject-source">
<pre>static VALUE
env_reject(VALUE _)
{
return rb_hash_delete_if(env_to_hash());
}</pre>
</div>
</div>
</div>
<div id="method-c-reject-21" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
reject! { |name, value| block } → ENV or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
reject! → Enumerator
</span>
</div>
<div class="method-description">
<p>Similar to <a href="ENV.html#method-c-delete_if"><code>ENV.delete_if</code></a>, but returns <code>nil</code> if no changes were made.</p>
<p>Deletes each environment variable for which the block returns a truthy value, returning <a href="ENV.html"><code>ENV</code></a> (if any deletions) or <code>nil</code> (if not):</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>, <span class="ruby-string">'baz'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'2'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">reject!</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">name</span>.<span class="ruby-identifier">start_with?</span>(<span class="ruby-string">'b'</span>) } <span class="ruby-comment"># => ENV</span>
<span class="ruby-constant">ENV</span> <span class="ruby-comment"># => {"foo"=>"0"}</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">reject!</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">name</span>.<span class="ruby-identifier">start_with?</span>(<span class="ruby-string">'b'</span>) } <span class="ruby-comment"># => nil</span>
</pre>
<p>Returns an <a href="Enumerator.html"><code>Enumerator</code></a> if no block given:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>, <span class="ruby-string">'baz'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'2'</span>)
<span class="ruby-identifier">e</span> = <span class="ruby-constant">ENV</span>.<span class="ruby-identifier">reject!</span> <span class="ruby-comment"># => #<Enumerator: {"bar"=>"1", "baz"=>"2", "foo"=>"0"}:reject!></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">name</span>.<span class="ruby-identifier">start_with?</span>(<span class="ruby-string">'b'</span>) } <span class="ruby-comment"># => ENV</span>
<span class="ruby-constant">ENV</span> <span class="ruby-comment"># => {"foo"=>"0"}</span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-identifier">name</span>.<span class="ruby-identifier">start_with?</span>(<span class="ruby-string">'b'</span>) } <span class="ruby-comment"># => nil</span>
</pre>
<div class="method-source-code" id="reject-21-source">
<pre>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))) {
env_delete(RARRAY_AREF(keys, i));
del++;
}
}
}
RB_GC_GUARD(keys);
if (del == 0) return Qnil;
return envtbl;
}</pre>
</div>
</div>
</div>
<div id="method-c-replace" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
replace(hash) → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Replaces the entire content of the environment variables with the name/value pairs in the given <code>hash</code>; returns <a href="ENV.html"><code>ENV</code></a>.</p>
<p>Replaces the content of <a href="ENV.html"><code>ENV</code></a> with the given pairs:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>) <span class="ruby-comment"># => ENV</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">to_hash</span> <span class="ruby-comment"># => {"bar"=>"1", "foo"=>"0"}</span>
</pre>
<p>Raises an exception if a name or value is invalid. See <a href="#class-ENV-label-Invalid-Names+and+Values">Invalid Names and Values</a>.</p>
<div class="method-source-code" id="replace-source">
<pre>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(RARRAY_AREF(keys, i));
}
RB_GC_GUARD(keys);
return env;
}</pre>
</div>
</div>
</div>
<div id="method-c-select" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
select { |name, value| block } → Hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
select → Enumerator
</span>
</div>
<div class="method-description">
<p>Returns a copy of the environment for entries where the block returns true.</p>
<p>Returns an <a href="Enumerator.html"><code>Enumerator</code></a> if no block was given.</p>
<p><a href="ENV.html#method-c-filter"><code>ENV.filter</code></a> is an alias for <a href="ENV.html#method-c-select"><code>ENV.select</code></a>.</p>
<div class="method-source-code" id="select-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-select-21" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
select! { |name, value| block } → ENV or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
select! → Enumerator
</span>
</div>
<div class="method-description">
<p>Equivalent to <a href="ENV.html#method-c-keep_if"><code>ENV.keep_if</code></a> but returns <code>nil</code> if no changes were made.</p>
<p><a href="ENV.html#method-c-filter-21"><code>ENV.filter!</code></a> is an alias for <a href="ENV.html#method-c-select-21"><code>ENV.select!</code></a>.</p>
<div class="method-source-code" id="select-21-source">
<pre>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))) {
env_delete(RARRAY_AREF(keys, i));
del++;
}
}
}
RB_GC_GUARD(keys);
if (del == 0) return Qnil;
return envtbl;
}</pre>
</div>
</div>
</div>
<div id="method-c-shift" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
shift → [name, value] or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Removes the first environment variable from <a href="ENV.html"><code>ENV</code></a> and returns a 2-element <a href="Array.html"><code>Array</code></a> containing its name and value:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">to_hash</span> <span class="ruby-comment"># => {'bar' => '1', 'foo' => '0'}</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">shift</span> <span class="ruby-comment"># => ['bar', '1']</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">to_hash</span> <span class="ruby-comment"># => {'foo' => '0'}</span>
</pre>
<p>Exactly which environment variable is “first” is OS-dependent. See <a href="#class-ENV-label-About+Ordering">About Ordering</a>.</p>
<p>Returns <code>nil</code> if the environment is empty:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">shift</span> <span class="ruby-comment"># => nil</span>
</pre>
<div class="method-source-code" id="shift-source">
<pre>static VALUE
env_shift(VALUE _)
{
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(key);
result = rb_assoc_new(key, val);
}
}
FREE_ENVIRON(environ);
return result;
}</pre>
</div>
</div>
</div>
<div id="method-c-size" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
size
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the number of environment variables.</p>
<div class="method-source-code" id="size-source">
<pre>static VALUE
env_size(VALUE _)
{
int i;
char **env;
env = GET_ENVIRON(environ);
for (i=0; env[i]; i++)
;
FREE_ENVIRON(environ);
return INT2FIX(i);
}</pre>
</div>
</div>
</div>
<div id="method-c-slice" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
slice(*keys) → a_hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a hash containing only the given keys from <a href="ENV.html"><code>ENV</code></a> and their values.</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">slice</span>(<span class="ruby-string">"TERM"</span>,<span class="ruby-string">"HOME"</span>) <span class="ruby-comment">#=> {"TERM"=>"xterm-256color", "HOME"=>"/Users/rhc"}</span>
</pre>
<div class="method-source-code" id="slice-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-store" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
store(name, value) → value
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p><a href="ENV.html#method-c-store"><code>ENV.store</code></a> is an alias for <a href="ENV.html#method-c-5B-5D-3D"><code>ENV.[]=</code></a>.</p>
<p>Creates, updates, or deletes the named environment variable, returning the value. Both <code>name</code> and <code>value</code> may be instances of <a href="String.html"><code>String</code></a>. See <a href="#class-ENV-label-Valid+Names+and+Values">Valid Names and Values</a>.</p>
<ul><li>
<p>If the named environment variable does not exist:</p>
<ul><li>
<p>If <code>value</code> is <code>nil</code>, does nothing.</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-keyword">nil</span> <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-keyword">nil</span>) <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'bar'</span>) <span class="ruby-comment"># => false</span>
</pre>
</li><li>
<p>If <code>value</code> is not <code>nil</code>, creates the environment variable with <code>name</code> and <code>value</code>:</p>
<pre class="ruby"><span class="ruby-comment"># Create 'foo' using ENV.[]=.</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'0'</span> <span class="ruby-comment"># => '0'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] <span class="ruby-comment"># => '0'</span>
<span class="ruby-comment"># Create 'bar' using ENV.store.</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-string">'1'</span>) <span class="ruby-comment"># => '1'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'bar'</span>] <span class="ruby-comment"># => '1'</span>
</pre>
</li></ul>
</li><li>
<p>If the named environment variable exists:</p>
<ul><li>
<p>If <code>value</code> is not <code>nil</code>, updates the environment variable with value <code>value</code>:</p>
<pre class="ruby"><span class="ruby-comment"># Update 'foo' using ENV.[]=.</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-string">'2'</span> <span class="ruby-comment"># => '2'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] <span class="ruby-comment"># => '2'</span>
<span class="ruby-comment"># Update 'bar' using ENV.store.</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-string">'3'</span>) <span class="ruby-comment"># => '3'</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'bar'</span>] <span class="ruby-comment"># => '3'</span>
</pre>
</li><li>
<p>If <code>value</code> is <code>nil</code>, deletes the environment variable:</p>
<pre class="ruby"><span class="ruby-comment"># Delete 'foo' using ENV.[]=.</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">'foo'</span>] = <span class="ruby-keyword">nil</span> <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'foo'</span>) <span class="ruby-comment"># => false</span>
<span class="ruby-comment"># Delete 'bar' using ENV.store.</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">store</span>(<span class="ruby-string">'bar'</span>, <span class="ruby-keyword">nil</span>) <span class="ruby-comment"># => nil</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'bar'</span>) <span class="ruby-comment"># => false</span>
</pre>
</li></ul>
</li></ul>
<p>Raises an exception if <code>name</code> or <code>value</code> is invalid. See <a href="#class-ENV-label-Invalid+Names+and+Values">Invalid Names and Values</a>.</p>
<div class="method-source-code" id="store-source">
<pre>static VALUE
env_aset_m(VALUE obj, VALUE nm, VALUE val)
{
return env_aset(nm, val);
}</pre>
</div>
</div>
</div>
<div id="method-c-to_a" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_a → Array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Converts the environment variables into an array of names and value arrays.</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">to_a</span> <span class="ruby-comment"># => [["TERM", "xterm-color"], ["SHELL", "/bin/bash"], ...]</span>
</pre>
<div class="method-source-code" id="to_a-source">
<pre>static VALUE
env_to_a(VALUE _)
{
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;
}</pre>
</div>
</div>
</div>
<div id="method-c-to_h" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_h → hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
to_h {|name, value| block } → hash
</span>
</div>
<div class="method-description">
<p>Creates a hash with a copy of the environment variables.</p>
<div class="method-source-code" id="to_h-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-c-to_hash" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_hash → hash
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Creates a hash with a copy of the environment variables.</p>
<div class="method-source-code" id="to_hash-source">
<pre>static VALUE
env_f_to_hash(VALUE _)
{
return env_to_hash();
}</pre>
</div>
</div>
</div>
<div id="method-c-to_s" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_s → "ENV"
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns “ENV”</p>
<div class="method-source-code" id="to_s-source">
<pre>static VALUE
env_to_s(VALUE _)
{
return rb_usascii_str_new2("ENV");
}</pre>
</div>
</div>
</div>
<div id="method-c-update" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
update(hash) → ENV
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
update(hash) { |name, old_value, new_value| block } → ENV
</span>
</div>
<div class="method-description">
<p>Adds the contents of <code>hash</code> to the environment variables. If no block is specified entries with duplicate keys are overwritten, otherwise the value of each duplicate name is determined by calling the block with the key, its value from the environment and its value from the hash.</p>
<div class="method-source-code" id="update-source">
<pre>static VALUE
env_update(VALUE env, VALUE hash)
{
if (env == hash) return env;
hash = to_hash(hash);
rb_foreach_func *func = rb_block_given_p() ?
env_update_block_i : env_update_i;
rb_hash_foreach(hash, func, 0);
return env;
}</pre>
</div>
</div>
</div>
<div id="method-c-value-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
value?(value) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if there is an environment variable with the given <code>value</code>.</p>
<div class="method-source-code" id="value-3F-source">
<pre>static VALUE
env_has_value(VALUE dmy, VALUE obj)
{
char **env;
obj = rb_check_string_type(obj);
if (NIL_P(obj)) return Qnil;
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;
}</pre>
</div>
</div>
</div>
<div id="method-c-values" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
values → Array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns all environment variable values in an Array:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-string">'foo'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'0'</span>, <span class="ruby-string">'bar'</span> <span class="ruby-operator">=></span> <span class="ruby-string">'1'</span>)
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">values</span> <span class="ruby-comment"># => ['1', '0']</span>
</pre>
<p>The order of the values is OS-dependent. See <a href="#class-ENV-label-About+Ordering">About Ordering</a>.</p>
<p>Returns the empty <a href="Array.html"><code>Array</code></a> if <a href="ENV.html"><code>ENV</code></a> is empty:</p>
<pre class="ruby"><span class="ruby-constant">ENV</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-constant">ENV</span>.<span class="ruby-identifier">values</span> <span class="ruby-comment"># => []</span>
</pre>
<div class="method-source-code" id="values-source">
<pre>static VALUE
env_f_values(VALUE _)
{
return env_values();
}</pre>
</div>
</div>
</div>
<div id="method-c-values_at" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
values_at(name, ...) → Array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns an array containing the environment variable values associated with the given names. See also <a href="ENV.html#method-c-select"><code>ENV.select</code></a>.</p>
<div class="method-source-code" id="values_at-source">
<pre>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;
}</pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.2.1.1.
<p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
</footer>