ARGF 클래스

ARGF 클래스

ARGF는 명령줄 인자로 주어지거나 STDIN으로 전달되는 파일을 처리하는 스크립트를 위한 스트림이에요. 여러 파일을 연속된 하나의 입력처럼 다루는 데 써요.

출처: Ruby 4.0 API

본문

ARGF와 ARGV

ARGF 객체는 전역 변수 ARGV에 있는 배열과 함께 동작해서, $stdin과 파일 스트림을 Ruby 프로그램에서 쓸 수 있게 해 줘요.

  • ARGV 는 argument vector(인자 벡터) 배열이라고 생각하면 돼요. 처음에는 Ruby 프로그램에 전달된 명령줄 인자와 옵션을 담고 있고, 프로그램이 이 배열을 마음대로 바꿀 수 있어요.
  • ARGF 는 argument files(인자 파일) 객체라고 생각하면 돼요. ARGV에서 무엇을 찾느냐에 따라 파일 스트림과/또는 $stdin 스트림에 접근할 수 있어요. 이로써 명령줄이 Ruby 프로그램이 읽을 스트림을 손쉽게 지정할 수 있게 돼요.

Reading(읽기)

ARGF는 source(소스) 스트림에서 읽을 수 있는데, 특정 시점의 소스는 ARGV의 내용에 의해 결정돼요.

가장 단순한 경우

가장 처음 ARGF 읽기가 ARGV가 비어 있으면서([]) 발생하면, 소스는 $stdin이에요:

파일 t.rb:

p ['ARGV', ARGV]
p ['ARGF.read', ARGF.read]

명령과 출력(foo.txt, bar.txt 파일의 내용은 아래 참고):

$ echo "Open the pod bay doors, Hal." | ruby t.rb
["ARGV", []]
["ARGF.read", "Open the pod bay doors, Hal.\n"]

$ cat foo.txt bar.txt | ruby t.rb
["ARGV", []]
["ARGF.read", "Foo 0\nFoo 1\nBar 0\nBar 1\nBar 2\nBar 3\n"]

예시에 관해

여기 예시들은 대부분 foo.txt 와 bar.txt 파일이 있다고 가정해요:

$ cat foo.txt
Foo 0
Foo 1
$ cat bar.txt
Bar 0
Bar 1
Bar 2
Bar 3

ARGV 안의 소스

가장 단순한 경우를 제외한 모든 ARGF 읽기(즉 *가장 처음이면서 ARGV가 비어 있지 않은 경우)*에서 소스는 ARGV 에서 찾아요.

ARGF 는 배열 ARGV 의 각 요소가 잠재적 소스라고 가정하며, 그 요소는 다음 중 하나예요:

  • 스트림으로 열 수 있는 파일의 문자열 경로.
  • 문자 '-' 로, $stdin 스트림을 의미해요.

이 중 하나가 아닌 각 요소는 ARGF 가 그 소스에 접근하기 전에 ARGV 에서 제거해야 해요. 다음 예시에서:

  • 파일 경로 foo.txt 와 bar.txt 는 잠재적 소스로 유지할 수 있어요.
  • 옵션 --xyzzy 와 --mojo 는 제거해야 해요.

예시:

파일 t.rb:

# Print arguments (and options, if any) found on command line.
p ['ARGV', ARGV]

명령과 출력:

$ ruby t.rb --xyzzy --mojo foo.txt bar.txt
["ARGV", ["--xyzzy", "--mojo", "foo.txt", "bar.txt"]]

ARGF 의 스트림 접근은 ARGV 의 요소를 왼쪽에서 오른쪽으로 고려해요:

파일 t.rb:

p "ARGV: #{ARGV}"
p "Read: #{ARGF.read}" # Read everything from all specified streams.

명령과 출력:

$ ruby t.rb foo.txt bar.txt
"ARGV: [\"foo.txt\", \"bar.txt\"]"
"Read: Foo 0\nFoo 1\nBar 0\nBar 1\nBar 2\nBar 3\n"

