ARGF

父类：ObjectIncluded 模块：Enumerable

ARGF 是一个设计用于处理作为命令行参数给出的文件或通过STDIN传入的脚本的流。

传递给脚本的参数存储在ARGV数组中，每个元素一个参数。ARGF假定任何不是文件名的参数都已从中删除ARGV。例如：

$ ruby argf.rb --verbose file1 file2

ARGV  #=> ["--verbose", "file1", "file2"]
option = ARGV.shift #=> "--verbose"
ARGV  #=> ["file1", "file2"]

您现在可以使用ARGF这些命名文件中的每一个的并置处理。例如，ARGF.read将返回file1的内容，接着是file2的内容。

ARGV读入文件后，ARGF将其从阵列中删除。因此，在所有文件被读取后都ARGV将是空的。

你可以操纵ARGV自己来控制ARGF操作。如果您从中删除文件ARGV，它将被忽略ARGF; 如果你添加文件ARGV，它们被当作是在命令行上命名的。例如：

ARGV.replace ["file1"]
ARGF.readlines # Returns the contents of file1 as an Array
ARGV           #=> []
ARGV.replace ["file2", "file3"]
ARGF.read      # Returns the contents of file2 and file3

如果ARGV是空的，ARGF就好像它包含STDIN，即将数据传送给脚本。例如：

$ echo "glark" | ruby -e 'p ARGF.read'
"glark\n"

公共实例方法

argv→ARGV显示源

返回ARGV数组，其中包含传递给脚本的参数，每个元素一个。

例如：

$ ruby argf.rb -v glark.txt

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

static VALUE
argf_argv(VALUE argf)
{
    return ARGF.argv;
}

binmode→ARGF显示资源

放ARGF成二进制模式。一旦流处于二进制模式，它不能被重置为非二进制模式。该选项具有以下效果：

• 换行转换已禁用。

• 编码转换已禁用。

• 内容被视为ASCII-8BIT。

static VALUE
argf_binmode_m(VALUE argf)
{
    ARGF.binmode = 1;
    next_argv();
    ARGF_FORWARD(0, 0);
    rb_io_ascii8bit_binmode(ARGF.current_file);
    return argf;
}

binmode?→true或false显示来源

