class ARGF

ARGF und `ARGV`

Das ARGF-Objekt arbeitet mit dem Array der globalen Variablen ARGV zusammen, um $stdin und Dateistreams für das Ruby-Programm verfügbar zu machen.

ARGV kann als das Array des **Argumentvektors** betrachtet werden.

Anfänglich enthält es die Kommandozeilenargumente und Optionen, die an das Ruby-Programm übergeben werden; das Programm kann dieses Array nach Belieben ändern.
ARGF kann als das **Argumentdateien**-Objekt betrachtet werden.

Es kann auf Dateistreams und/oder den $stdin-Stream zugreifen, basierend darauf, was es in ARGV findet. Dies bietet eine bequeme Möglichkeit, Streams für ein Ruby-Programm über die Kommandozeile anzugeben.

Lesen

ARGF kann aus *Quellen*-Streams lesen, die zu einem bestimmten Zeitpunkt durch den Inhalt von ARGV bestimmt werden.

Einfachster Fall

Wenn der *aller erste* ARGF-Lesevorgang mit einem leeren ARGV ([]) auftritt, ist die Quelle $stdin.

Datei t.rb

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

Befehle und Ausgaben (siehe unten für den Inhalt der Dateien foo.txt und 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"]

Über die Beispiele

Viele Beispiele hier gehen davon aus, dass die Dateien foo.txt und bar.txt existieren.

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

Quellen in `ARGV`

Für jeden ARGF-Lesevorgang *außer* dem einfachsten Fall (d.h. *außer* dem *aller ersten* ARGF-Lesevorgang mit einem leeren ARGV) werden die Quellen in ARGV gefunden.

ARGF geht davon aus, dass jedes Element im Array ARGV eine potenzielle Quelle ist und eine der folgenden Optionen ist:

Der Zeichenkettenpfad zu einer Datei, die als Stream geöffnet werden kann.
Das Zeichen '-', was den Stream $stdin bedeutet.

Jedes Element, das *nicht* eine dieser Optionen ist, sollte aus ARGV entfernt werden, bevor ARGF auf diese Quelle zugreift.

Im folgenden Beispiel

Dateipfade foo.txt und bar.txt können als potenzielle Quellen beibehalten werden.
Optionen --xyzzy und --mojo sollten entfernt werden.

Beispiel

Datei t.rb

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

Befehl und Ausgabe

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

Der Stream-Zugriff von ARGF berücksichtigt die Elemente von ARGV von links nach rechts.

Datei t.rb

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

Befehl und Ausgabe

$ 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"

Da der Wert in ARGV ein normales Array ist, können Sie ihn manipulieren, um zu steuern, welche Quellen ARGF berücksichtigt.

Wenn Sie ein Element aus ARGV entfernen, wird ARGF die entsprechende Quelle nicht berücksichtigen.
Wenn Sie ein Element zu ARGV hinzufügen, wird ARGF die entsprechende Quelle berücksichtigen.

Jedes Element in ARGV wird entfernt, wenn auf seine entsprechende Quelle zugegriffen wird; wenn auf alle Quellen zugegriffen wurde, ist das Array leer.

Datei t.rb

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

Befehl und Ausgabe

$ 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"

Dateipfade in `ARGV`

Das Array ARGV kann Dateipfade enthalten, die Quellen für das Lesen von ARGF angeben.

Dieses Programm gibt aus, was es aus den auf der Kommandozeile angegebenen Dateien liest.

Datei t.rb

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

Befehl und Ausgabe

$ 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"]

`$stdin` in `ARGV` angeben

Um den Stream $stdin in ARGV anzugeben, verwenden Sie das Zeichen '-'.

Datei t.rb

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

Befehl und Ausgabe

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

Wenn kein Zeichen '-' angegeben wird, wird der Stream $stdin ignoriert (Ausnahme: siehe Specifying $stdin in ARGV).

Befehl und Ausgabe

$ echo "Open the pod bay doors, Hal." | 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"

Mischungen und Wiederholungen in `ARGV`

Für einen ARGF-Leser kann ARGV jede Mischung aus Dateipfaden und dem Zeichen '-', einschließlich Wiederholungen, enthalten.

Änderungen an `ARGV`

Das laufende Ruby-Programm kann beliebige Änderungen am ARGV-Array vornehmen; der aktuelle Wert von ARGV beeinflusst das Lesen von ARGF.

Leeres `ARGV`

Bei einem leeren ARGV gibt eine ARGF-Lesemethode entweder nil zurück oder löst eine Ausnahme aus, abhängig von der spezifischen Methode.

Weitere Lesemethoden

Wie oben gezeigt, liest die Methode ARGF#read den Inhalt aller Quellen in eine einzige Zeichenkette. Andere ARGF-Methoden bieten andere Möglichkeiten, auf diesen Inhalt zuzugreifen, darunter:

Byte-Zugriff: each_byte, getbyte, readbyte.
Zeichenzugriff: each_char, getc, readchar.
Codepoint-Zugriff: each_codepoint.
Zeilen-Zugriff: each_line, gets, readline, readlines.
Quellen-Zugriff: read, read_nonblock, readpartial.

Über Enumerable

ARGF enthält das Modul Enumerable. Praktisch alle Methoden in Enumerable rufen die Methode each in der inkludierenden Klasse auf.

Gut zu wissen: In ARGF gibt die Methode each Daten aus den *Quellen*, *nicht* aus ARGV zurück; daher gibt z. B. ARGF#entries ein Array von Zeilen aus den Quellen zurück, nicht ein Array der Zeichenketten aus ARGV.

Datei t.rb

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

Befehl und Ausgabe

$ 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"]]

Schreiben

Wenn der *inplace-Modus* aktiv ist, kann ARGF in Ziel-Streams schreiben, die zu einem bestimmten Zeitpunkt durch den Inhalt von ARGV bestimmt werden.

Methoden zum Inplace-Modus

Methoden zum Schreiben

Öffentliche Instanzmethoden

argv → ARGV

Source

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

Gibt das ARGV-Array zurück, das die an Ihr Skript übergebenen Argumente enthält, eines pro Element.

Zum Beispiel

$ ruby argf.rb -v glark.txt

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

binmode → ARGF

Source

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;
}

