ENV 클래스

ENV 클래스 (객체)

ENV는 환경 변수에 대한 해시처럼 접근하는(hash-like) 접근자예요. OS의 환경 변수를 Ruby 코드에서 읽고 쓰고 지울 수 있게 해 주죠.

운영체제와의 상호작용

ENV 객체는 운영체제의 환경 변수와 상호작용해요:

ENV에서 어떤 이름의 값을 가져오면, 그 값은 현재 환경 변수들 사이에서 가져와져요.
ENV에서 이름-값 쌍을 만들거나 설정하면, 그 즉시 환경 변수에 설정돼요.
ENV에서 이름-값 쌍을 지우면, 그 즉시 환경 변수에서 사라져요.

이름과 값

일반적으로 이름이나 값은 String이에요.

유효한 이름과 값: 각 이름이나 값은 String이거나, #to_str에 응답해 String을 돌려주는 객체 중 하나여야 해요. 후자의 경우 그 String이 이름이나 값으로 쓰여요.

유효하지 않은 이름과 값:

새 이름은:

빈 문자열이면 안 돼요: ENV[''] = '0' → Errno::EINVAL
"=" 문자를 포함하면 안 돼요: ENV['='] = '0' → Errno::EINVAL

새 이름이나 값은:

#to_str에 응답하지 않는 비-String이면 안 돼요: ENV['foo'] = Object.new → TypeError
NUL 문자 "\0"를 포함하면 안 돼요: ENV['foo'] = "\0" → ArgumentError (null byte)
UTF-16LE, ISO-2022-JP 같은 ASCII 비호환 인코딩이면 안 돼요: ENV['foo'] = '0'.force_encoding(Encoding::ISO_2022_JP) → ArgumentError

순서에 대하여

ENV는 운영체제의 환경 변수에서 발견되는 순서대로 이름/값 쌍을 열거해요. 그래서 ENV 내용의 순서는 OS에 의존적이고, 결정적이지 않을 수 있어요. 이는 ENV 메서드가 돌려주는 Hash·Enumerator·배열·inspect 문자열·shift 배열·key 이름 등에서 나타나요.

예시에 대하여

ENV의 일부 메서드는 ENV 자신을 돌려줘요. 예시에 거대한 ENV를 보여주는 건 유용하지 않으니, 대부분의 예시 스니펫은 ENV.replace(새 컬렉션으로 교체)나 ENV.clear(비우기)로 시작해요.