Returns true if +ARGF+ is being read in binary mode; false otherwise. (To
enable binary mode use +ARGF.binmode+.

例如：

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

static VALUE
argf_binmode_p(VALUE argf)
{
    return ARGF.binmode ? Qtrue : Qfalse;
}

bytes() 显示源文件

这是一个不推荐的别名each_byte。

static VALUE
argf_bytes(VALUE argf)
{
    rb_warn("ARGF#bytes is deprecated; use #each_byte instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(argf, ID2SYM(rb_intern("each_byte")), 0, 0);
    return argf_each_byte(argf);
}

chars()显示源文件

这是一个不推荐的别名each_char。

static VALUE
argf_chars(VALUE argf)
{
    rb_warn("ARGF#chars is deprecated; use #each_char instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(argf, ID2SYM(rb_intern("each_char")), 0, 0);
    return argf_each_char(argf);
}

关闭→ARGF显示资源

Closes the current file and skips to the next file in ARGV. If there are
no more files to open, just closes the current file. +STDIN+ will not be
closed.

例如：

$ ruby argf.rb foo bar

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

static VALUE
argf_close_m(VALUE argf)
{
    next_argv();
    argf_close(argf);
    if (ARGF.next_p != -1) {
        ARGF.next_p = 1;
    }
    ARGF.lineno = 0;
    return argf;
}

关闭?→true或false显示来源

如果当前文件已关闭，则返回true ; 否则为假。使用ARGF.close实际关闭当前文件。

static VALUE
argf_closed(VALUE argf)
{
    next_argv();
    ARGF_FORWARD(0, 0);
    return rb_io_closed(ARGF.current_file);
}

codepoints() 显示源代码

这是一个不推荐的别名each_codepoint。

static VALUE
argf_codepoints(VALUE argf)
{
    rb_warn("ARGF#codepoints is deprecated; use #each_codepoint instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(argf, ID2SYM(rb_intern("each_codepoint")), 0, 0);
    return argf_each_codepoint(argf);
}

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

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

each(...) → an_enumerator

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

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

each_line(...) → an_enumerator

返回一个枚举器，它遍历每个文件所在的每一行（由sep隔开，默认为平台的换行符）ARGV。如果提供了一个块，则每一行依次被放到该块中，否则返回一个枚举器。可选的限制参数是Integer指定每行的最大长度; 根据这个限制，更长的线路将被分割。

此方法允许您将命令行中提供的文件视为由每个指定文件的串联组成的单个文件。第一个文件的最后一行返回后，返回第二个文件的第一行。的ARGF.filename和ARGF.lineno方法可以被用于确定文件名和行号，分别为当前行的。

例如，下面的代码打印每个以其行号为前缀的每个命名文件的每行，每个文件显示一次文件名：

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

static VALUE
argf_each_line(int argc, VALUE *argv, VALUE argf)
{
    RETURN_ENUMERATOR(argf, argc, argv);
    FOREACH_ARGF() {
        argf_block_call_line(rb_intern("each_line"), argc, argv, argf);
    }
    return argf;
}

bytes {|byte| block } →ARGF显示源

bytes → an_enumerator

each_byte {|byte| block } → ARGF

each_byte → an_enumerator

Iterates over each byte of each file in +ARGV+.
A byte is returned as an +Integer+ in the range 0..255.

This method allows you to treat the files supplied on the command line as
a single file consisting of the concatenation of each named file. After
the last byte of the first file has been returned, the first byte of the
second file is returned. The +ARGF.filename+ method can be used to
determine the filename of the current byte.

If no block is given, an enumerator is returned instead.

例如：

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

static VALUE
argf_each_byte(VALUE argf)
{
    RETURN_ENUMERATOR(argf, 0, 0);
    FOREACH_ARGF() {
        argf_block_call(rb_intern("each_byte"), 0, 0, argf);
    }
    return argf;
}

each_char {|char| block } → ARGF Show source

each_char → an_enumerator

遍历每个文件的每个字符ARGF。

此方法允许您将命令行中提供的文件视为由每个指定文件的串联组成的单个文件。在返回第一个文件的最后一个字符后，返回第二个文件的第一个字符。该ARGF.filename方法可用于确定当前字符出现的文件的名称。

如果没有给出块，则返回一个枚举器。

static VALUE
argf_each_char(VALUE argf)
{
    RETURN_ENUMERATOR(argf, 0, 0);
    FOREACH_ARGF() {
        argf_block_call(rb_intern("each_char"), 0, 0, argf);
    }
    return argf;
}

each_codepoint {| codepoint | 块}→ARGF显示源

each_codepoint → an_enumerator

遍历每个文件的每个代码点ARGF。

此方法允许您将命令行中提供的文件视为由每个指定文件的串联组成的单个文件。在返回第一个文件的最后一个代码点之后，返回第二个文件的第一个代码点。该ARGF.filename方法可用于确定当前代码点出现的文件的名称。

如果没有给出块，则返回一个枚举器。

static VALUE
argf_each_codepoint(VALUE argf)
{
    RETURN_ENUMERATOR(argf, 0, 0);
    FOREACH_ARGF() {
        argf_block_call(rb_intern("each_codepoint"), 0, 0, argf);
    }
    return argf;
}

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

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

each_line(...) → an_enumerator

返回一个枚举器，它遍历每个文件所在的每一行（由sep隔开，默认为平台的换行符）ARGV。如果提供了一个块，则每一行依次被放到该块中，否则返回一个枚举器。可选的限制参数是Integer指定每行的最大长度; 根据这个限制，更长的线路将被分割。

此方法允许您将命令行中提供的文件视为由每个指定文件的串联组成的单个文件。第一个文件的最后一行返回后，返回第二个文件的第一行。的ARGF.filename和ARGF.lineno方法可以被用于确定文件名和行号，分别为当前行的。

例如，下面的代码打印每个以其行号为前缀的每个命名文件的每行，每个文件显示一次文件名：

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

static VALUE
argf_each_line(int argc, VALUE *argv, VALUE argf)
{
    RETURN_ENUMERATOR(argf, argc, argv);
    FOREACH_ARGF() {
        argf_block_call_line(rb_intern("each_line"), argc, argv, argf);
    }
    return argf;
}

eof?→true或false显示来源

eof→true或false

如果当前文件位于文件末尾，ARGF则返回true ，即它没有要读取的数据。该流必须打开阅读或IOError将被提出。

$ echo "eof" | ruby argf.rb

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

static VALUE
argf_eof(VALUE argf)
{
    next_argv();
    if (RTEST(ARGF.current_file)) {
        if (ARGF.init_p == 0) return Qtrue;
        next_argv();
        ARGF_FORWARD(0, 0);
        if (rb_io_eof(ARGF.current_file)) {
            return Qtrue;
        }
    }
    return Qfalse;
}

eof? →true或false显示来源

如果当前文件位于文件末尾，ARGF则返回true ，即它没有要读取的数据。该流必须打开阅读或IOError将被提出。

$ echo "eof" | ruby argf.rb

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

static VALUE
argf_eof(VALUE argf)
{
    next_argv();
    if (RTEST(ARGF.current_file)) {
        if (ARGF.init_p == 0) return Qtrue;
        next_argv();
        ARGF_FORWARD(0, 0);
        if (rb_io_eof(ARGF.current_file)) {
            return Qtrue;
        }
    }
    return Qfalse;
}

external_encoding→编码显示源文件

Returns the external encoding for files read from +ARGF+ as an +Encoding+
object. The external encoding is the encoding of the text as stored in a
file. Contrast with +ARGF.internal_encoding+, which is the encoding used
to represent this text within Ruby.

To set the external encoding use +ARGF.set_encoding+.

例如：

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

static VALUE
argf_external_encoding(VALUE argf)
{
    if (!RTEST(ARGF.current_file)) {
        return rb_enc_from_encoding(rb_default_external_encoding());
    }
    return rb_io_external_encoding(rb_io_check_io(ARGF.current_file));
}

file → IO或文件对象显示源

将当前文件作为IO或File对象返回。当前文件为STDIN时返回＃<IO：<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>

static VALUE
argf_file(VALUE argf)
{
    next_argv();
    return ARGF.current_file;
}

filename → String Show source

返回当前的文件名。当前文件为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"

static VALUE
argf_filename(VALUE argf)
{
    next_argv();
    return ARGF.filename;
}

fileno → integer Show source

返回表示当前文件的数字文件描述符的整数。如果没有当前文件，则引发一个ArgumentError。

ARGF.fileno    #=> 3

static VALUE
argf_fileno(VALUE argf)
{
    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream");
    }
    ARGF_FORWARD(0, 0);
    return rb_io_fileno(ARGF.current_file);
}

getbyte → Integer or nil Show source

从中获取下一个8位字节（0..255）ARGF。nil如果在流尾部调用，则返回。

例如：

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

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

static VALUE
argf_getbyte(VALUE argf)
{
    VALUE ch;

  retry:
    if (!next_argv()) return Qnil;
    if (!RB_TYPE_P(ARGF.current_file, T_FILE)) {
        ch = rb_funcall3(ARGF.current_file, rb_intern("getbyte"), 0, 0);
    }
    else {
        ch = rb_io_getbyte(ARGF.current_file);
    }
    if (NIL_P(ch) && ARGF.next_p != -1) {
        argf_close(argf);
        ARGF.next_p = 1;
        goto retry;
    }

    return ch;
}

getc → String or nil Show source

读取下一个字符ARGF并将其作为一个返回String。nil在流尾部返回。

ARGF将命令行中命名的文件视为通过连接其内容创建的单个文件。返回第一个文件的最后一个字符后，它返回第二个文件的第一个字符，依此类推。

例如：

$ 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

static VALUE
argf_getc(VALUE argf)
{
    VALUE ch;

  retry:
    if (!next_argv()) return Qnil;
    if (ARGF_GENERIC_INPUT_P()) {
        ch = rb_funcall3(ARGF.current_file, rb_intern("getc"), 0, 0);
    }
    else {
        ch = rb_io_getc(ARGF.current_file);
    }
    if (NIL_P(ch) && ARGF.next_p != -1) {
        argf_close(argf);
        ARGF.next_p = 1;
        goto retry;
    }

    return ch;
}

gets(sep=$/) → string or nil Show source

gets(limit) → string or nil

gets(sep, limit) → string or nil

返回当前文件中的下一行ARGF。

默认情况下，行假定以+ $ / +分隔; 使用不同的字符作为分隔符，提供它作为一个String用于九月参数。

可选的limit参数指定每行返回的字符数。默认情况下所有字符都会返回。

static VALUE
argf_gets(int argc, VALUE *argv, VALUE argf)
{
    VALUE line;

    line = argf_getline(argc, argv, argf);
    rb_lastline_set(line);

    return line;
}

inplace_mode → String Show source

在就地编辑模式下返回附加到修改文件名称的文件扩展名。 可以使用ARGF.inplace_mode =或将-i开关传递给Ruby二进制文件来设置此值。

static VALUE
argf_inplace_mode_get(VALUE argf)
{
    if (!ARGF.inplace) return Qnil;
    return rb_str_new2(ARGF.inplace);
}

inplace_mode = ext → ARGF Show source

Sets the filename extension for in place editing mode to the given String.
Each file being edited has this value appended to its filename. The
modified file is saved under this new name.

For example:

    $ ruby argf.rb file.txt

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

file.txt的每一行都有第一次出现的“foo”替换为“bar”，然后新行写出到file.txt.bak。

static VALUE
argf_inplace_mode_set(VALUE argf, VALUE val)
{
    if (rb_safe_level() >= 1 && OBJ_TAINTED(val))
        rb_insecure_operation();

    if (!RTEST(val)) {
        if (ARGF.inplace) free(ARGF.inplace);
        ARGF.inplace = 0;
    }
    else {
        StringValue(val);
        if (ARGF.inplace) free(ARGF.inplace);
        ARGF.inplace = 0;
        ARGF.inplace = strdup(RSTRING_PTR(val));
    }
    return argf;
}

inspect()

别名为：to_s

internal_encoding → encoding Show source

返回从ARGF读取的字符串的内部编码作为Encoding对象。

如果ARGF.set_encoding已用两个编码名称调用，则返回第二个。否则，如果Encoding.default_external已设置，则返回该值。否则，如果在命令行中指定了默认外部编码，则会使用该值。如果编码未知，则返回nil。

static VALUE
argf_internal_encoding(VALUE argf)
{
    if (!RTEST(ARGF.current_file)) {
        return rb_enc_from_encoding(rb_default_external_encoding());
    }
    return rb_io_internal_encoding(rb_io_check_io(ARGF.current_file));
}

lineno → integer Show source

作为一个整体返回ARGF的当前行号。该值可以用手动设置ARGF.lineno=。

例如：

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

static VALUE
argf_lineno(VALUE argf)
{
    return INT2FIX(ARGF.lineno);
}

lineno = integer → integer Show source

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

static VALUE
argf_set_lineno(VALUE argf, VALUE val)
{
    ARGF.lineno = NUM2INT(val);
    ARGF.last_lineno = ARGF.lineno;
    return Qnil;
}

lines(*args) Show source

这是一个不推荐的别名each_line。

static VALUE
argf_lines(int argc, VALUE *argv, VALUE argf)
{
    rb_warn("ARGF#lines is deprecated; use #each_line instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(argf, ID2SYM(rb_intern("each_line")), argc, argv);
    return argf_each_line(argc, argv, argf);
}

path → String Show source

返回当前的文件名。当前文件为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"

static VALUE
argf_filename(VALUE argf)
{
    next_argv();
    return ARGF.filename;
}

pos → Integer Show source

返回当前文件的当前偏移量（以字节为单位）ARGF。

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

static VALUE
argf_tell(VALUE argf)
{
    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream to tell");
    }
    ARGF_FORWARD(0, 0);
    return rb_io_tell(ARGF.current_file);
}

pos = position → Integer Show source

寻求ARGF中位置给予的位置（以字节为单位）。

例如：

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

static VALUE
argf_set_pos(VALUE argf, VALUE offset)
{
    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream to set position");
    }
    ARGF_FORWARD(1, &offset);
    return rb_io_set_pos(ARGF.current_file, offset);
}

print → nil Show source

print(obj, ...) → nil

将给定的对象写入ios。退货nil。

该流必须打开才能写入。 每个给定的不是字符串的对象都将通过调用其to_s方法进行转换。 当不带参数调用时，打印$ _的内容。

如果输出字段分隔符（$,）不是nil，则将其插入对象之间。如果输出记录separator（$\）不是nil，则会将其附加到输出。

$stdout.print("This is ", 100, " percent.\n")

产生：

This is 100 percent.

VALUE
rb_io_print(int argc, const VALUE *argv, VALUE out)
{
    int i;
    VALUE line;

    /* if no argument given, print `$_' */
    if (argc == 0) {
        argc = 1;
        line = rb_lastline_get();
        argv = &line;
    }
    for (i=0; i<argc; i++) {
        if (!NIL_P(rb_output_fs) && i>0) {
            rb_io_write(out, rb_output_fs);
        }
        rb_io_write(out, argv[i]);
    }
    if (argc > 0 && !NIL_P(rb_output_rs)) {
        rb_io_write(out, rb_output_rs);
    }

    return Qnil;
}

printf(format_string , obj, ...) → nil Show source

格式化并写入ios，在格式字符串的控制下转换参数。详情请参阅Kernel#sprintf。

VALUE
rb_io_printf(int argc, const VALUE *argv, VALUE out)
{
    rb_io_write(out, rb_f_sprintf(argc, argv));
    return Qnil;
}

putc(obj) → obj Show source

如果OBJ是Numeric，写其代码是最不显著字节字符OBJ，否则写的字符串表示的第一个字节OBJ到IOS。注意：此方法不适用于多字节字符，因为它会截断它们。

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

产生:

AA

static VALUE
rb_io_putc(VALUE io, VALUE ch)
{
    VALUE str;
    if (RB_TYPE_P(ch, T_STRING)) {
        str = rb_str_substr(ch, 0, 1);
    }
    else {
        char c = NUM2CHR(ch);
        str = rb_str_new(&c, 1);
    }
    rb_io_write(io, str);
    return ch;
}

puts(obj, ...) → nil Show source

写入给定的对象（一个或多个），以IOS与IO#print。在没有以换行符结束的任何之后写入换行符。

如果使用数组参数调用，则将每个元素写入新行。如果不带参数调用，则输出一个换行符。

$stdout.puts("this", "is", "a", "test")

产生:

this
is
a
test

VALUE
rb_io_puts(int argc, const VALUE *argv, VALUE out)
{
    int i;
    VALUE line;

    /* if no argument given, print newline. */
    if (argc == 0) {
        rb_io_write(out, rb_default_rs);
        return Qnil;
    }
    for (i=0; i<argc; i++) {
        if (RB_TYPE_P(argv[i], T_STRING)) {
            line = argv[i];
            goto string;
        }
        if (rb_exec_recursive(io_puts_ary, argv[i], out)) {
            continue;
        }
        line = rb_obj_as_string(argv[i]);
      string:
        rb_io_write(out, line);
        if (RSTRING_LEN(line) == 0 ||
            !str_end_with_asciichar(line, '\n')) {
            rb_io_write(out, rb_default_rs);
        }
    }

    return Qnil;
}

读取（[length，outbuf]）→string，outbuf或nil显示源文件

Reads _length_ bytes from ARGF. The files named on the command line
are concatenated and treated as a single file by this method, so when
called without arguments the contents of this pseudo file are returned in
their entirety.

_length_ must be a non-negative integer or nil. If it is a positive
integer, +read+ tries to read at most _length_ bytes. It returns nil
if an EOF was encountered before anything could be read. Fewer than
_length_ bytes may be returned if an EOF is encountered during the read.

If _length_ is omitted or is _nil_, it reads until EOF. A String is
returned even if EOF is encountered before any data is read.

If _length_ is zero, it returns _""_.

If the optional _outbuf_ argument is present, it must reference a String,
which will receive the data.
The <i>outbuf</i> will contain only the received data after the method call
even if it is not empty at the beginning.

例如：

   $ 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)   #=> ""

Note that this method behaves like fread() function in C.  If you need the
behavior like read(2) system call, consider +ARGF.readpartial+.

static VALUE
argf_read(int argc, VALUE *argv, VALUE argf)
{
    VALUE tmp, str, length;
    long len = 0;

    rb_scan_args(argc, argv, "02", &length, &str);
    if (!NIL_P(length)) {
        len = NUM2LONG(argv[0]);
    }
    if (!NIL_P(str)) {
        StringValue(str);
        rb_str_resize(str,0);
        argv[1] = Qnil;
    }

  retry:
    if (!next_argv()) {
        return str;
    }
    if (ARGF_GENERIC_INPUT_P()) {
        tmp = argf_forward(argc, argv, argf);
    }
    else {
        tmp = io_read(argc, argv, ARGF.current_file);
    }
    if (NIL_P(str)) str = tmp;
    else if (!NIL_P(tmp)) rb_str_append(str, tmp);
    if (NIL_P(tmp) || NIL_P(length)) {
        if (ARGF.next_p != -1) {
            argf_close(argf);
            ARGF.next_p = 1;
            goto retry;
        }
    }
    else if (argc >= 1) {
        long slen = RSTRING_LEN(str);
        if (slen < len) {
            len -= slen;
            argv[0] = INT2NUM(len);
            goto retry;
        }
    }
    return str;
}

read_nonblock(maxlen) → string Show source

read_nonblock(maxlen, outbuf) → outbuf

以非阻塞模式从ARGF流读取至多maxlen字节。

static VALUE
argf_read_nonblock(int argc, VALUE *argv, VALUE argf)
{
    VALUE opts;

    rb_scan_args(argc, argv, "11:", NULL, NULL, &opts);

    if (!NIL_P(opts))
        argc--;

    return argf_getpartial(argc, argv, argf, opts, 1);
}

readbyte → Integer Show source

从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)

