Kernel

Kernel

모든 루비 객체에서 쓸 수 있는 핵심 메서드들을 제공하는 모듈이에요.

출처: Ruby 3.3 API

본문

Kernel 모듈은 클래스 Object가 포함하므로, 그 메서드들은 모든 루비 객체에서 사용할 수 있어요. Kernel의 인스턴스 메서드들은 클래스 Object에 문서화되어 있고, 모듈 메서드들은 여기에 문서화되어 있어요. 이 메서드들은 수신자 없이 호출되므로 함수 형태로 호출할 수 있어요:

sprintf "%.1f", 1.234 #=> "1.2"

여기 있는 것 (What's Here)

모듈 Kernel은 다음을 위한 메서드를 제공해요.

• 변환: Array, Complex, Float, Hash, Integer, Rational, String — 주어진 인자를 기반으로 각 타입 객체를 돌려줘요.
• 조회: __callee__, __dir__, __method__, autoload?, binding, block_given?, caller, caller_locations, class, frozen?, global_variables, local_variables, test
• 종료: abort, at_exit, exit, exit!
• 예외: catch, raise(별칭 fail), throw
• IO: ::pp, gets, open, p, print, printf, putc, puts, readline, readlines, select
• Proc: lambda, proc
• 추적: set_trace_func, trace_var, untrace_var
• 서브프로세스: `command`, exec, fork, spawn, system
• 로딩: autoload, load, require, require_relative
• 수율(yield): tap, then(별칭 yield_self)
• 난수: rand, srand
• 기타: eval, loop, sleep, sprintf(별칭 format), syscall, trap, warn

더 알아보기: 공개 클래스 메서드 (Public Class Methods)

URI (uri)

주어진 uri(URI 문자열 또는 기존 URI 객체)에서 파생된 URI 객체를 돌려줘요.

uri = URI('http://github.com/ruby/ruby')
# => #<URI::HTTP http://github.com/ruby/ruby>
URI(uri) # => #<URI::HTTP http://github.com/ruby/ruby>

pp (*objs)

인자들을 보기 좋게(pretty form) 출력해요. pp는 인자를 그대로 돌려줘요.

더 알아보기: 공개 인스턴스 메서드 (Public Instance Methods)

Array(object) → object or new_array

object에서 변환된 배열을 돌려줘요. 먼저 to_ary, 다음으로 to_a로 변환을 시도해요:

Array([0, 1, 2])        # => [0, 1, 2]
Array({foo: 0, bar: 1}) # => [[:foo, 0], [:bar, 1]]
Array(0..4)             # => [0, 1, 2, 3, 4]
Array(:foo)             # => [:foo]  # 변환 불가 시 [object]

BigDecimal(value, exception: true) → bigdecimal

value를 소수점 ndigits자리 정밀도의 BigDecimal로 변환해 돌려줘요.

• Integer, Float, Rational, Complex, BigDecimal → 직접 변환 (ndigits 불필요)
• String → 정수·부동소수 리터럴 파싱으로 변환 (앞뒤 공백 무시)
• :to_str에 응답하는 타입 → 먼저 문자열로 변환 후 위와 같이 변환
• 기타 타입 → exception: true면 예외, false면 nil

BigDecimal(2)          # => 0.2e1
BigDecimal('2.0')      # => 0.2e1
BigDecimal(' 2.0 ')    # => 0.2e1

Complex(real, imag = 0, exception: true) → complex or nil

인자가 유효하면 새 Complex 객체를 돌려줘요. 아니면 exception: true면 예외, false면 nil을 돌려줘요.

• Numeric 인자 real, imag → Complex.rect(real, imag)와 동일
• 문자열 인자의 형태:
  • 부호로 구분된 실수·허수 숫자 부분(끝에 'i'): Complex('1+2i') → (1+2i), Complex('1') → (1+0i), Complex('1i') → (0+1i)
  • @로 구분된 극좌표 유리수: Complex('1/2@3/4') → (0.36584443443691045+0.34081938001166706i)

Float(arg, exception: true) → float or nil

arg를 float로 변환해 돌려줘요. Numeric 타입은 직접 변환되고, 난 String·nil 외에는 arg.to_f로 변환돼요. 유효하지 않은 문자의 String은 ArgumentError, nil은 TypeError를 일으켜요.

Float(1)                 #=> 1.0
Float("123.456")         #=> 123.456
Float("123.0_badstring") #=> ArgumentError
Float(nil)               #=> TypeError
Float("123.0_badstring", exception: false) #=> nil

Hash(object) → object or new_hash

object에서 변환된 해시를 돌려줘요.

• 해시면 그대로 돌려줘요.
• 빈 배열이나 nil이면 빈 해시를 돌려줘요.
• object.to_hash가 해시를 돌려주면 그 해시를 돌려줘요.
• 그 외엔 TypeError.

Hash({foo: 0, bar: 1}) # => {:foo=>0, :bar=>1}
Hash(nil)              # => {}
Hash([])               # => {}

Integer(object, base = 0, exception: true) → integer or nil

object에서 변환된 정수를 돌려줘요. to_int 먼저, to_i 다음으로 시도해요. 0이 아닌 base가 주어지면 object는 문자열(또는 문자열로 변환 가능)이어야 해요.

Integer(1)      # => 1
Integer(1.9)    # => 1  # 0을 향해 반올림
Integer(-1.9)   # => -1
Integer('100')  # => 100
Integer('0x100') # => 256  # 0x는 16진수 지정
Integer('100', 2) # => 4
Integer('-1_0_0', 16) # => -256  # 언더스코어 허용
Integer(Rational(9, 10)) # => 0
Integer(Time.now)       # => 1650974042

exception: false를 주면 어떤 예외든 억제하고 nil을 돌려줘요.

Pathname(path) → pathname

주어진 문자열·경로에서 새 Pathname 객체를 만들어 돌려줘요. 이 생성자를 쓰려면 먼저 require 'pathname'이 필요해요.

require 'pathname'
Pathname("/home/zzak") #=> #<Pathname:/home/zzak>

참고: Pathname::new.

Rational(x, y, exception: true) → rational or nil

x/y 또는 arg를 Rational로 돌려줘요.

Rational(2, 3)  #=> (2/3)
Rational(5)     #=> (5/1)
Rational("2/3") #=> (2/3)
Rational("10 cents") #=> ArgumentError
Rational("10 cents", exception: false) #=> nil

String(object) → object or new_string

object에서 변환된 문자열을 돌려줘요. 먼저 to_str, 다음으로 to_s로 변환해요. 변환할 수 없으면 TypeError.

String([0, 1, 2])        # => "[0, 1, 2]"
String({foo: 0, bar: 1}) # => "{:foo=>0, :bar=>1}"

__callee__ → symbol

현재 메서드의 호출된 이름을 Symbol로 돌려줘요. 메서드 밖에서 호출하면 nil.

__dir__ → string

이 메서드가 호출된 파일의 디렉터리 정규화 절대 경로를 돌려줘요. File.dirname(File.realpath(__FILE__))와 같아요.

__method__ → symbol

현재 메서드의 정의 시 이름을 Symbol로 돌려줘요. 메서드 밖에서 호출하면 nil.

`command` → string

서브셸에서 command 실행의 $stdout 출력을 돌려주고, 전역 변수 $?에 프로세스 상태를 설정해요. 신뢰할 수 없는 입력과 함께 호출하면 보안 취약점이 있을 수 있어요(Command Injection 참조).

`date`                 # => "Wed Apr  9 08:56:30 CDT 2003\n"
`echo oops && exit 99` # => "oops\n"
$?                     # => #<Process::Status: pid 17088 exit 99>

내장 문법 %x{...}은 이 메서드를 사용해요.

abort

즉시 실행을 종료해요. 사실상 Kernel.exit(false)를 호출하는 것과 같아요. 문자열 인자 msg가 주어지면 종료 전에 STDERR로 출력돼요.

at_exit { block } → proc

블록을 Proc으로 변환해(호출 지점에 바인딩) 프로그램 종료 시 실행되도록 등록해요. 여러 핸들러가 등록되면 등록의 역순으로 실행돼요.

at_exit { puts "cruel world" }
at_exit { print "goodbye " }
exit
# produces: goodbye cruel world

autoload(const, filename) → nil

const(String 또는 Symbol)가 처음 접근될 때 filename을 로드하도록 (Kernel::require 사용) 등록해요. 이미 autoload로 정의돼 있으면 파일명을 교체하고, autoload가 아니면 아무 것도 하지 않아요.

autoload?(name, inherit=true) → String or nil

name이 autoload로 등록돼 있으면 로드될 파일명을 돌려줘요.

binding → a_binding

호출 지점의 변수·메서드 바인딩을 설명하는 Binding 객체를 돌려줘요. Binding#eval로 이 환경에서 코드를 실행하거나 지역 변수를 추출할 때 쓸 수 있어요.

def get_binding
  binding
end
template = '{name: @name, position: @position}'
eval(template, user.get_binding)

block_given? → true or false

현재 컨텍스트에서 yield가 블록을 실행할 수 있으면 true를 돌려줘요. (iterator? 형태는 약하게 deprecated.)

def try
  if block_given?
    yield
  else
    "no block"
  end
end
try                  #=> "no block"
try { "hello" }      #=> "hello"

callcc {|cont| block } → obj

Continuation 객체를 생성해 블록에 넘겨줘요. 사용 전 require 'continuation' 필요해요. cont.call을 하면 callcc가 그 값으로 돌아와요. 콜 스택을 풀기 위한 대안으로 Kernel#throw도 참고하세요.

caller(start=1, length=nil) → array or nil

현재 실행 스택 — file:line 또는 file:line: in 'method' 형태의 문자열 배열을 돌려줘요. start로 위에서부터 생략할 항목 수를, length로 개수를 제한해요. 범위를 넘기면 해당 범위만 돌려줘요.

caller_locations(start=1, length=nil) → array or nil

현재 실행 스택을 backtrace 위치 객체 배열로 돌려줘요. Thread::Backtrace::Location 참고.

catch([tag]) {|tag| block } → obj

블록을 실행해요. throw가 없으면 블록이 정상 실행되고 마지막 표현식 값을 돌려줘요. throw(tag2, val)가 호출되면 객체_id가 같은 catch 블록을 스택에서 찾아 그 지점에서 중단하고 val(없으면 nil)을 돌려줘요.

catch(1) { 123 }            # => 123
catch(1) { throw(1, 456) }  # => 456
catch(1) { throw(1) }       # => nil
catch(1) {|x| x + 2 }       # => 3

태그 없이 호출하면 새 유니크 객체를 블록 매개변수로 넘겨줘요.

chomp → $_

$_ = $_.chomp(string)과 동일. -p/-n 옵션일 때만 사용 가능.

chop → $_

($_.dup).chop!과 동일하되 nil은 절대 반환하지 않아요. -p/-n 옵션일 때만 사용 가능.

class → class

obj의 클래스를 돌려줘요. class는 루비 예약어이므로 반드시 명시적 수신자로 호출해야 해요.

1.class    #=> Integer
self.class #=> Object

clone(freeze: nil) → an_object

obj의 얕은 복사본을 만들어요. freeze 키워드 인자가 없으면 frozen 상태까지 복사해요. Object#dup에 대한 논의도 참고하세요.

s1 = 'Hello'
s2 = s1.clone  # frozen 상태 포함

클래스별 특성이 있을 수 있고 그럴 땐 해당 클래스의 #initialize_copy에 문서화돼요.

eval(string [, binding [, filename [,lineno]]]) → obj

string의 루비 표현식을 평가해요. binding(Binding 객체)을 주면 그 컨텍스트에서 실행되고, filename·lineno는 문법 오류 보고에 쓰여요.

str = "hello"
eval "str + ' Fred'"                      #=> "hello Fred"

exec([env, ] command_line, options = {})

현재 프로세스를 다음 중 하나로 교체해요 — command_line 문자열을 셸에 넘기거나, exe_path 실행 파일을 직접 호출. exec 시스템 콜로 새 프로세스를 만들어요. 신뢰할 수 없는 입력 주의(Command Injection).

exec('if true; then echo "Foo"; fi') # 셸 예약어
exec('echo', 'hello', 'world')       # 실행 파일 직접 호출
exec('doesnt_exist') # Raises Errno::ENOENT

exit(status = true)

SystemExit를 일으켜 루비 스크립트 종료를 시작하고, 그 예외는 잡을 수 있어요. 종료 상태 status를 OS에 돌려줘요. 실제 최종 종료 직전에 at_exit 루틴과 finalizer를 실행해요.

begin
  exit
  puts 'Never get here.'
rescue SystemExit
  puts 'Rescued a SystemExit exception.'
end
puts 'After begin block.'

exit!(status = false)

즉시 프로세스를 종료해요. exit 핸들러는 호출되지 않아요.

raise

인자 없이 → $!의 예외를 던지거나 $!가 nil이면 RuntimeError. 단일 String → 메시지가 그 문자열인 RuntimeError. 그 외엔 첫 매개변수가 Exception 클래스여야 해요. 이벤트의 원인(Exception#cause)은 자동으로 "현재" 예외($!)로 설정돼요. begin...end 블록의 rescue 절이 잡아요.

raise "Failed to create socket"
raise ArgumentError, "No parameters", caller

fork { ... } → integer or nil

자식 프로세스를 만들어요.

• 블록을 주면 자식에서 실행하고, 종료 시 자식은 상태 0으로 종료돼요.
• 블록이 없으면 부모에서는 자식 pid를, 자식에서는 nil을 돌려줘요.

좀비 프로세스를 피하려면 부모가 Process.wait나 Process.detach를 호출해야 해요. fork를 호출한 스레드만 자식에 복사돼요. 일부 플랫폼에선 없을 수 있으니 블록이 필요하면 ::spawn을 써요.

format

sprintf의 별칭이에요.

frozen? → true or false

obj의 freeze 상태를 돌려줘요.

a = ["a", "b", "c"]
a.freeze  #=> ["a", "b", "c"]
a.frozen? #=> true

gets(sep=$/ [, getline_args]) → string or nil

ARGV($*)의 파일 목록 또는 표준 입력에서 다음 줄을 돌려주고(그리고 $_에 할당), 파일 끝에선 nil. 선택 인자는 레코드 구분자를 지정하고, nil이면 전체를, 빈 문자열이면 문단 단위로 읽어요.

ARGV << "testfile"
print while gets

$_를 암묵 매개변수로 쓰는 스타일은 루비 커뮤니티에서 점차 선호되지 않아요.

global_variables → array

전역 변수 이름들의 배열을 돌려줘요. $~, $+ 같은 특수 정규식 전역 변수는 포함하지만 $1 같은 번호 붙은 것은 포함하지 않아요.

gsub(pattern, replacement) → $_

$_.gsub...과 동일하되 치환이 발생하면 $_이 갱신돼요. -p/-n 옵션일 때만 사용 가능.

iterator? → true or false

Deprecated. block_given?을 쓰세요.

lambda { |...| block } → a_proc

Proc.new와 같되, 결과 Proc은 호출 시 전달되는 매개변수 수를 확인해요.

load(filename, wrap=false) → true

파일 filename의 루비 프로그램을 로드하고 실행해요. $LOAD_PATH에서 파일을 찾고, 없으면 현재 디렉터리 기준 상대 경로로 로드해요. 파일이 없으면 LoadError. wrap이 true면 익명 모듈 아래서 실행해 전역 네임스페이스를 보호해요. 로드된 파일의 지역 변수는 전파되지 않아요.

local_variables → array

현재 지역 변수들의 이름을 돌려줘요.

fred = 1
for i in 1..10
end
local_variables   #=> [:fred, :i]

loop { block }

블록을 반복 실행해요. 블록이 없으면 enumerator를 반환해요. 블록에서 StopIteration이 발생하면 루프가 끝나고 그 예외의 "result" 값을 돌려줘요.

loop do
  print "Input: "
  break if (line = gets) =~ /^q/i
end

open(path, mode = 'r', perm = 0666, **opts) → io or nil

주어진 파일에 연결된 IO 객체를 만들어요. 신뢰할 수 없는 입력 주의(Command Injection).

open('t.txt') # => #<File:t.txt>
open('t.txt') {|f| p f } # => #<File:t.txt (closed)>

자세한 내용은 File.open.

p(object) → obj

각 obj에 대해 $stdout.write(obj.inspect, "\n")을 실행해요. 하나면 그 객체를, 여러 개면 배열을, 없으면 nil을 돌려줘요. 디버깅 목적으로 설계됐어요(CRuby에서 쓰기 동작은 중단 불가).

r = Range.new(0, 4)
p r          # => 0..4
p [r, r, r]  # => [0..4, 0..4, 0..4]

pretty_inspect ()

객체를 pretty print한 결과를 문자열로 돌려줘요. PP 모듈 참고.

print(*objects) → nil

$stdout.print(*objects)와 동일. 각 객체를 to_s로 변환해 stdout에 쓰고, 구분자·레코드 구분자 설정에 따라 분리해요. 인자가 없으면 $_를 출력해요.

objects = [0, 0.0, Rational(0, 1), Complex(0, 0), :zero, 'zero']
print(*objects) # output: 00.00/10+0izerozero

printf(format_string, *objects) → nil

io.write(sprintf(format_string, *objects))와 동일. 형식 문자열에 대한 자세한 내용은 Format Specifications 참고.

printf('%4.4d %10s %2.2f', 24, 24, 24.0) # writes to $stdout
printf($stderr, '%4.4d %10s %2.2f', 24, 24, 24.0) # writes to $stderr

proc { |...| block } → a_proc

Proc.new와 동일.

putc(int) → int

$stdout.putc(int)와 동일. 멀티바이트 문자에 관한 중요 정보는 IO#putc 참고.

puts(*objects) → nil

$stdout.puts(objects)와 동일.

rand(max=0) → number

• 인자 없이 또는 max.to_i.abs == 0 → 0.0 이상 1.0 미만의 난수 float.
• max.abs >= 1 → 0 이상 max.to_i.abs 미만의 난수 정수.
• max가 Range → range.member?(number) == true인 난수.

rand        #=> 0.2725926052826416
rand(100)   #=> 12
rand(-100)  # => 87  # 음수·float 허용되나 놀라운 결과 가능

Kernel.srand으로 난수 시퀀스 재현 가능. Random.rand도 참고.

readline(sep = $/, chomp: false) → string

Kernel#gets와 동일하되 스트림 끝에서 예외(EOFError)를 던져요. chomp은 줄 구분자 제거 여부.

readlines(sep = $/, chomp: false, **enc_opts) → array

Kernel#gets로 end-of-stream까지 얻은 줄들의 배열을 돌려줘요. sep(구분자)·limit(바이트 제한)·chomp(구분자 제거)·enc_opts(인코딩 옵션)를 지원해요.

require_relative(string) → true or false

호출 파일이 있는 디렉터리 기준 상대 경로로 string 라이브러리를 로드해요. 파일이 없으면 LoadError. 처음 로드 시 true, 이미 로드됐다면 false.

select(read_ios, write_ios = [], error_ios = [], timeout = nil) → array or nil

시스템 콜 select(2)를 호출해 여러 파일 디스크립터를 감시해요. 세 배열의 IO 객체를 감시하다 준비된 게 생기면 3-요소 배열(읽기 준비·쓰기 준비·보류 예외 객체 배열)을 돌려줘요. timeout 안에 준비된 게 없으면 nil. 모든 플랫폼에서 구현된 건 아니에요.

최선의 사용법은 read_nonblock, write_nonblock 같은 비차단 메서드 후에 호출하는 거예요. 비차단 블로킹 읽기·쓰기 에뮬레이션:

begin
  result = io_like.read_nonblock(maxlen)
rescue IO::WaitReadable
  IO.select([io_like])
  retry
rescue IO::WaitWritable
  IO.select(nil, [io_like])
  retry
end

set_trace_func(proc) → proc

proc을 추적 핸들러로 설정해요(nil이면 추적 비활성). 이 메서드는 구식이에요. TracePoint를 쓰세요. proc은 최대 6개 매개변수(이벤트명, 파일명, 줄 번호, 메서드명 심볼/nil, binding/nil, 클래스·모듈/nil)를 받아요. 이벤트: c-call, c-return, call, class, end, line, raise, return.

set_trace_func proc { |event, file, line, id, binding, class_or_module|
  printf "%8s %s:%-2d %16p %14p\n", event, file, line, id, class_or_module
}

sleep(secs = nil) → slept_secs

현재 스레드를 secs초 동안(또는 nil이면 영원히) 멈추고, 실제 멈춘(반올림된) 정수 초를 돌려줘요.

sleep 1.2 # => 1
sleep 1.9 # => 2

spawn([env, ] command_line, options = {}) → pid

새 자식 프로세스를 만들어요. 완료를 기다리지 않고 새 프로세스의 pid를 돌려줘요. 좀비를 피하려면 Process.wait나 Process.detach를 호출하세요.

spawn('if true; then echo "Foo"; fi') # => 798847 # 셸 예약어
Process.wait # => 798847
spawn('echo', 'hello', 'world') # => 799393 # 실행 파일 직접 호출

sprintf(format_string *objects) → string

objects를 format_string에 형식화한 결과 문자열을 돌려줘요. Format Specifications 참고.

srand(number = Random.new_seed) → old_seed

시스템 난수 생성기를 number로 시드하고 이전 시드 값을 돌려줘요. 인자를 생략하면 OS 엔트로피(시간·pid·일련번호 조합)로 시드해요. 테스트 시 결정적 동작을 만들 수 있어요.

srand 1234
[rand, rand]           # => [0.1915194503788923, 0.6221087710398319]
srand 1234
[rand, rand]           # => [0.1915194503788923, 0.6221087710398319]

sub(pattern, replacement) → $_

$_.sub(args)와 동일하되 치환이 발생하면 $_이 갱신돼요. -p/-n 옵션일 때만 사용 가능.

syscall(integer_callno, *arguments) → integer

Posix 시스템 콜 syscall(2)을 호출해 지정 함수를 실행해요. 정수 인자는 직접, 문자열 인자는 바이트 시퀀스로 해석해요(최대 9개). integer_callno·인자·반환값은 플랫폼 의존적이에요. 기본적으로 안전하지 않고 이식성이 없으니 Fiddle(DL) 라이브러리가 선호돼요. 모든 플랫폼에 구현된 건 아니에요.

system([env, ] command_line, options = {}, exception: false) → true, false, or nil

새 자식 프로세스를 실행해요. 명령이 0 상태로 종료하면 true, 0이 아닌 정수면 false, 실행할 수 없으면 nil을 돌려줘요. exception: true면 이 값들 대신 예외를 던져요. 명령의 오류 상태를 $?에 할당해요. 신뢰할 수 없는 입력 주의(Command Injection).

system('if true; then echo "Foo"; fi') # => true
system('echo') # => true
$? # => #<Process::Status: pid 640610 exit 0>
system('date > /nop/date.tmp') # => false
system('date > /nop/date.tmp', exception: true) # Raises RuntimeError
system('echo', 'hello', 'world') # => true
system('doesnt_exist') # => nil

tap {|x| block } → obj

self를 블록에 넘기고 나서 self를 돌려줘요. 메서드 체인 중간 결과에 작업을 하기 위한 메서드예요.

(1..10)                  .tap {|x| puts "original: #{x}" }
  .to_a                  .tap {|x| puts "array:    #{x}" }
  .select {|x| x.even? } .tap {|x| puts "evens:    #{x}" }

test(cmd, file1 [, file2] ) → obj

문자 cmd로 파일 검사들을 수행해요.

단일 파일 검사 예: "A"(마지막 접근 시간), "d"(디렉터리 여부), "e"(존재 여부), "f"(일반 파일 여부), "l"(심볼릭 링크 여부), "s"(0이 아닌 크기면 크기, 아니면 nil), "z"(0 길이 여부), "r"/"w"/"x"(읽기·쓰기·실행 가능 여부) 등.

두 파일 검사 예: "-"(동일 여부), "="(수정 시간 동일), "<"(file1 수정 시간이 file2보다 이전), ">"(이후).

then {|x| block } → an_object

self를 블록에 넘기고 블록 결과를 돌려줘요. 메서드 체인에서 값을 흘려보내는 용도로 좋아요. 블록 없이 호출하면 Enumerator를 반환해요.

3.next.then {|x| x**x }.to_s #=> "256"

throw(tag [, obj])

tag를 기다리는 활성 catch 블록의 끝으로 제어를 옮겨요. 해당 catch가 없으면 UncaughtThrowError. 두 번째 인자는 catch 블록의 반환값(기본 nil). 예시는 Kernel::catch 참고.

trace_var(symbol, cmd ) → nil

전역 변수 할당 추적을 제어해요. symbol은 변수를, cmd(문자열 또는 Proc) 또는 블록은 변수가 할당될 때 실행돼요. 블록은 새 값을 매개변수로 받아요. Kernel::untrace_var도 참고.

trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
# produces: $_ is now 'hello'

trap( signal, command ) → obj

시그널 처리를 지정해요. 첫 매개변수는 시그널 이름("SIGALRM" 등, "SIG" 생략 가능) 또는 번호. command가 "IGNORE"/"SIG_IGN"이면 무시, "DEFAULT"/"SIG_DFL"이면 루비 기본, "EXIT"면 스크립트 종료, "SYSTEM_DEFAULT"면 OS 기본 핸들러, 그 외엔 명령·블록 실행. "EXIT" 또는 번호 0은 프로그램 종료 직전에 호출돼요. trap은 주어진 시그널의 이전 핸들러를 돌려줘요.

untrace_var(symbol [, cmd] ) → array or nil

지정된 전역 변수에 대한 추적을 제거하고 nil을 돌려줘요. 명령을 지정하지 않으면 해당 변수의 모든 추적을 제거하고 실제 제거된 명령 배열을 돌려줘요.

warn(*msgs, uplevel: nil, category: nil) → nil

경고가 비활성화돼 있지 않으면 각 메시지를 문자열로 변환하고 줄바꿈을 붙여 Warning.warn으로 전달해요. uplevel은 호출자 프레임 정보를 앞에 붙이고, category는 :deprecated·:experimental 중 하나를 전달해요.

warn("warning 1", "warning 2")
# produces:
# warning 1
# warning 2

yield_self {|x| block } → an_object

self를 블록에 넘기고 블록 결과를 돌려줘요. then의 별칭.

"my string".yield_self {|s| s.upcase } #=> "MY STRING"

비공개 인스턴스 메서드 (Private Instance Methods)

JSON (object, *args)

객체가 문자열 같으면 파싱해 루비 데이터 구조로 돌려주고, 아니면 객체에서 JSON 텍스트를 생성해 돌려줘요. opts는 generate/parse로 각각 전달돼요.

URI (uri)

주어진 uri에서 파생된 URI 객체를 돌려줘요. (공개 클래스 메서드 URI 참고)

gem (gem_name, *requirements)

gem_name의 특정 버전을 활성화해요. requirements는 버전 요구 목록(보통 "= 버전"). Gem::Requirement 참고. 최신 버전을 쓸 거면 호출할 필요가 없어요. 활성화되면 true, 아니면 false. gem을 못 찾거나 버전 요구와 안 맞거나 다른 버전이 이미 활성화됐다면 예외. 모든 require 문 전에 호출해야 해요. 프리릴리즈 버전은 프리릴리즈 요구가 주어질 때만 로드돼요.

gem 'rake', '>= 1.1.a', '< 2'

j (*objs)

objs를 가장 짧은 형태(한 줄)의 JSON 문자열로 STDOUT에 출력해요.

jj (*objs)

objs를 들여쓰기된 여러 줄의 pretty JSON 문자열로 STDOUT에 출력해요.

pp (*objs)

인자들을 보기 좋게 출력해요. pp는 인자를 그대로 돌려줘요.

require (path)

RubyGems가 로드되면 Kernel#require가 gem을 필요 시 로드할 수 있는 것으로 대체돼요. require 'x' 호출 시, 이미 루비 로드패스에서 로드되면 그렇게 하고, 아니면 설치된 gem에서 일치 파일을 찾아 해당 gem을 활성화해요. 이미 로드된 파일에 대해 false를 돌려주는 일반 require 동작은 유지돼요.

y (*objects)

Psych.dump_stream의 별칭으로 IRB에서 쓰도록 만들어진 메서드예요.