Schaltet ARGF in den Binärmodus. Sobald ein Stream im Binärmodus ist, kann er nicht mehr in den Nicht-Binärmodus zurückversetzt werden. Diese Option hat die folgenden Auswirkungen:

Zeilenumbruchkonvertierung ist deaktiviert.
Encoding-Konvertierung ist deaktiviert.
Inhalt wird als ASCII-8BIT behandelt.

binmode? → true oder false

Source

static VALUE
argf_binmode_p(VALUE argf)
{
    return RBOOL(ARGF.binmode);
}

Gibt true zurück, wenn ARGF im Binärmodus gelesen wird; andernfalls false. Um den Binärmodus zu aktivieren, verwenden Sie ARGF.binmode.

Zum Beispiel

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

close → ARGF

Source

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;
}

Schließt die aktuelle Datei und springt zur nächsten Datei in ARGV. Wenn keine weiteren Dateien geöffnet werden müssen, schließt sie einfach die aktuelle Datei. STDIN wird nicht geschlossen.

Zum Beispiel

$ ruby argf.rb foo bar

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

closed? → true or false

Source

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

Gibt *true* zurück, wenn die aktuelle Datei geschlossen wurde; *false* andernfalls. Verwenden Sie ARGF.close, um die aktuelle Datei tatsächlich zu schließen.

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

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

each(...) → an_enumerator

Source

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;
}

Gibt einen Enumerator zurück, der über jede Zeile (getrennt durch *sep*, standardmäßig das Zeilenumbruchzeichen Ihrer Plattform) jeder Datei in ARGV iteriert. Wenn ein Block angegeben ist, wird jede Zeile nacheinander an den Block übergeben, andernfalls wird ein Enumerator zurückgegeben. Das optionale limit-Argument ist eine Integer, die die maximale Länge jeder Zeile angibt; längere Zeilen werden entsprechend diesem Limit aufgeteilt.

Diese Methode ermöglicht es Ihnen, die auf der Kommandozeile angegebenen Dateien als eine einzige Datei zu behandeln, die aus der Verkettung jeder benannten Datei besteht. Nach der letzten Zeile der ersten Datei wird die erste Zeile der zweiten Datei zurückgegeben. Die Methoden ARGF.filename und ARGF.lineno können verwendet werden, um den Dateinamen der aktuellen Zeile und die Zeilennummer der gesamten Eingabe zu ermitteln.