여기 있는 것들 (What's Here)

먼저, 다른 곳에 있는 것들. ENV 클래스(객체)는:

Object 클래스에서 상속받아요.
모듈 Enumerable을 extend해요.

여기서 ENV는 다음 용도에 유용한 메서드들을 제공해요:

조회(Querying)
할당(Assigning)
삭제(Deleting)
반복(Iterating)
변환(Converting)
그리고 더…

조회 메서드

::[]: 주어진 환경 변수 이름의 값이 있으면 돌려줘요.
::empty?: ENV가 비어 있는지.
::has_value?, ::value?: 주어진 값이 ENV에 있는지.
::include?, ::has_key?, ::key?, ::member?: 주어진 이름이 ENV에 있는지.
::key: 주어진 값을 가진 첫 항목의 이름.
::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: 예외 발생.
::except: 주어진 것들을 제외한 모든 이름/값 쌍의 해시.
::fetch: 주어진 이름의 값.
::inspect: ENV 내용을 문자열로.
::invert: ENV 값이 키, 그에 대응하는 ENV 이름이 값인 해시.
::keys: 모든 이름의 배열.
::rassoc: 주어진 값을 가진 첫 번째 발견 항목의 이름과 값.
::reject: 블록이 거부하지 않은 항목들의 해시.
::select, ::filter: 블록이 고른 이름/값 쌍의 해시.
::slice: 주어진 이름들과 그에 대응하는 값들의 해시.
::to_a: 항목들을 2-요소 Array의 배열로.
::to_h: 블록이 고른 항목들의 해시.
::to_hash: 모든 항목들의 해시.
::to_s: 문자열 'ENV'.
::values: 모든 값의 배열.
::values_at: 주어진 이름들에 대한 값의 배열.

더 많은 메서드

::dup: 예외 발생.
::freeze: 예외 발생.
::rehash: ENV를 수정하지 않고 nil을 돌려줘요.

클래스 메서드

ENV[name] → value — 환경 변수 name의 값이 있으면 돌려줘요: ENV['foo'] = '0'; ENV['foo'] # => "0". 없으면 nil. name이 유효하지 않으면 예외.
ENV[name] = value → value — 이름 있는 환경 변수를 만들거나, 갱신하거나, 삭제하고 값을 돌려줘요.
- 이름 있는 변수가 없을 때: value가 nil이면 아무것도 안 해요. nil이 아니면 만들고 name과 value로 설정해요.
- 이름 있는 변수가 있을 때: value가 nil이 아니면 갱신, nil이면 삭제해요.
```
ENV.clear
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
ENV['foo'] = '0' # => '0'
ENV['foo'] # => '0'
ENV['foo'] = nil # => nil
ENV.include?('foo') # => false
```
assoc(name) → [name, value] or nil — 환경 변수 name의 이름과 값을 담은 2-요소 Array를 돌려줘요: ENV.assoc('foo') # => ['foo', '0']. 그런 변수가 없거나, name이 빈 문자열/'=' 포함이면 nil. 유효하지 않은 이름이면 예외 (NUL, ASCII 비호환 인코딩, 비-String).
clear → ENV — 모든 환경 변수를 제거하고 ENV를 돌려줘요.
clone(freeze: nil) # raises TypeError — 프로세스 전역 환경 변수 래퍼를 복제하는 건 무의미하므로 TypeError. ENV 데이터 사본이 필요하면 to_h를 쓰세요.
delete(name) → value — 존재하면 name 환경 변수를 삭제하고 그 값을 돌려줘요: ENV.delete('foo') # => '0'. 블록 없이 존재하지 않으면 nil. 블록을 주고 존재하지 않으면 name을 블록에 넘기고 블록 값을 돌려줘요. 존재하면 삭제하고 값을 돌려줘요 (블록 무시).
```
ENV.delete('foo') { |name| name * 2 } # => "foofoo"
```
delete_if { |name, value| block } → ENV — 각 이름/값 쌍(2-요소 Array)을 블록에 넘기고, 블록이 truthy를 돌려주는 환경 변수마다 삭제해 ENV를 돌려줘요. 블록이 없으면 Enumerator.
dup # raises TypeError — ENV는 싱글턴 객체라 TypeError. to_h를 쓰세요.
each { |name, value| block } → ENV — 각 이름/값 쌍을 2-요소 Array로 블록에 넘겨요. 블록이 없으면 Enumerator.
each_key { |name| block } → ENV — 각 이름을 블록에 넘겨요. 블록이 없으면 Enumerator.
each_value { |value| block } → ENV — 각 값을 블록에 넘겨요. 블록이 없으면 Enumerator.
empty? → true or false — 환경 변수가 없으면 true: ENV.clear; ENV.empty? # => true
except(*keys) → a_hash — ENV에서 주어진 키들(과 그 값)을 제외한 해시를 돌려줘요: ENV.except("TERM","HOME") #=> {"LANG"=>"en_US.UTF-8"}
fetch(name) → value — name이 환경 변수 이름이면 그 값을 돌려줘요. 아니면 블록이 있으면 name을 블록에 넘기고 반환값을, 기본값이 있으면 그 기본값을 돌려줘요. 블록과 기본값을 모두 주면 경고("block supersedes default value argument")를 내고 블록 반환값을 돌려줘요. 기본값도 블록도 없는데 찾지 못하면 KeyError.
```
ENV.fetch('foo') # => '0'
ENV.fetch('foo') { |name| :need_not_return_a_string } # => :need_not_return_a_string
ENV.fetch('foo', :default) # => :default
```
select { |name, value| block } → hash (filter) — 각 이름/값 쌍을 넘기고, 블록이 truthy를 돌려주는 이름/값의 Hash를 돌려줘요. 블록이 없으면 Enumerator.
select! { |name, value| block } → ENV or nil (filter!) — 블록이 false/nil을 돌려주는 각 항목을 삭제하고, 삭제가 있었다면 ENV, 아니면 nil을 돌려줘요. 블록이 없으면 Enumerator.
freeze — 예외 발생: ENV.freeze # Raises TypeError (cannot freeze ENV)
include?(name) → true or false — 주어진 name의 환경 변수가 있으면 true. 유효한 String인데 없거나, 빈 문자열/'=' 포함이면 false. 유효하지 않으면 예외 (NUL, ASCII 비호환, 비-String).
value?(value) → true or false — value가 어떤 환경 변수 이름의 값이면 true: ENV.value?('0') # => true, ENV.has_value?('2') # => false
inspect → a_string — 환경 내용을 문자열로: ENV.inspect # => "{\"bar\"=>\"1\", \"foo\"=>\"0\"}"
invert → hash — ENV 값이 키, 그에 대응하는 ENV 이름이 값인 Hash: ENV.invert # => {"1"=>"bar", "0"=>"foo"}. 중복 값은 해시 항목을 덮어써요. 순서는 OS 의존.
keep_if { |name, value| block } → ENV — 블록이 false/nil을 돌려주는 각 환경 변수를 삭제하고 ENV를 돌려줘요. 블록이 없으면 Enumerator.
key(value) → name or nil — value를 가진 첫 환경 변수의 이름: ENV.key('0') # => "foo". 그런 값이 없으면 nil. value가 유효하지 않으면 예외. 순서는 OS 의존.
keys → array — 모든 변수 이름의 배열: ENV.keys # => ['bar', 'foo']. 순서는 OS 의존. 비어 있으면 빈 Array.
length → an_integer (size) — 환경 변수 개수: ENV.length # => 2
update → ENV (merge!) — 주어진 hash의 각 키/값 쌍을 ENV에 더하고 ENV를 돌려줘요. 해시 값이 nil이면 해당 ENV 항목을 삭제해요. 이미 있는 이름은 블록 없이 값만 덮어쓰고, 블록이 있으면 이름·ENV 값·해시 값을 넘기고 블록 반환값을 새 값으로 써요.
```
ENV.merge!('baz' => '2', 'bat' => '3') # => {"bar"=>"1", "bat"=>"3", "baz"=>"2", "foo"=>"0"}
ENV.merge!('foo' => '5') { |name, env_val, hash_val | env_val + hash_val } # => {"bar"=>"1", "foo"=>"45"}
```
유효하지 않은 이름/값이 나오면 예외를 던져요. 예외보다 앞선 해시 쌍은 정상 처리되고, 뒤따르는 것들은 무시돼요.
rassoc(value) → [name, value] or nil — 값 value를 가진 첫 번째로 발견된 환경 변수의 이름과 값을 담은 2-요소 Array. 순서는 OS 의존.
rehash → nil — (Hash 호환용.) ENV를 수정하지 않고 nil을 돌려줘요.
reject { |name, value| block } → hash — 블록이 truthy를 돌려주는 이름/값 쌍을 결과 Hash에 더하고, 아니면 무시해요. 블록이 없으면 Enumerator.
reject! { |name, value| block } → ENV or nil — ENV.delete_if와 비슷하지만 변경이 없으면 nil을 돌려줘요. 블록이 없으면 Enumerator.
replace(hash) → ENV — 환경 변수의 전체 내용을 주어진 hash의 이름/값 쌍으로 교체하고 ENV를 돌려줘요: ENV.replace('foo' => '0', 'bar' => '1') # => ENV. 유효하지 않은 이름/값이 있으면 예외 (TypeError).
shift → [name, value] or nil — 첫 환경 변수를 ENV에서 제거하고 그 이름/값을 담은 2-요소 Array를 돌려줘요. 어떤 변수가 "첫 번째"인지는 OS 의존. 비어 있으면 nil.
slice(*names) → hash — 주어진 ENV 이름들과 그에 대응하는 값들의 Hash: ENV.slice('foo', 'baz') # => {"foo"=>"0", "baz"=>"2"}. 어떤 names가 유효하지 않으면 예외.
to_a → array — ENV 내용을 2-요소 Array(각각 이름/값 쌍)의 Array로: ENV.to_a # => [["bar", "1"], ["foo", "0"]]
to_h → hash — 블록 없이 ENV의 모든 이름/값 쌍을 담은 Hash. 블록과 함께: 각 이름/값 쌍을 블록에 넘기고, 블록은 결과 Hash에 키/값으로 더해질 2-요소 Array를 돌려줘야 해요. 블록이 Array를 돌려주지 않으면 TypeError, 크기가 잘못되면 ArgumentError.
```
ENV.to_h { |name, value| [name.to_sym, value.to_i] } # => {bar: 1, foo: 0}
```
to_hash → hash — ENV의 모든 이름/값 쌍을 담은 Hash.
to_s → "ENV" — 문자열 'ENV'를 돌려줘요: ENV.to_s # => "ENV"
values → array — 모든 환경 변수 값의 배열: ENV.values # => ['1', '0']. 순서는 OS 의존. 비어 있으면 빈 Array.
values_at(*names) → array — 주어진 이름들과 연관된 환경 변수 값들의 Array: ENV.values_at('foo', 'baz') # => ["0", "2"]. ENV 이름이 아닌 이름마다 nil을 넣어요. 이름이 없으면 빈 Array. 유효하지 않으면 예외.

출처: Ruby 4.0 API - ENV