ARGV 의 값은 평범한 배열이므로, 이를 조작해서 ARGF 가 고려할 소스를 제어할 수 있어요:

  • ARGV 에서 요소를 제거하면 ARGF 는 그에 해당하는 소스를 고려하지 않아요.
  • ARGV 에 요소를 추가하면 ARGF 는 그에 해당하는 소스를 고려해요.

ARGV 의 각 요소는 그에 해당하는 소스에 접근할 때 제거돼요. 모든 소스에 접근하고 나면 배열은 비게 돼요:

파일 t.rb:

until ARGV.empty? && ARGF.eof?
  p "ARGV: #{ARGV}"
  p "Line: #{ARGF.readline}" # Read each line from each specified stream.
end

명령과 출력:

$ ruby t.rb foo.txt bar.txt
"ARGV: [\"foo.txt\", \"bar.txt\"]"
"Line: Foo 0\n"
"ARGV: [\"bar.txt\"]"
"Line: Foo 1\n"
"ARGV: [\"bar.txt\"]"
"Line: Bar 0\n"
"ARGV: []"
"Line: Bar 1\n"
"ARGV: []"
"Line: Bar 2\n"
"ARGV: []"
"Line: Bar 3\n"

ARGV 의 파일 경로

ARGV 배열은 ARGF 읽기의 소스를 지정하는 파일 경로를 담을 수 있어요. 이 프로그램은 명령줄에 지정된 경로의 파일에서 읽은 내용을 출력해요:

파일 t.rb:

p ['ARGV', ARGV]
# Read and print all content from the specified sources.
p ['ARGF.read', ARGF.read]

명령과 출력:

