Ruby - Datei-E / A.

Ruby bietet eine ganze Reihe von E / A-bezogenen Methoden, die im Kernel-Modul implementiert sind. Alle E / A-Methoden werden von der Klasse IO abgeleitet.

Die Klasse IO bietet alle grundlegenden Methoden, wie Lesen, Schreiben, bekommt, puts, Readline-, getc, und printf .

Dieses Kapitel behandelt alle grundlegenden E / A-Funktionen, die in Ruby verfügbar sind. Weitere Funktionen finden Sie unter Ruby Class IO .

Die Puts-Anweisung

In den vorherigen Kapiteln haben Sie Variablen Werte zugewiesen und die Ausgabe dann mit der Puts- Anweisung gedruckt .

Die put- Anweisung weist das Programm an, den in der Variablen gespeicherten Wert anzuzeigen. Dadurch wird am Ende jeder geschriebenen Zeile eine neue Zeile hinzugefügt.

Beispiel

#!/usr/bin/ruby

val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

Dies führt zu folgendem Ergebnis:

This is variable one
This is variable two

Das bekommt Statement

Die get- Anweisung kann verwendet werden, um alle Eingaben des Benutzers vom Standardbildschirm STDIN zu übernehmen.

Beispiel

Der folgende Code zeigt Ihnen, wie Sie die get-Anweisung verwenden. Dieser Code fordert den Benutzer auf, einen Wert einzugeben, der in einem variablen Wert gespeichert und schließlich auf STDOUT gedruckt wird.

#!/usr/bin/ruby

puts "Enter a value :"
val = gets
puts val

Dies führt zu folgendem Ergebnis:

Enter a value :
This is entered value
This is entered value

Die putc Aussage

Im Gegensatz zur put- Anweisung, die die gesamte Zeichenfolge auf dem Bildschirm ausgibt , kann mit der putc- Anweisung jeweils ein Zeichen ausgegeben werden.

Beispiel

Die Ausgabe des folgenden Codes ist nur das Zeichen H -

#!/usr/bin/ruby

str = "Hello Ruby!"
putc str

Dies führt zu folgendem Ergebnis:

Die Druckanweisung

Die print- Anweisung ähnelt der put- Anweisung. Der einzige Unterschied besteht darin , dass die Puts Aussage in die nächste Zeile geht nach den Inhalt gedruckt wird , während bei der Druck Anweisung der Cursor auf der gleichen Linie positioniert ist.

Beispiel

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

Dies führt zu folgendem Ergebnis:

Hello WorldGood Morning

Dateien öffnen und schließen

Bis jetzt haben Sie die Standardeingabe und -ausgabe gelesen und geschrieben. Jetzt werden wir sehen, wie man mit tatsächlichen Datendateien spielt.

Die File.new-Methode

Sie können ein erstellen Datei - Objekt mit File.new zum Lesen, Schreiben oder beides, je nach Betriebsart String - Methode. Schließlich können Sie die File.close- Methode verwenden, um diese Datei zu schließen.

Syntax

aFile = File.new("filename", "mode")
   # ... process the file
aFile.close

Die File.open-Methode

Mit der File.open- Methode können Sie ein neues Dateiobjekt erstellen und dieses Dateiobjekt einer Datei zuweisen. Es gibt jedoch einen Unterschied zwischen den Methoden File.open und File.new . Der Unterschied besteht darin, dass die File.open- Methode einem Block zugeordnet werden kann, während Sie dies mit der File.new- Methode nicht tun können .

File.open("filename", "mode") do |aFile|
   # ... process the file
end

Hier ist eine Liste der verschiedenen Modi zum Öffnen einer Datei -

Sr.Nr.	Modi & Beschreibung
1	r Schreibgeschützter Modus. Der Dateizeiger befindet sich am Anfang der Datei. Dies ist der Standardmodus.
2	r+ Lese- / Schreibmodus. Der Dateizeiger befindet sich am Anfang der Datei.
3	w Nur-Schreib-Modus. Überschreibt die Datei, wenn die Datei vorhanden ist. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Schreiben erstellt.
4	w+ Lese- / Schreibmodus. Überschreibt die vorhandene Datei, wenn die Datei vorhanden ist. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Lesen und Schreiben erstellt.
5	a Nur-Schreib-Modus. Der Dateizeiger befindet sich am Ende der Datei, wenn die Datei vorhanden ist. Das heißt, die Datei befindet sich im Anhänge-Modus. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Schreiben erstellt.
6	a+ Lese- und Schreibmodus. Der Dateizeiger befindet sich am Ende der Datei, wenn die Datei vorhanden ist. Die Datei wird im Anhänge-Modus geöffnet. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Lesen und Schreiben erstellt.

Dateien lesen und schreiben

Die gleichen Methoden, die wir für 'einfache' E / A verwendet haben, sind für alle Dateiobjekte verfügbar. Get liest also eine Zeile aus der Standardeingabe und aFile.gets liest eine Zeile aus dem Dateiobjekt aFile.