Zum Beispiel gibt der folgende Code jede Zeile jeder benannten Datei aus, die mit ihrer Zeilennummer präfixiert ist, und zeigt den Dateinamen einmal pro Datei an.

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

Während der folgende Code nur zuerst den Namen der ersten Datei ausgibt und den Inhalt mit der Zeilennummer, die über alle benannten Dateien zählt.

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

Auch als alias bezeichnet: each_line

each_byte {|byte| block } → ARGF

each_byte → an_enumerator

Source

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;
}

Iteriert über jedes Byte jeder Datei in ARGV. Ein Byte wird als Integer im Bereich 0..255 zurückgegeben.

Diese Methode ermöglicht es Ihnen, die auf der Kommandozeile angegebenen Dateien als eine einzige Datei zu behandeln, die aus der Verkettung jeder benannten Datei besteht. Nach dem letzten Byte der ersten Datei wird das erste Byte der zweiten Datei zurückgegeben. Die Methode ARGF.filename kann verwendet werden, um den Dateinamen des aktuellen Bytes zu ermitteln.

Wenn kein Block angegeben wird, wird stattdessen ein Enumerator zurückgegeben.

Zum Beispiel

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

each_char {|char| block } → ARGF

each_char → an_enumerator

Source

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;
}

Iteriert über jedes Zeichen jeder Datei in ARGF.

Diese Methode ermöglicht es Ihnen, die auf der Kommandozeile angegebenen Dateien als eine einzige Datei zu behandeln, die aus der Verkettung jeder benannten Datei besteht. Nach dem letzten Zeichen der ersten Datei wird das erste Zeichen der zweiten Datei zurückgegeben. Die Methode ARGF.filename kann verwendet werden, um den Namen der Datei zu ermitteln, in der das aktuelle Zeichen erscheint.

Wenn kein Block angegeben wird, wird stattdessen ein Enumerator zurückgegeben.

each_codepoint {|codepoint| block } → ARGF

each_codepoint → an_enumerator

Source

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;
}

Iteriert über jeden Codepoint jeder Datei in ARGF.

Diese Methode ermöglicht es Ihnen, die auf der Kommandozeile angegebenen Dateien als eine einzige Datei zu behandeln, die aus der Verkettung jeder benannten Datei besteht. Nach dem letzten Codepoint der ersten Datei wird der erste Codepoint der zweiten Datei zurückgegeben. Die Methode ARGF.filename kann verwendet werden, um den Namen der Datei zu ermitteln, in der der aktuelle Codepoint erscheint.

Wenn kein Block angegeben wird, wird stattdessen ein Enumerator zurückgegeben.

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

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

each_line(...) → an_enumerator

Zum Beispiel gibt der folgende Code jede Zeile jeder benannten Datei aus, die mit ihrer Zeilennummer präfixiert ist, und zeigt den Dateinamen einmal pro Datei an.

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

Während der folgende Code nur zuerst den Namen der ersten Datei ausgibt und den Inhalt mit der Zeilennummer, die über alle benannten Dateien zählt.

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

Alias für: each

eof → true oder false

Source

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;
}

Gibt true zurück, wenn die aktuelle Datei in ARGF das Ende der Datei erreicht hat, d.h. sie keine Daten mehr zum Lesen hat. Der Stream muss zum Lesen geöffnet sein, sonst wird eine IOError ausgelöst.

$ echo "eof" | ruby argf.rb

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

Auch als alias bezeichnet: eof?

eof? → true oder false

$ echo "eof" | ruby argf.rb

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

Alias für: eof

external_encoding → encoding

Source

static VALUE
argf_external_encoding(VALUE argf)
{
    return argf_encoding(argf, rb_io_external_encoding);
}

Gibt die externe Kodierung für aus ARGF gelesene Dateien als Encoding-Objekt zurück. Die externe Kodierung ist die Kodierung des Textes, wie er in einer Datei gespeichert ist. Im Gegensatz zu ARGF.internal_encoding, das die Kodierung ist, die zur Darstellung dieses Textes innerhalb von Ruby verwendet wird.