static VALUE
argf_readbyte(VALUE argf)
{
    VALUE c;

    NEXT_ARGF_FORWARD(0, 0);
    c = argf_getbyte(argf);
    if (NIL_P(c)) {
        rb_eof_error();
    }
    return c;
}

readchar → String or nil Show source

从ARGF读取下一个字符并将其作为字符串返回。 在读取最后一个文件的最后一个字符后引发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)

static VALUE
argf_readchar(VALUE argf)
{
    VALUE ch;

  retry:
    if (!next_argv()) rb_eof_error();
    if (!RB_TYPE_P(ARGF.current_file, T_FILE)) {
        ch = rb_funcall3(ARGF.current_file, rb_intern("getc"), 0, 0);
    }
    else {
        ch = rb_io_getc(ARGF.current_file);
    }
    if (NIL_P(ch) && ARGF.next_p != -1) {
        argf_close(argf);
        ARGF.next_p = 1;
        goto retry;
    }

    return ch;
}

readline(sep=$/) → string Show source

readline(limit) → string

readline(sep, limit) → string

返回当前文件ARGF中的下一行。

默认情况下，行假定以+ $ / +分隔; 使用不同的字符作为分隔符，提供它作为一个String用于九月参数。

可选的limit参数指定每行返回的字符数。默认情况下所有字符都会返回。