E / A-Objekte bieten jedoch zusätzliche Zugriffsmethoden, um unser Leben zu erleichtern.

Die Sysread-Methode

Mit der Methode sysread können Sie den Inhalt einer Datei lesen. Sie können die Datei in jedem der Modi öffnen, wenn Sie die Methode sysread verwenden. Zum Beispiel -

Es folgt die Eingabetextdatei -

This is a simple text file for testing purpose.

Versuchen wir nun, diese Datei zu lesen -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r")
if aFile
   content = aFile.sysread(20)
   puts content
else
   puts "Unable to open file!"
end

Diese Anweisung gibt die ersten 20 Zeichen der Datei aus. Der Dateizeiger wird nun auf das 21. Zeichen in der Datei gesetzt.

Die Syswrite-Methode

Mit der Methode syswrite können Sie den Inhalt in eine Datei schreiben. Sie müssen die Datei im Schreibmodus öffnen, wenn Sie die Methode syswrite verwenden. Zum Beispiel -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
else
   puts "Unable to open file!"
end

Diese Anweisung schreibt "ABCDEF" in die Datei.

Die each_byte-Methode

Diese Methode gehört zur Klasse Datei . Die Methode each_byte ist immer einem Block zugeordnet. Betrachten Sie das folgende Codebeispiel -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
   aFile.each_byte {|ch| putc ch; putc ?. }
else
   puts "Unable to open file!"
end

Zeichen werden einzeln an die Variable ch übergeben und dann wie folgt auf dem Bildschirm angezeigt:

s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...
.
.

Die IO.readlines-Methode

Die Klasse Datei ist eine Unterklasse der Klasse IO. Die Klasse IO verfügt auch über einige Methoden, mit denen Dateien bearbeitet werden können.

Eine der IO-Klassenmethoden ist IO.readlines . Diese Methode gibt den Inhalt der Datei zeilenweise zurück. Der folgende Code zeigt die Verwendung der Methode IO.readlines -

#!/usr/bin/ruby

arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]

In diesem Code ist die Variable arr ein Array. Jede Zeile der Datei input.txt ist ein Element im Array arr. Daher enthält arr [0] die erste Zeile, während arr [1] die zweite Zeile der Datei enthält.

Die IO.foreach-Methode

Diese Methode gibt die Ausgabe auch zeilenweise zurück. Der Unterschied zwischen der Methode foreach und den Methoden- Readlines besteht darin, dass die Methode foreach einem Block zugeordnet ist. Im Gegensatz zu den Methoden- Readlines gibt die Methode foreach jedoch kein Array zurück. Zum Beispiel -

#!/usr/bin/ruby

IO.foreach("input.txt"){|block| puts block}

Dieser Code wird den Inhalt der Datei passiert Test Zeile für Zeile mit dem variablen Block, und dann wird die Ausgabe auf dem Bildschirm angezeigt werden.

Dateien umbenennen und löschen

Mit den Methoden zum Umbenennen und Löschen können Sie Dateien programmgesteuert mit Ruby umbenennen und löschen .

Es folgt das Beispiel zum Umbenennen einer vorhandenen Datei test1.txt -

#!/usr/bin/ruby

# Rename a file from test1.txt to test2.txt
File.rename( "test1.txt", "test2.txt" )

Es folgt das Beispiel zum Löschen einer vorhandenen Datei test2.txt -

#!/usr/bin/ruby

# Delete file test2.txt
File.delete("test2.txt")

Dateimodi und Besitz

Verwenden Sie die chmod- Methode mit einer Maske, um den Modus oder die Berechtigungs- / Zugriffsliste einer Datei zu ändern.

Das folgende Beispiel ändert den Modus einer vorhandenen Datei test.txt in einen Maskenwert :

#!/usr/bin/ruby

file = File.new( "test.txt", "w" )
file.chmod( 0755 )

Im Folgenden finden Sie eine Tabelle, die Ihnen bei der Auswahl einer anderen Maske für die chmod- Methode helfen kann.

Sr.Nr.	Maske & Beschreibung
1	0700 RWX-Maske für Besitzer
2	0400 r für Besitzer
3	0200 w für Besitzer
4	0100 x für Besitzer
5	0070 rwx Maske für Gruppe
6	0040 r für Gruppe
7	0020 w für Gruppe
8	0010 x für Gruppe
9	0007 RWX-Maske für andere
10	0004 r für andere
11	0002 w für andere
12	0001 x für andere
13	4000 Legen Sie die Benutzer-ID bei der Ausführung fest
14	2000 Legen Sie die Gruppen-ID bei der Ausführung fest
15	1000 Speichern Sie den ausgetauschten Text auch nach der Verwendung

Dateianfragen

Der folgende Befehl testet vor dem Öffnen, ob eine Datei vorhanden ist:

#!/usr/bin/ruby

File.open("file.rb") if File::exists?( "file.rb" )

Der folgende Befehl fragt ab, ob die Datei wirklich eine Datei ist -

#!/usr/bin/ruby

# This returns either true or false
File.file?( "text.txt" )