Um die externe Kodierung einzustellen, verwenden Sie ARGF.set_encoding.

Zum Beispiel

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

file → IO oder File object

Source

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

Gibt die aktuelle Datei als IO- oder File-Objekt zurück. $stdin wird zurückgegeben, wenn die aktuelle Datei STDIN ist.

Zum Beispiel

$ 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

Source

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

Gibt den aktuellen Dateinamen zurück. „-“ wird zurückgegeben, wenn die aktuelle Datei STDIN ist.

Zum Beispiel

$ 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"

Auch als alias bezeichnet: path

fileno → integer

Source

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);
}

Gibt eine Ganzzahl zurück, die den numerischen Dateideskriptor für die aktuelle Datei darstellt. Löst eine ArgumentError aus, wenn keine aktuelle Datei vorhanden ist.

ARGF.fileno    #=> 3

Auch als alias bezeichnet: to_i

getbyte → Integer oder nil

Source

static VALUE
argf_getbyte(VALUE argf)
{
    VALUE ch;

  retry:
    if (!next_argv()) return Qnil;
    if (!RB_TYPE_P(ARGF.current_file, T_FILE)) {
        ch = forward_current(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;
}

Liest das nächste 8-Bit-Byte (0..255) aus ARGF. Gibt nil zurück, wenn es am Ende des Streams aufgerufen wird.

Zum Beispiel

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

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

getc → String oder nil

Source

static VALUE
argf_getc(VALUE argf)
{
    VALUE ch;

  retry:
    if (!next_argv()) return Qnil;
    if (ARGF_GENERIC_INPUT_P()) {
        ch = forward_current(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;
}

Liest das nächste Zeichen aus ARGF und gibt es als String zurück. Gibt nil am Ende des Streams zurück.

ARGF behandelt die auf der Kommandozeile genannten Dateien als eine einzige Datei, die durch Verkettung ihrer Inhalte erstellt wird. Nach der Rückgabe des letzten Zeichens der ersten Datei gibt es das erste Zeichen der zweiten Datei usw. zurück.

Zum Beispiel

$ 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 oder nil

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

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

Source

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

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

    return line;
}

Gibt die nächste Zeile aus der aktuellen Datei in ARGF zurück.

Standardmäßig werden Zeilen durch $/ getrennt angenommen; um ein anderes Zeichen als Trennzeichen zu verwenden, übergeben Sie es als String für das sep-Argument.

Das optionale limit-Argument gibt an, wie viele Zeichen jeder Zeile zurückgegeben werden sollen. Standardmäßig werden alle Zeichen zurückgegeben.

Siehe IO.readlines für Details zu getline_args.

inplace_mode → String

Source

static VALUE
argf_inplace_mode_get(VALUE argf)
{
    if (!ARGF.inplace) return Qnil;
    if (NIL_P(ARGF.inplace)) return rb_str_new(0, 0);
    return rb_str_dup(ARGF.inplace);
}

Gibt die Dateierweiterung zurück, die den Namen von Sicherungskopien geänderter Dateien im Inplace-Bearbeitungsmodus angehängt wird. Dieser Wert kann mit ARGF.inplace_mode= oder durch Übergabe des Schalters -i an die Ruby-Binärdatei festgelegt werden.

inplace_mode = ext → ARGF

Source

static VALUE
argf_inplace_mode_set(VALUE argf, VALUE val)
{
    if (!RTEST(val)) {
        ARGF.inplace = Qfalse;
    }
    else if (StringValueCStr(val), !RSTRING_LEN(val)) {
        ARGF.inplace = Qnil;
    }
    else {
        ARGF.inplace = rb_str_new_frozen(val);
    }
    return argf;
}

Setzt die Dateinamenerweiterung für den Inplace-Bearbeitungsmodus auf die angegebene String. Die Sicherungskopie jeder bearbeiteten Datei erhält diesen Wert an ihren Dateinamen angehängt.

Zum Beispiel

$ ruby argf.rb file.txt

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

Zuerst wird *file.txt.bak* als Sicherungskopie von *file.txt* erstellt. Dann wird bei jeder Zeile von *file.txt* das erste Vorkommen von „foo“ durch „bar“ ersetzt.

inspect

Alias für: to_s

internal_encoding → encoding

Source

static VALUE
argf_internal_encoding(VALUE argf)
{
    return argf_encoding(argf, rb_io_internal_encoding);
}

Gibt die interne Kodierung für aus ARGF gelesene Zeichenketten als Encoding-Objekt zurück.

Wenn ARGF.set_encoding mit zwei Kodierungsnamen aufgerufen wurde, wird der zweite zurückgegeben. Andernfalls, wenn Encoding.default_external gesetzt wurde, wird dieser Wert zurückgegeben. Andernfalls, wenn eine Standard-Externe-Kodierung auf der Kommandozeile angegeben wurde, wird dieser Wert verwendet. Wenn die Kodierung unbekannt ist, wird nil zurückgegeben.

lineno → integer

Source

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

Gibt die aktuelle Zeilennummer von ARGF als Ganzes zurück. Dieser Wert kann manuell mit ARGF.lineno= gesetzt werden.

Zum Beispiel

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

lineno = integer → integer

Source

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

Setzt die Zeilennummer von ARGF als Ganzes auf die angegebene Integer.

ARGF setzt die Zeilennummer automatisch, während Sie Daten lesen, daher müssen Sie sie normalerweise nicht explizit setzen. Um die aktuelle Zeilennummer abzurufen, verwenden Sie ARGF.lineno.

Zum Beispiel

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

path → String

Gibt den aktuellen Dateinamen zurück. „-“ wird zurückgegeben, wenn die aktuelle Datei STDIN ist.

Zum Beispiel

$ 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"

Alias für: filename

pos → Integer

Gibt den aktuellen Offset (in Bytes) der aktuellen Datei in ARGF zurück.

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

Alias für: tell

pos = position → Integer

Source

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);
}

Setzt die Position auf den durch position gegebenen Offset (in Bytes) in ARGF.

Zum Beispiel

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

print(*objects) → nil

Source

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;
    }
    if (argc > 1 && !NIL_P(rb_output_fs)) {
        rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$, is set to non-nil value");
    }
    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;
}