在文件结尾提出一个EOFError。

static VALUE
argf_readline(int argc, VALUE *argv, VALUE argf)
{
    VALUE line;

    if (!next_argv()) rb_eof_error();
    ARGF_FORWARD(argc, argv);
    line = argf_gets(argc, argv, argf);
    if (NIL_P(line)) {
        rb_eof_error();
    }

    return line;
}

readlines(sep=$/) → array Show source

readlines(limit) → array

readlines(sep, limit) → array

全部读取ARGF当前文件，返回Array行，每个元素一行。假定行被sep分隔。

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

static VALUE
argf_readlines(int argc, VALUE *argv, VALUE argf)
{
    long lineno = ARGF.lineno;
    VALUE lines, ary;

    ary = rb_ary_new();
    while (next_argv()) {
        if (ARGF_GENERIC_INPUT_P()) {
            lines = rb_funcall3(ARGF.current_file, rb_intern("readlines"), argc, argv);
        }
        else {
            lines = rb_io_readlines(argc, argv, ARGF.current_file);
            argf_close(argf);
        }
        ARGF.next_p = 1;
        rb_ary_concat(ary, lines);
        ARGF.lineno = lineno + RARRAY_LEN(ary);
        ARGF.last_lineno = ARGF.lineno;
    }
    ARGF.init_p = 0;
    return ary;
}