Der folgende Befehl ermittelt, ob der angegebene Dateiname ein Verzeichnis ist -

#!/usr/bin/ruby

# a directory
File::directory?( "/usr/local/bin" ) # => true

# a file
File::directory?( "file.rb" ) # => false

Der folgende Befehl ermittelt, ob die Datei lesbar, beschreibbar oder ausführbar ist.

#!/usr/bin/ruby

File.readable?( "test.txt" )   # => true
File.writable?( "test.txt" )   # => true
File.executable?( "test.txt" ) # => false

Der folgende Befehl ermittelt, ob die Datei die Größe Null hat oder nicht -

#!/usr/bin/ruby

File.zero?( "test.txt" )      # => true

Der folgende Befehl gibt die Größe der Datei zurück -

#!/usr/bin/ruby

File.size?( "text.txt" )     # => 1002

Mit dem folgenden Befehl können Sie einen Dateityp ermitteln:

#!/usr/bin/ruby

File::ftype( "test.txt" )     # => file

Die ftype-Methode identifiziert den Dateityp, indem sie eine der folgenden Optionen zurückgibt: Datei, Verzeichnis, CharacterSpecial, BlockSpecial, Fifo, Link, Socket oder Unbekannt.

Mit dem folgenden Befehl können Sie ermitteln, wann eine Datei erstellt, geändert oder zuletzt aufgerufen wurde:

#!/usr/bin/ruby

File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008
File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008
File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

Verzeichnisse in Ruby

Alle Dateien sind in verschiedenen Verzeichnissen enthalten, und Ruby hat auch keine Probleme damit. Während die File- Klasse Dateien verarbeitet, werden Verzeichnisse mit der Dir- Klasse behandelt.

Durch Verzeichnisse navigieren

Verwenden Sie Dir.chdir wie folgt, um das Verzeichnis innerhalb eines Ruby-Programms zu ändern . In diesem Beispiel wird das aktuelle Verzeichnis in / usr / bin geändert .

Dir.chdir("/usr/bin")

Mit Dir.pwd können Sie herausfinden, wie das aktuelle Verzeichnis lautet -

puts Dir.pwd # This will return something like /usr/bin

Mit Dir.entries - können Sie eine Liste der Dateien und Verzeichnisse in einem bestimmten Verzeichnis abrufen.

puts Dir.entries("/usr/bin").join(' ')

Dir.entries gibt ein Array mit allen Einträgen im angegebenen Verzeichnis zurück. Dir.foreach bietet die gleiche Funktion -

Dir.foreach("/usr/bin") do |entry|
   puts entry
end

Eine noch präzisere Methode zum Abrufen von Verzeichnislisten ist die Verwendung der Klassenarray-Methode von Dir -

Dir["/usr/bin/*"]

Verzeichnis erstellen

Mit Dir.mkdir können Verzeichnisse erstellt werden -

Dir.mkdir("mynewdir")

Sie können mit mkdir auch Berechtigungen für ein neues Verzeichnis festlegen (das noch nicht vorhanden ist).

NOTE - Die Maske 755 setzt die Berechtigungen Eigentümer, Gruppe, Welt [jedermann] auf rwxr-xr-x, wobei r = Lesen, w = Schreiben und x = Ausführen.

Dir.mkdir( "mynewdir", 755 )

Verzeichnis löschen

Mit Dir.delete kann ein Verzeichnis gelöscht werden. Die Dir.unlink und Dir.rmdir führt genau die gleiche Funktion und sind für die Bequemlichkeit zur Verfügung gestellt.

Dir.delete("testdir")

Dateien und temporäre Verzeichnisse erstellen

Temporäre Dateien sind solche, die möglicherweise während der Ausführung eines Programms kurz erstellt werden, jedoch kein permanenter Informationsspeicher sind.

Dir.tmpdir stellt den Pfad zum temporären Verzeichnis auf dem aktuellen System bereit, obwohl die Methode standardmäßig nicht verfügbar ist. Um Dir.tmpdir verfügbar zu machen, muss require 'tmpdir' verwendet werden.

Sie können Dir.tmpdir mit File.join verwenden , um eine plattformunabhängige temporäre Datei zu erstellen.

require 'tmpdir'
   tempfilename = File.join(Dir.tmpdir, "tingtong")
   tempfile = File.new(tempfilename, "w")
   tempfile.puts "This is a temporary file"
   tempfile.close
   File.delete(tempfilename)

Dieser Code erstellt eine temporäre Datei, schreibt Daten in sie und löscht sie. Rubys Standardbibliothek enthält auch eine Bibliothek namens Tempfile , mit der temporäre Dateien für Sie erstellt werden können.

require 'tempfile'
   f = Tempfile.new('tingtong')
   f.puts "Hello"
   puts f.path
   f.close

Eingebaute Funktionen

Hier sind die in Ruby integrierten Funktionen zum Verarbeiten von Dateien und Verzeichnissen:

Dateiklasse und Methoden .
Dir Klasse und Methoden .