Schreibt die gegebenen Objekte in den Stream; gibt nil zurück. Hängt den Ausgabe-Datensatz-Separator $OUTPUT_RECORD_SEPARATOR ($\) an, wenn er nicht nil ist. Siehe Line IO.

Mit dem Argument objects, für jedes Objekt

Konvertiert über seine Methode to_s, wenn es keine Zeichenkette ist.
Schreibt in den Stream.
Wenn es nicht das letzte Objekt ist, schreibt den Ausgabe-Feld-Separator $OUTPUT_FIELD_SEPARATOR ($,), wenn er nicht nil ist.

Mit Standardtrennzeichen

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

Ausgabe

nil
nil
"00.00/10+0izerozero"

Mit spezifizierten Trennzeichen

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

Ausgabe

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

Ohne Argument wird der Inhalt von $_ geschrieben (was normalerweise die letzte Benutzereingabe ist).

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

printf(format_string, *objects) → nil

Source

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

Formatiert und schreibt objects in den Stream.

Details zu format_string finden Sie unter Formatangaben.

putc(object) → object

Source

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;
}

Schreibt ein Zeichen in den Stream. Siehe Character IO.

Wenn object numerisch ist, wird es bei Bedarf in eine Ganzzahl konvertiert, dann wird das Zeichen mit dem niedrigstwertigen Byte als Code geschrieben; wenn object eine Zeichenkette ist, wird das erste Zeichen geschrieben.

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

Ausgabe

AA

puts(*objects) → nil

Source

VALUE
rb_io_puts(int argc, const VALUE *argv, VALUE out)
{
    VALUE line, args[2];

    /* if no argument given, print newline. */
    if (argc == 0) {
        rb_io_write(out, rb_default_rs);
        return Qnil;
    }
    for (int i = 0; i < argc; i++) {
        // Convert the argument to a string:
        if (RB_TYPE_P(argv[i], T_STRING)) {
            line = argv[i];
        }
        else if (rb_exec_recursive(io_puts_ary, argv[i], out)) {
            continue;
        }
        else {
            line = rb_obj_as_string(argv[i]);
        }

        // Write the line:
        int n = 0;
        if (RSTRING_LEN(line) == 0) {
            args[n++] = rb_default_rs;
        }
        else {
            args[n++] = line;
            if (!rb_str_end_with_asciichar(line, '\n')) {
                args[n++] = rb_default_rs;
            }
        }

        rb_io_writev(out, n, args);
    }

    return Qnil;
}