$ ruby t.rb foo.txt bar.txt
["ARGV", [foo.txt, bar.txt]
["ARGF.read", "Foo 0\nFoo 1\nBar 0\nBar 1\nBar 2\nBar 3\n"]

ARGV 에서 $stdin 지정

ARGV 에서 $stdin 스트림을 지정하려면 문자 '-' 를 써요:

파일 t.rb:

p ['ARGV', ARGV]
p ['ARGF.read', ARGF.read]

명령과 출력:

$ echo "Open the pod bay doors, Hal." | ruby t.rb -
["ARGV", ["-"]]
["ARGF.read", "Open the pod bay doors, Hal.\n"]

문자 '-' 를 주지 않으면 $stdin 스트림은 무시돼요:

$ echo "Open the pod bay doors, Hal." | ruby t.rb foo.txt bar.txt
["ARGV", ["foo.txt", "bar.txt"]]
["ARGF.read", "Foo 0\nFoo 1\nBar 0\nBar 1\nBar 2\nBar 3\n"]

ARGV 의 혼합과 반복

ARGF 리더에게 ARGV 는 파일 경로와 문자 '-' 의 어떤 혼합이든 담을 수 있고, 반복도 허용돼요.

ARGV 수정

실행 중인 Ruby 프로그램은 ARGV 배열을 어떤 방식으로든 수정할 수 있어요. 현재의 ARGV 값이 ARGF 읽기에 영향을 줘요.

빈 ARGV

빈 ARGV 에 대해 ARGF 읽기 메서드는 특정 메서드에 따라 nil 을 돌려주거나 예외를 발생시켜요.

더 많은 읽기 메서드

위에서 봤듯이 ARGF#read 메서드는 모든 소스의 내용을 하나의 문자열로 읽어요. 다른 ARGF 메서드는 그 내용에 접근하는 다른 방법을 제공해요:

  • 바이트 접근: each_byte, getbyte, readbyte.
  • 문자 접근: each_char, getc, readchar.
  • 코드포인트 접근: each_codepoint.
  • 줄 접근: each_line, gets, readline, readlines.
  • 소스 접근: read, read_nonblock, readpartial.

Enumerable에 관해

ARGF 는 Enumerable 모듈을 포함해요. Enumerable 의 거의 모든 메서드는 포함하는 클래스의 each 메서드를 호출해요.

잘 새겨두세요: ARGF 에서 each 메서드는 ARGV 가 아니라 소스 에서 데이터를 돌려줘요. 그래서 예를 들어 ARGF#entries 는 소스의 줄 배열을 돌려주지, ARGV 의 문자열 배열을 돌려주지 않아요:

파일 t.rb:

p ['ARGV', ARGV]
p ['ARGF.entries', ARGF.entries]

명령과 출력:

$ ruby t.rb foo.txt bar.txt
["ARGV", ["foo.txt", "bar.txt"]]
["ARGF.entries", ["Foo 0\n", "Foo 1\n", "Bar 0\n", "Bar 1\n", "Bar 2\n", "Bar 3\n"]]

Writing(쓰기)

인플레이스 모드(inplace mode) 가 적용 중이면 ARGF 는 대상 스트림에 쓸 수 있는데, 특정 시점의 대상은 ARGV 의 내용으로 결정돼요.

인플레이스 모드에 관한 메서드:

  • inplace_mode
  • inplace_mode=
  • to_write_io

쓰기용 메서드:

  • print
  • printf
  • putc
  • puts
  • write

Public Instance Methods

argv → ARGV

스크립트에 전달된 인자를 요소 하나당 하나씩 담고 있는 ARGV 배열을 돌려줘요.

$ ruby argf.rb -v glark.txt

ARGF.argv   #=> ["-v", "glark.txt"]

binmode → ARGF

ARGF 를 바이너리 모드로 전환해요. 일단 스트림이 바이너리 모드가 되면 다시 해제할 수 없어요. 다음과 같은 효과가 있어요:

  • 개행 변환 비활성화.
  • Encoding 변환 비활성화.
  • 콘텐츠를 ASCII-8BIT로 취급.

binmode? → true or false

ARGF 가 바이너리 모드로 읽히고 있으면 true, 그 외에는 false 를 돌려줘요. 바이너리 모드를 켜려면 ARGF.binmode 를 사용해요.

ARGF.binmode?  #=> false
ARGF.binmode
ARGF.binmode?  #=> true

close → ARGF

현재 파일을 닫고 ARGV 의 다음 파일로 건너뛰어요. 열 파일이 더 없다면 현재 파일만 닫아요. STDIN은 닫히지 않아요.

$ ruby argf.rb foo bar

ARGF.filename  #=> "foo"
ARGF.close
ARGF.filename  #=> "bar"
ARGF.close

closed? → true or false

현재 파일이 닫혀 있으면 true, 그 외에는 false 를 돌려줘요. 실제로 현재 파일을 닫으려면 ARGF.close 를 사용해요.

each(sep=$/) {|line| block } → ARGF

each(sep=$/, limit) {|line| block } → ARGF

each(...) → an_enumerator

ARGV 의 각 파일의 각 줄(기본값은 플랫폼의 개행 문자로 구분된 sep)을 순회하는 열거자(enumerator)를 돌려줘요. 블록이 주어지면 각 줄을 차례로 블록에 yield 하고, 아니면 열거자를 돌려줘요. 선택적 limit 인자는 각 줄의 최대 길이를 지정하는 Integer 이며, 더 긴 줄은 이 제한에 따라 잘려요.

이 메서드로 명령줄에 제공된 파일들을 각 이름 붙은 파일의 연결로 이루어진 단일 파일처럼 다룰 수 있어요. 첫 파일의 마지막 줄을 돌려준 뒤 두 번째 파일의 첫 줄을 돌려줘요. ARGF.filename 과 ARGF.lineno 로 각각 현재 줄의 파일명과 전체 입력 기준의 줄 번호를 알 수 있어요.

예를 들어, 다음 코드는 각 이름 붙은 파일의 각 줄을 줄 번호와 함께 출력하고 파일명은 파일당 한 번 표시해요:

ARGF.each_line do |line|
  puts ARGF.filename if ARGF.file.lineno == 1
  puts "#{ARGF.file.lineno}: #{line}"
end

반면 다음 코드는 처음에 첫 파일의 이름만 출력하고, 내용은 모든 이름 붙은 파일에 걸쳐 누적된 줄 번호와 함께 출력해요:

ARGF.each_line do |line|
  puts ARGF.filename if ARGF.lineno == 1
  puts "#{ARGF.lineno}: #{line}"
end

each_line 의 별칭이기도 해요.

each_byte {|byte| block } → ARGF

each_byte → an_enumerator

ARGV 의 각 파일의 각 바이트를 순회해요. 바이트는 0..255 범위의 Integer 로 돌려줘요. 명령줄의 파일들을 하나의 연결 파일처럼 다루며, 블록이 없으면 열거자를 돌려줘요.

ARGF.bytes.to_a  #=> [35, 32, ... 95, 10]

each_char {|char| block } → ARGF

each_char → an_enumerator

ARGF 의 각 파일의 각 문자를 순회해요. 파일들을 하나의 연결 파일처럼 다루며, 블록이 없으면 열거자를 돌려줘요.

each_codepoint {|codepoint| block } → ARGF

each_codepoint → an_enumerator

ARGF 의 각 파일의 각 코드포인트를 순회해요. 파일들을 하나의 연결 파일처럼 다루며, 블록이 없으면 열거자를 돌려줘요.

each_line(sep=$/) {|line| block } → ARGF

each_line(sep=$/, limit) {|line| block } → ARGF

each_line(...) → an_enumerator

각 줄을 순회하는 열거자를 돌려줘요. each 의 동작과 같고, each 의 별칭이에요. (자세한 설명은 each 항목 참고.)

ARGF.each_line do |line|
  puts ARGF.filename if ARGF.file.lineno == 1
  puts "#{ARGF.file.lineno}: #{line}"
end

eof → true or false

ARGF 의 현재 파일이 파일 끝(EOF, 더 읽을 데이터가 없음)이면 true 를 돌려줘요. 스트림은 읽기용으로 열려 있어야 하며, 아니면 IOError 가 발생해요.

$ echo "eof" | ruby argf.rb

ARGF.eof?                 #=> false
3.times { ARGF.readchar }
ARGF.eof?                 #=> false
ARGF.readchar             #=> "\n"
ARGF.eof?                 #=> true

eof? 의 별칭이기도 해요.

eof? → true or false

ARGF 의 현재 파일이 EOF면 true 를 돌려줘요. eof 의 별칭이에요. (자세한 설명은 eof 항목 참고.)

external_encoding → encoding

ARGF 에서 읽은 파일의 외부 인코딩을 Encoding 객체로 돌려줘요. 외부 인코딩은 파일에 저장된 텍스트의 인코딩이에요. Ruby 내부에서 이 텍스트를 나타내는 데 쓰는 인코딩인 ARGF.internal_encoding 과 대비돼요. 외부 인코딩을 설정하려면 ARGF.set_encoding 을 사용해요.

ARGF.external_encoding  #=>  #<Encoding:UTF-8>

file → IO or File object

현재 파일을 IO 또는 File 객체로 돌려줘요. 현재 파일이 STDIN이면 $stdin 을 돌려줘요.

$ echo "foo" > foo
$ echo "bar" > bar

$ ruby argf.rb foo bar

ARGF.file      #=> #<File:foo>
ARGF.read(5)   #=> "foo\nb"
ARGF.file      #=> #<File:bar>

filename → String

현재 파일명을 돌려줘요. 현재 파일이 STDIN이면 "-" 를 돌려줘요.

$ echo "foo" > foo
$ echo "bar" > bar
$ echo "glark" > glark

$ ruby argf.rb foo bar glark

ARGF.filename  #=> "foo"
ARGF.read(5)   #=> "foo\nb"
ARGF.filename  #=> "bar"
ARGF.skip
ARGF.filename  #=> "glark"

path 의 별칭이기도 해요.

fileno → integer

현재 파일의 숫자 파일 디스크립터를 나타내는 정수를 돌려줘요. 현재 파일이 없으면 ArgumentError 를 던져요.

ARGF.fileno    #=> 3

to_i 의 별칭이기도 해요.

getbyte → Integer or nil

ARGF 에서 다음 8비트 바이트(0..255)를 가져와요. 스트림 끝에서 호출하면 nil 을 돌려줘요.

$ echo "foo" > file
$ ruby argf.rb file

ARGF.getbyte #=> 102
ARGF.getbyte #=> 111
ARGF.getbyte #=> 111
ARGF.getbyte #=> 10
ARGF.getbyte #=> nil

getc → String or nil

ARGF 에서 다음 문자를 읽어 String 으로 돌려줘요. 스트림 끝에서는 nil 을 돌려줘요. 명령줄에 이름 붙은 파일들을 하나의 연결 파일처럼 다룬다는 점에 주의하세요.

$ echo "foo" > file
$ ruby argf.rb file

ARGF.getc  #=> "f"
ARGF.getc  #=> "o"
ARGF.getc  #=> "o"
ARGF.getc  #=> "\n"
ARGF.getc  #=> nil
ARGF.getc  #=> nil

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

gets(limit [, getline_args]) → string or nil

gets(sep, limit [, getline_args]) → string or nil

ARGF 의 현재 파일에서 다음 줄을 돌려줘요. 기본적으로 줄을 $/ 로 구분한다고 가정하며, 다른 구분 문자를 쓰려면 sep 인자에 문자열로 주면 돼요. 선택적 limit 인자는 각 줄에서 돌려줄 문자 수를 지정하며, 기본적으로 모든 문자가 돌려줘요. getline_args에 대한 자세한 내용은 IO.readlines 를 참고하세요.

inplace_mode → String

인플레이스 편집(in-place edit) 모드에서 수정된 파일의 백업 복사본 이름에 붙는 파일 확장자를 돌려줘요. 이 값은 ARGF.inplace_mode= 로 설정하거나 Ruby 바이너리에 -i 스위치를 전달해 설정할 수 있어요.

inplace_mode = ext → ARGF

인플레이스 편집 모드의 파일명 확장자를 주어진 String 으로 설정해요. 편집 중인 각 파일의 백업 복사본 이름에 이 값이 붙어요.

$ ruby argf.rb file.txt

ARGF.inplace_mode = '.bak'
ARGF.each_line do |line|
  print line.sub("foo","bar")
end

먼저 file.txt.bak 이 file.txt 의 백업으로 생성되고, 그다음 file.txt 의 각 줄에서 첫 번째 "foo" 가 "bar" 로 바뀌어요.

internal_encoding → encoding

ARGF 에서 읽은 문자열의 내부 인코딩을 Encoding 객체로 돌려줘요. ARGF.set_encoding 이 인코딩 이름 두 개로 호출됐다면 두 번째가 돌려줘요. 그 외에는 Encoding.default_external 이 설정돼 있으면 그 값이, 명령줄에서 기본 외부 인코딩이 지정됐다면 그 값이 돌려줘요. 인코딩을 알 수 없으면 nil 을 돌려줘요.

lineno → integer

ARGF 전체의 현재 줄 번호를 돌려줘요. 이 값은 ARGF.lineno= 로 수동 설정할 수 있어요.

ARGF.lineno   #=> 0
ARGF.readline #=> "This is line 1\n"
ARGF.lineno   #=> 1

lineno = integer → integer

ARGF 전체의 줄 번호를 주어진 Integer 로 설정해요. ARGF 는 데이터를 읽으며 줄 번호를 자동으로 설정하므로, 보통은 직접 설정할 필요가 없어요. 현재 줄 번호에 접근하려면 ARGF.lineno 를 사용해요.

ARGF.lineno      #=> 0
ARGF.readline    #=> "This is line 1\n"
ARGF.lineno      #=> 1
ARGF.lineno = 0  #=> 0
ARGF.lineno      #=> 0

path → String

현재 파일명을 돌려줘요. 현재 파일이 STDIN이면 "-" 를 돌려줘요. filename 의 별칭이에요. (자세한 설명은 filename 항목 참고.)

pos → Integer

현재 파일의 현재 오프셋(바이트 단위)을 돌려줘요. tell 의 별칭이에요.

ARGF.pos    #=> 0
ARGF.gets   #=> "This is line one\n"
ARGF.pos    #=> 17

pos = position → Integer

ARGF 에서 position(바이트 단위)이 주는 위치로 시크(seek)해요.

ARGF.pos = 17
ARGF.gets   #=> "This is line two\n"

print(*objects) → nil

주어진 객체들을 스트림에 쓰고 nil 을 돌려줘요. 출력 레코드 구분자 $OUTPUT_RECORD_SEPARATOR($\)가 nil 이 아니면 이를 붙여요.

objects 인자가 주어지면 각 객체에 대해:

  • 문자열이 아니면 to_s 메서드로 변환.
  • 스트림에 쓰기.
  • 마지막 객체가 아니면 출력 필드 구분자 $OUTPUT_FIELD_SEPARATOR($,)가 nil 이 아니면 이를 쓰기.

기본 구분자 사용 시:

f = File.open('t.tmp', 'w+')
objects = [0, 0.0, Rational(0, 1), Complex(0, 0), :zero, 'zero']
p $OUTPUT_RECORD_SEPARATOR
p $OUTPUT_FIELD_SEPARATOR
f.print(*objects)
f.rewind
p f.read
f.close

출력:

nil
nil
"00.00/10+0izerozero"

구분자를 지정하면:

$\ = "\n"
$, = ','
f.rewind
f.print(*objects)
f.rewind
p f.read

출력:

"0,0.0,0/1,0+0i,zero,zero\n"

인자 없이 호출하면 $_(보통 가장 최근 사용자 입력)의 내용을 써요:

f = File.open('t.tmp', 'w+')
gets # Sets $_ to the most recent user input.
f.print
f.close

printf(format_string, *objects) → nil

objects 를 포맷해서 스트림에 써요. format_string 에 대한 자세한 내용은 Format Specifications를 참고하세요.

putc(object) → object

스트림에 문자 하나를 써요. object 가 숫자면 필요한 경우 정수로 변환한 뒤, 최하위 바이트가 코드인 문자를 써요. object 가 문자열이면 첫 문자를 써요.

$stdout.putc "A"
$stdout.putc 65

출력:

AA

puts(*objects) → nil

주어진 객체들을 스트림에 쓰고 nil 을 돌려줘요. 각 객체 뒤에, 이미 개행 시퀀스로 끝나지 않았다면 개행을 하나 써요. 인자 없이 호출하면 개행만 써요. 여기서 추가되는 개행은 문자 "\n" 이지 출력 레코드 구분자($\)가 아니라는 점을 주의하세요.

각 객체의 처리:

  • 문자열: 문자열을 씀.
  • 문자열도 배열도 아님: object.to_s 를 씀.
  • 배열: 배열의 각 요소를 씀. 배열은 중첩될 수 있음.
def show(*objects)
  # Puts objects to file.
  f = File.new('t.tmp', 'w+')
  f.puts(objects)
  # Return file content.
  f.rewind
  p f.read
  f.close
end

# Strings without newlines.
show('foo', 'bar', 'baz')     # => "foo\nbar\nbaz\n"
# Strings, some with newlines.
show("foo\n", 'bar', "baz\n") # => "foo\nbar\nbaz\n"

# Neither strings nor arrays:
show(0, 0.0, Rational(0, 1), Complex(9, 0), :zero)
# => "0\n0.0\n0/1\n9+0i\nzero\n"

# Array of strings.
show(['foo', "bar\n", 'baz']) # => "foo\nbar\nbaz\n"
# Nested arrays.
show([[[0, 1], 2, 3], 4, 5])  # => "0\n1\n2\n3\n4\n5\n"

read([length [, outbuf]]) → string, outbuf, or nil

ARGF 에서 length 바이트를 읽어요. 명령줄에 이름 붙은 파일들은 연결되어 이 메서드에서 단일 파일처럼 다뤄지므로, 인자 없이 호출하면 이 의사(pseudo) 파일의 내용 전체가 돌려줘요.

length 는 0 이상의 정수 또는 nil 이어야 해요.

  • length 가 양의 정수면, read 는 변환 없이(바이너리 모드) length 바이트를 읽으려고 해요. 아무것도 읽기 전에 EOF를 만나면 nil 을 돌려주고, 읽기 중 EOF를 만나면 length 보다 적은 바이트를 돌려줘요. 정수 길이의 경우 결과 문자열은 항상 ASCII-8BIT 인코딩이에요.
  • length 가 생략되거나 nil 이면 EOF까지 읽어요. 적용 가능하면 인코딩 변환이 적용돼요. 데이터를 읽기 전에 EOF를 만나도 문자열이 돌려줘요.
  • length 가 0이면 빈 문자열("")을 돌려줘요.

선택적 outbuf 인자가 있으면 String 을 참조해야 하며 그 문자열이 데이터를 받아요. 인자 시작 시 비어 있지 않아도 메서드 호출 후에는 받은 데이터만 담게 돼요.

$ echo "small" > small.txt
$ echo "large" > large.txt
$ ./glark.rb small.txt large.txt

ARGF.read      #=> "small\nlarge"
ARGF.read(200) #=> "small\nlarge"
ARGF.read(2)   #=> "sm"
ARGF.read(0)   #=> ""

이 메서드는 C의 fread() 처럼 동작해요. 즉 지정한 길이의 데이터를 읽기 위해 read(2) 시스템 호출을 재시도한다는 뜻이에요. 단일 read(2) 시스템 호출과 같은 동작이 필요하다면 ARGF#readpartial 또는 ARGF#read_nonblock 을 고려하세요.

read_nonblock(maxlen[, options]) → string

read_nonblock(maxlen, outbuf[, options]) → outbuf

ARGF 스트림에서 비차단(non-blocking) 모드로 최대 maxlen 바이트를 읽어요.

readbyte → Integer

ARGF 에서 다음 8비트 바이트를 읽어 Integer 로 돌려줘요. 마지막 파일의 마지막 바이트를 읽은 뒤에는 EOFError 를 발생시켜요.

$ echo "foo" > file
$ ruby argf.rb file

ARGF.readbyte  #=> 102
ARGF.readbyte  #=> 111
ARGF.readbyte  #=> 111
ARGF.readbyte  #=> 10
ARGF.readbyte  #=> end of file reached (EOFError)

readchar → String or nil

ARGF 에서 다음 문자를 읽어 String 으로 돌려줘요. 마지막 파일의 마지막 문자를 읽은 뒤에는 EOFError 를 발생시켜요.

$ echo "foo" > file
$ ruby argf.rb file

ARGF.readchar  #=> "f"
ARGF.readchar  #=> "o"
ARGF.readchar  #=> "o"
ARGF.readchar  #=> "\n"
ARGF.readchar  #=> end of file reached (EOFError)

readline(sep=$/) → string

readline(limit) → string

readline(sep, limit) → string

ARGF 의 현재 파일에서 다음 줄을 돌려줘요. 기본적으로 줄을 $/ 로 구분하며, 다른 구분 문자는 sep 인자에 문자열로 주면 돼요. 선택적 limit 인자는 각 줄에서 돌려줄 문자 수를 지정해요. 파일 끝에서는 EOFError 가 발생해요.

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

readlines(limit, chomp: false) → array

readlines(sep, limit, chomp: false) → array

ARGF 의 각 파일을 전체 읽어, 파일들의 줄을 담은 Array 를 돌려줘요. 줄은 sep 으로 구분된다고 가정해요.

lines = ARGF.readlines
lines[0]                #=> "This is line one\n"

모든 옵션에 대한 자세한 설명은 IO.readlines 를 참고하세요. to_a 의 별칭이기도 해요.

readpartial(maxlen) → string

readpartial(maxlen, outbuf) → outbuf

ARGF 스트림에서 최대 maxlen 바이트를 읽어요. 선택적 outbuf 인자가 있으면 String 을 참조해야 하며 받은 데이터만 담게 돼요. ARGF 스트림의 끝에서 EOFError 를 발생시켜요. ARGF 스트림은 여러 파일의 연결이므로 내부적으로 각 파일마다 EOF가 발생해요. ARGF.readpartial 은 마지막 파일을 제외한 EOF에서는 빈 문자열을 돌려주고, 마지막 파일의 EOF에서 EOFError 를 발생시켜요.

rewind → 0

현재 파일을 입력의 시작 위치로 옮기고 ARGF.lineno 를 0으로 재설정해요.

ARGF.readline   #=> "This is line one\n"
ARGF.rewind     #=> 0
ARGF.lineno     #=> 0
ARGF.readline   #=> "This is line one\n"

seek(amount, whence=IO::SEEK_SET) → 0

whence 값에 따라 ARGF 스트림에서 amount(정수) 오프셋으로 시크해요. 자세한 내용은 IO#seek 를 참고하세요.

set_encoding(ext_enc) → ARGF

set_encoding("ext_enc:int_enc") → ARGF

set_encoding(ext_enc, int_enc) → ARGF

set_encoding("ext_enc:int_enc", opt) → ARGF

set_encoding(ext_enc, int_enc, opt) → ARGF

단일 인자가 지정되면 ARGF 에서 읽은 문자열이 지정된 인코딩으로 태그돼요. 콜론으로 구분된 두 인코딩 이름, 예를 들어 "ascii:utf-8" 이 주어지면 읽은 문자열이 첫 인코딩(외부 인코딩)에서 두 번째 인코딩(내부 인코딩)으로 변환된 뒤 두 번째 인코딩으로 태그돼요. 두 인자가 지정되면 인코딩 객체 또는 인코딩 이름이어야 하고, 첫 번째가 외부 인코딩, 두 번째가 내부 인코딩이에요. 외부/내부 인코딩이 지정되면 선택적 Hash 인자로 변환 과정을 조정할 수 있어요. 이 해시 구조는 String#encode 문서에 설명돼 있어요.

ARGF.set_encoding('ascii')         # Tag the input as US-ASCII text
ARGF.set_encoding(Encoding::UTF_8) # Tag the input as UTF-8 text
ARGF.set_encoding('utf-8','ascii') # Transcode the input from US-ASCII
                                   # to UTF-8.

skip → ARGF

현재 파일을 ARGV 의 다음 파일로 설정해요. 더 이상 파일이 없으면 효과가 없어요.

$ ruby argf.rb foo bar
ARGF.filename  #=> "foo"
ARGF.skip
ARGF.filename  #=> "bar"

tell → Integer

현재 파일의 현재 오프셋(바이트 단위)을 돌려줘요. pos 의 별칭이기도 해요.

ARGF.pos    #=> 0
ARGF.gets   #=> "This is line one\n"
ARGF.pos    #=> 17

to_a(sep = $/, chomp: false) → array

to_a(limit, chomp: false) → array

to_a(sep, limit, chomp: false) → array

ARGF 의 각 파일을 전체 읽어 줄들을 담은 Array 를 돌려줘요. readlines 의 별칭이에요. (자세한 설명은 readlines 항목 참고.)

to_i → integer

현재 파일의 숫자 파일 디스크립터를 나타내는 정수를 돌려줘요. 현재 파일이 없으면 ArgumentError 를 던져요. fileno 의 별칭이에요. (자세한 설명은 fileno 항목 참고.)

to_io → IO

현재 파일을 나타내는 IO 객체를 돌려줘요. 현재 파일이 STDIN 같은 스트림이 아니면 File 객체가 돼요.

ARGF.to_io    #=> #<File:glark.txt>
ARGF.to_io    #=> #<IO:<STDIN>>

to_s → String

"ARGF" 를 돌려줘요. inspect 의 별칭이기도 해요.

to_write_io → io

인플레이스 모드가 활성화돼 있으면 쓰기용으로 ARGF 에 연결된 IO 인스턴스를 돌려줘요.

write(*objects) → integer

인플레이스 모드이면 주어진 objects 각각을 써요.