readpartial(maxlen) → string Show source

readpartial(maxlen, outbuf) → outbuf

从ARGF流中最多读取maxlen字节。

如果可选的outbuf参数存在，它必须引用一个String，它将接收数据。该outbuf中仅包含方法调用后接收到的数据，即使它不是在一开始是空的。

EOFError在ARGF流结束时提高。由于ARGF流是多个文件的串联，因此每个文件都会发生内部EOF。#readpartial返回除最后一个EOF外的空字符串，并且EOFError为最后一个引发。

static VALUE
argf_readpartial(int argc, VALUE *argv, VALUE argf)
{
    return argf_getpartial(argc, argv, argf, Qnil, 0);
}

rewind → 0 Show source

将当前文件定位到输入的开头，重置ARGF.lineno为零。

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

static VALUE
argf_rewind(VALUE argf)
{
    VALUE ret;
    int old_lineno;

    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream to rewind");
    }
    ARGF_FORWARD(0, 0);
    old_lineno = RFILE(ARGF.current_file)->fptr->lineno;
    ret = rb_io_rewind(ARGF.current_file);
    if (!global_argf_p(argf)) {
        ARGF.last_lineno = ARGF.lineno -= old_lineno;
    }
    return ret;
}

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

寻求偏移量（一个Integer中）ARGF根据的值流何处。有关更多详细信息，请参见+ IO＃seek +。