Schreibt die gegebenen objects in den Stream, der zum Schreiben geöffnet sein muss; gibt nil zurück.\ Schreibt eine neue Zeile nach jeder, die nicht bereits mit einer neuen Zeilensequenz endet. Wenn ohne Argumente aufgerufen, schreibt es eine neue Zeile. Siehe Line IO.

Beachten Sie, dass jede hinzugefügte neue Zeile das Zeichen "\n"<//tt> ist, nicht der Ausgabe-Datensatz-Separator (<tt>$\).

Behandlung für jedes Objekt

String: schreibt die Zeichenkette.
Weder Zeichenkette noch Array: schreibt object.to_s.
Array: schreibt jedes Element des Arrays; Arrays können verschachtelt sein.

Um diese Beispiele kurz zu halten, definieren wir diese Hilfsmethode:

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, oder nil

Source

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) {
            argv[0] = LONG2NUM(len - slen);
            goto retry;
        }
    }
    return str;
}

Liest length Bytes aus ARGF. Die auf der Kommandozeile genannten Dateien werden verkettet und von dieser Methode als eine einzige Datei behandelt, so dass beim Aufruf ohne Argumente der Inhalt dieser Pseudodatei vollständig zurückgegeben wird.

length muss eine nicht-negative Ganzzahl oder nil sein.

Wenn length eine positive Ganzzahl ist, versucht read, length Bytes ohne Konvertierung (Binärmodus) zu lesen. Sie gibt nil zurück, wenn vor dem Lesen ein EOF angetroffen wird. Weniger als length Bytes werden zurückgegeben, wenn während des Lesens ein EOF angetroffen wird. Im Fall einer Ganzzahl length hat die resultierende Zeichenkette immer die Kodierung ASCII-8BIT.

Wenn length weggelassen wird oder nil ist, wird bis zum EOF gelesen und die Kodierungskonvertierung wird, falls zutreffend, angewendet. Eine Zeichenkette wird auch dann zurückgegeben, wenn vor dem Lesen von Daten ein EOF angetroffen wird.

Wenn length null ist, gibt sie eine leere Zeichenkette ("") zurück.

Wenn das optionale outbuf-Argument vorhanden ist, muss es sich auf eine String beziehen, die die Daten aufnehmen wird. Der outbuf enthält nach dem Methodenaufruf nur die empfangenen Daten, auch wenn er am Anfang nicht leer war.

Zum Beispiel

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

Beachten Sie, dass diese Methode ähnlich wie die fread()-Funktion in C funktioniert. Das bedeutet, dass sie versucht, read(2)-Systemaufrufe wiederholt aufzurufen, um Daten mit der angegebenen Länge zu lesen. Wenn Sie das Verhalten eines einzelnen read(2)-Systemaufrufs benötigen, ziehen Sie ARGF#readpartial oder ARGF#read_nonblock in Betracht.

read_nonblock(maxlen[, options]) → string

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

Source

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);
}

Liest höchstens maxlen Bytes aus dem ARGF-Stream im nicht-blockierenden Modus.

readbyte → Integer

Source

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;
}

Liest das nächste 8-Bit-Byte aus ARGF und gibt es als Integer zurück. Löst eine EOFError aus, nachdem das letzte Byte der letzten Datei gelesen wurde.

Zum Beispiel

$ 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 oder nil

Source

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 = forward_current(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;
}

Liest das nächste Zeichen aus ARGF und gibt es als String zurück. Löst eine EOFError am Ende der letzten Datei aus.

Zum Beispiel

$ 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

Source

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;
}

Gibt die nächste Zeile aus der aktuellen Datei in ARGF zurück.

Standardmäßig werden Zeilen durch $/ getrennt angenommen; um ein anderes Zeichen als Trennzeichen zu verwenden, übergeben Sie es als String für das sep-Argument.