static VALUE
argf_seek_m(int argc, VALUE *argv, VALUE argf)
{
    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream to seek");
    }
    ARGF_FORWARD(argc, argv);
    return rb_io_seek_m(argc, argv, ARGF.current_file);
}

set_encoding(ext_enc) → ARGF Show source

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 + documentation中进行了解释。

例如：

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.

static VALUE
argf_set_encoding(int argc, VALUE *argv, VALUE argf)
{
    rb_io_t *fptr;

    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream to set encoding");
    }
    rb_io_set_encoding(argc, argv, ARGF.current_file);
    GetOpenFile(ARGF.current_file, fptr);
    ARGF.encs = fptr->encs;
    return argf;
}

skip → ARGF Show source

Sets the current file to the next file in ARGV. If there aren't any more
files it has no effect.

例如：

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

static VALUE
argf_skip(VALUE argf)
{
    if (ARGF.init_p && ARGF.next_p == 0) {
        argf_close(argf);
        ARGF.next_p = 1;
    }
    return argf;
}

tell → Integer Show source

返回ARGF中当前文件的当前偏移量（以字节为单位）。

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

static VALUE
argf_tell(VALUE argf)
{
    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream to tell");
    }
    ARGF_FORWARD(0, 0);
    return rb_io_tell(ARGF.current_file);
}

to_a(sep=$/) → array Show source

to_a(limit) → array

to_a(sep, limit) → array

全部读取ARGF当前文件，返回Array行，每个元素一行。假定行被sep分隔。

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

static VALUE
argf_readlines(int argc, VALUE *argv, VALUE argf)
{
    long lineno = ARGF.lineno;
    VALUE lines, ary;

    ary = rb_ary_new();
    while (next_argv()) {
        if (ARGF_GENERIC_INPUT_P()) {
            lines = rb_funcall3(ARGF.current_file, rb_intern("readlines"), argc, argv);
        }
        else {
            lines = rb_io_readlines(argc, argv, ARGF.current_file);
            argf_close(argf);
        }
        ARGF.next_p = 1;
        rb_ary_concat(ary, lines);
        ARGF.lineno = lineno + RARRAY_LEN(ary);
        ARGF.last_lineno = ARGF.lineno;
    }
    ARGF.init_p = 0;
    return ary;
}

to_i → integer Show source

返回表示当前文件的数字文件描述符的整数。如果没有当前文件，则引发一个ArgumentError。

ARGF.fileno    #=> 3

static VALUE
argf_fileno(VALUE argf)
{
    if (!next_argv()) {
        rb_raise(rb_eArgError, "no stream");
    }
    ARGF_FORWARD(0, 0);
    return rb_io_fileno(ARGF.current_file);
}

to_io → IO Show source

返回表示当前文件的IO对象。 这将是一个File对象，除非当前文件是诸如STDIN之类的流。

例如：

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

static VALUE
argf_to_io(VALUE argf)
{
    next_argv();
    ARGF_FORWARD(0, 0);
    return ARGF.current_file;
}

to_s → String Show source

返回“ARGF”。

static VALUE
argf_to_s(VALUE argf)
{
    return rb_str_new2("ARGF");
}

还有别名：inspect

to_write_io → io Show source

如果启用了就地模式，则返回绑定到ARGF以写入的IO实例。

static VALUE
argf_write_io(VALUE argf)
{
    if (!RTEST(ARGF.current_file)) {
        rb_raise(rb_eIOError, "not opened for writing");
    }
    return GetWriteIO(ARGF.current_file);
}

write(string) → integer Show source

如果是就地模式，则写入字符串。

static VALUE
argf_write(VALUE argf, VALUE str)
{
    return rb_io_write(argf_write_io(argf), str);
}

	ARGF