Das optionale limit-Argument gibt an, wie viele Zeichen jeder Zeile zurückgegeben werden sollen. Standardmäßig werden alle Zeichen zurückgegeben.

Am Ende der Datei wird eine EOFError ausgelöst.

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

readlines(limit, chomp: false) → array

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

Source

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 = forward_current(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;
}

Liest jede Datei in ARGF vollständig und gibt ein Array mit den Zeilen aus den Dateien zurück. Zeilen werden standardmäßig durch sep getrennt.

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

Siehe IO.readlines für eine vollständige Beschreibung aller Optionen.

Auch als alias bezeichnet: to_a

readpartial(maxlen) → string

readpartial(maxlen, outbuf) → outbuf

Source

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

Liest höchstens maxlen Bytes aus dem ARGF-Stream.

Es löst eine EOFError am Ende des ARGF-Streams aus. Da der ARGF-Stream eine Verkettung mehrerer Dateien ist, tritt EOF intern für jede Datei auf. ARGF.readpartial gibt leere Zeichenketten für EOFs zurück, außer für den letzten, und löst für den letzten eine EOFError aus.

rewind → 0

Source

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;
}

Positioniert die aktuelle Datei an den Anfang der Eingabe und setzt ARGF.lineno auf null zurück.

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

Source

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);
}

Setzt die Position auf den Offset amount (eine Integer) im ARGF-Stream, entsprechend dem Wert von whence. Siehe IO#seek für weitere Details.

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

Source

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;
}

Wenn ein einzelnes Argument angegeben wird, werden die aus ARGF gelesenen Zeichenketten mit der angegebenen Kodierung versehen.

Wenn zwei durch einen Doppelpunkt getrennte Kodierungsnamen angegeben werden, z. B. „ascii:utf-8“, wird die gelesene Zeichenkette von der ersten Kodierung (externe Kodierung) in die zweite Kodierung (interne Kodierung) konvertiert und dann mit der zweiten Kodierung versehen.

Wenn zwei Argumente angegeben werden, müssen es Kodierungsobjekte oder Kodierungsnamen sein. Wiederum gibt die erste die externe Kodierung an; die zweite die interne Kodierung.

Wenn die externe und die interne Kodierung angegeben sind, kann das optionale Hash-Argument verwendet werden, um den Konvertierungsprozess anzupassen. Die Struktur dieses Hashs wird in der Dokumentation zu String#encode erklärt.

Zum Beispiel

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

Source

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

Setzt die aktuelle Datei auf die nächste Datei in ARGV. Wenn keine weiteren Dateien vorhanden sind, hat dies keine Auswirkung.

Zum Beispiel

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

tell → Integer

Source

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);
}

Gibt den aktuellen Offset (in Bytes) der aktuellen Datei in ARGF zurück.

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

Auch als alias bezeichnet: pos

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

to_a(limit, chomp: false) → array

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

Liest jede Datei in ARGF vollständig und gibt ein Array mit den Zeilen aus den Dateien zurück. Zeilen werden standardmäßig durch sep getrennt.

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

Siehe IO.readlines für eine vollständige Beschreibung aller Optionen.

Alias für: readlines

to_i → integer

Gibt eine Ganzzahl zurück, die den numerischen Dateideskriptor für die aktuelle Datei darstellt. Löst eine ArgumentError aus, wenn keine aktuelle Datei vorhanden ist.

ARGF.fileno    #=> 3

Alias für: fileno

to_io → IO

Source

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

Gibt ein IO-Objekt zurück, das die aktuelle Datei repräsentiert. Dies ist ein File-Objekt, es sei denn, die aktuelle Datei ist ein Stream wie STDIN.

Zum Beispiel

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

to_s → String

Source

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

Gibt „ARGF“ zurück.

Auch als alias bezeichnet: inspect

to_write_io → io

Source

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);
}

Gibt eine IO-Instanz zurück, die für das Schreiben an ARGF gebunden ist, wenn der Inplace-Modus aktiviert ist.

write(*objects) → integer

Source

static VALUE
argf_write(int argc, VALUE *argv, VALUE argf)
{
    return rb_io_writev(argf_write_io(argf), argc, argv);
}

Schreibt jedes der angegebenen objects, wenn der Inplace-Modus aktiv ist.