class File

Ein File-Objekt ist eine Repräsentation einer Datei im zugrundeliegenden System.

Die Klasse File erweitert das Modul FileTest und unterstützt Singleton-Methoden wie File.exist?.

Über die Beispiele

Viele Beispiele hier verwenden diese Variablen

# English text with newlines.
text = <<~EOT
  First line
  Second line

  Fourth line
  Fifth line
EOT

# Russian text.
russian = "\u{442 435 441 442}" # => "тест"

# Binary data.
data = "\u9990\u9991\u9992\u9993\u9994"

# Text file.
File.write('t.txt', text)

# File with Russian text.
File.write('t.rus', russian)

# File with binary data.
f = File.new('t.dat', 'wb:UTF-16')
f.write(data)
f.close

Zugriffsmodi

Die Methoden File.new und File.open erstellen jeweils ein File-Objekt für einen gegebenen Dateipfad.

Zeichenketten-Zugriffsmodi

Die Methoden File.new und File.open können ein Zeichenkettenargument mode annehmen, welches

beginnt mit einem 1- oder 2-stelligen Lese-/Schreibmodus.
kann auch einen 1-stelligen Datenmodus enthalten.
kann auch einen 1-stelligen Datei-Erstellungsmodus enthalten.

Lese-/Schreibmodus

Der Lese-/Schreibmodus mode bestimmt

ob die Datei anfänglich gekürzt werden soll.
ob das Lesen erlaubt ist, und wenn ja
- die anfängliche Leseposition in der Datei.
- wo in der Datei gelesen werden kann.
ob das Schreiben erlaubt ist, und wenn ja
- die anfängliche Schreibposition in der Datei.
- wo in der Datei geschrieben werden kann.

Diese Tabellen fassen zusammen

Read/Write Modes for Existing File

|------|-----------|----------|----------|----------|-----------|
| R/W  | Initial   |          | Initial  |          | Initial   |
| Mode | Truncate? |  Read    | Read Pos |  Write   | Write Pos |
|------|-----------|----------|----------|----------|-----------|
| 'r'  |    No     | Anywhere |    0     |   Error  |     -     |
| 'w'  |    Yes    |   Error  |    -     | Anywhere |     0     |
| 'a'  |    No     |   Error  |    -     | End only |    End    |
| 'r+' |    No     | Anywhere |    0     | Anywhere |     0     |
| 'w+' |    Yes    | Anywhere |    0     | Anywhere |     0     |
| 'a+' |    No     | Anywhere |   End    | End only |    End    |
|------|-----------|----------|----------|----------|-----------|

Read/Write Modes for \File To Be Created

|------|----------|----------|----------|-----------|
| R/W  |          | Initial  |          | Initial   |
| Mode |  Read    | Read Pos |  Write   | Write Pos |
|------|----------|----------|----------|-----------|
| 'w'  |   Error  |    -     | Anywhere |     0     |
| 'a'  |   Error  |    -     | End only |     0     |
| 'w+' | Anywhere |    0     | Anywhere |     0     |
| 'a+' | Anywhere |    0     | End only |    End    |
|------|----------|----------|----------|-----------|

Beachten Sie, dass die Modi 'r' und 'r+' für eine nicht existierende Datei nicht erlaubt sind (Ausnahme wird ausgelöst).

In den Tabellen

Anywhere bedeutet, dass die Methoden IO#rewind, IO#pos= und IO#seek verwendet werden können, um die Position der Datei zu ändern, sodass erlaubtes Lesen oder Schreiben überall in der Datei erfolgen kann.
End only bedeutet, dass das Schreiben nur am Dateiende erfolgen kann und dass die Methoden IO#rewind, IO#pos= und IO#seek das Schreiben nicht beeinflussen.
Error bedeutet, dass eine Ausnahme ausgelöst wird, wenn ein nicht erlaubtes Lesen oder Schreiben versucht wird.

Lese-/Schreibmodi für existierende Dateien

'r':

Datei wird nicht anfänglich gekürzt

f = File.new('t.txt') # => #<File:t.txt>
f.size == 0           # => false

Anfängliche Leseposition der Datei ist 0
```
f.pos # => 0
```

Datei kann überall gelesen werden; siehe IO#rewind, IO#pos=, IO#seek

f.readline # => "First line\n"
f.readline # => "Second line\n"

f.rewind
f.readline # => "First line\n"

f.pos = 1
f.readline # => "irst line\n"

f.seek(1, :CUR)
f.readline # => "econd line\n"

Schreiben ist nicht erlaubt
```
f.write('foo') # Raises IOError.
```

'w':

Datei wird anfänglich gekürzt

path = 't.tmp'
File.write(path, text)
f = File.new(path, 'w')
f.size == 0 # => true

Anfängliche Schreibposition der Datei ist 0
```
f.pos # => 0
```

Datei kann überall geschrieben werden (sogar über das Dateiende hinaus); siehe IO#rewind, IO#pos=, IO#seek

f.write('foo')
f.flush
File.read(path) # => "foo"
f.pos # => 3

f.write('bar')
f.flush
File.read(path) # => "foobar"
f.pos # => 6

f.rewind
f.write('baz')
f.flush
File.read(path) # => "bazbar"
f.pos # => 3

f.pos = 3
f.write('foo')
f.flush
File.read(path) # => "bazfoo"
f.pos # => 6

f.seek(-3, :END)
f.write('bam')
f.flush
File.read(path) # => "bazbam"
f.pos # => 6

f.pos = 8
f.write('bah')  # Zero padding as needed.
f.flush
File.read(path) # => "bazbam\u0000\u0000bah"
f.pos # => 11

Lesen ist nicht erlaubt
```
f.read # Raises IOError.
```

'a':

Datei wird nicht anfänglich gekürzt

path = 't.tmp'
File.write(path, 'foo')
f = File.new(path, 'a')
f.size == 0 # => false

Anfängliche Position der Datei ist 0 (wird aber ignoriert)
```
f.pos # => 0
```

Datei kann nur am Ende geschrieben werden; IO#rewind, IO#pos=, IO#seek beeinflussen das Schreiben nicht

f.write('bar')
f.flush
File.read(path) # => "foobar"
f.write('baz')
f.flush
File.read(path) # => "foobarbaz"

f.rewind
f.write('bat')
f.flush
File.read(path) # => "foobarbazbat"

Lesen ist nicht erlaubt
```
f.read # Raises IOError.
```

'r+':

Datei wird nicht anfänglich gekürzt

path = 't.tmp'
File.write(path, text)
f = File.new(path, 'r+')
f.size == 0 # => false

Anfängliche Leseposition der Datei ist 0
```
f.pos # => 0
```

Datei kann überall gelesen oder geschrieben werden (sogar über das Dateiende hinaus); siehe IO#rewind, IO#pos=, IO#seek

f.readline # => "First line\n"
f.readline # => "Second line\n"

f.rewind
f.readline # => "First line\n"

f.pos = 1
f.readline # => "irst line\n"

f.seek(1, :CUR)
f.readline # => "econd line\n"

f.rewind
f.write('WWW')
f.flush
File.read(path)
# => "WWWst line\nSecond line\nFourth line\nFifth line\n"

f.pos = 10
f.write('XXX')
f.flush
File.read(path)
# => "WWWst lineXXXecond line\nFourth line\nFifth line\n"

f.seek(-6, :END)
# => 0
f.write('YYY')
# => 3
f.flush
# => #<File:t.tmp>
File.read(path)
# => "WWWst lineXXXecond line\nFourth line\nFifth YYYe\n"

f.seek(2, :END)
f.write('ZZZ') # Zero padding as needed.
f.flush
File.read(path)
# => "WWWst lineXXXecond line\nFourth line\nFifth YYYe\n\u0000\u0000ZZZ"

'a+':

Datei wird nicht anfänglich gekürzt

path = 't.tmp'
File.write(path, 'foo')
f = File.new(path, 'a+')
f.size == 0 # => false

Anfängliche Leseposition der Datei ist 0
```
f.pos # => 0
```

Datei kann nur am Ende geschrieben werden; IO#rewind, IO#pos=, IO#seek beeinflussen das Schreiben nicht

f.write('bar')
f.flush
File.read(path)      # => "foobar"
f.write('baz')
f.flush
File.read(path)      # => "foobarbaz"

f.rewind
f.write('bat')
f.flush
File.read(path) # => "foobarbazbat"

Datei kann überall gelesen werden; siehe IO#rewind, IO#pos=, IO#seek

f.rewind
f.read # => "foobarbazbat"

f.pos = 3
f.read # => "barbazbat"

f.seek(-3, :END)
f.read # => "bat"

Lese-/Schreibmodi für zu erstellende Dateien

Beachten Sie, dass die Modi 'r' und 'r+' für eine nicht existierende Datei nicht erlaubt sind (Ausnahme wird ausgelöst).

'w':

Anfängliche Schreibposition der Datei ist 0

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'w')
f.pos # => 0

Datei kann überall geschrieben werden (sogar über das Dateiende hinaus); siehe IO#rewind, IO#pos=, IO#seek

f.write('foo')
f.flush
File.read(path) # => "foo"
f.pos # => 3

f.write('bar')
f.flush
File.read(path) # => "foobar"
f.pos # => 6

f.rewind
f.write('baz')
f.flush
File.read(path) # => "bazbar"
f.pos # => 3

f.pos = 3
f.write('foo')
f.flush
File.read(path) # => "bazfoo"
f.pos # => 6

f.seek(-3, :END)
f.write('bam')
f.flush
File.read(path) # => "bazbam"
f.pos # => 6

f.pos = 8
f.write('bah')  # Zero padding as needed.
f.flush
File.read(path) # => "bazbam\u0000\u0000bah"
f.pos # => 11

Lesen ist nicht erlaubt
```
f.read # Raises IOError.
```

'a':

Anfängliche Schreibposition der Datei ist 0

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'a')
f.pos # => 0

Schreiben erfolgt nur am Dateiende

f.write('foo')
f.pos # => 3
f.write('bar')
f.pos # => 6
f.flush
File.read(path) # => "foobar"

f.rewind
f.write('baz')
f.flush
File.read(path) # => "foobarbaz"

Lesen ist nicht erlaubt
```
f.read # Raises IOError.
```

'w+':

Anfängliche Position der Datei ist 0

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'w+')
f.pos # => 0

Datei kann überall geschrieben werden (sogar über das Dateiende hinaus); siehe IO#rewind, IO#pos=, IO#seek

f.write('foo')
f.flush
File.read(path) # => "foo"
f.pos # => 3

f.write('bar')
f.flush
File.read(path) # => "foobar"
f.pos # => 6

f.rewind
f.write('baz')
f.flush
File.read(path) # => "bazbar"
f.pos # => 3

f.pos = 3
f.write('foo')
f.flush
File.read(path) # => "bazfoo"
f.pos # => 6

f.seek(-3, :END)
f.write('bam')
f.flush
File.read(path) # => "bazbam"
f.pos # => 6

f.pos = 8
f.write('bah')  # Zero padding as needed.
f.flush
File.read(path) # => "bazbam\u0000\u0000bah"
f.pos # => 11

Datei kann überall gelesen werden (sogar über das Dateiende hinaus); siehe IO#rewind, IO#pos=, IO#seek

f.rewind
# => 0
f.read
# => "bazbam\u0000\u0000bah"

f.pos = 3
# => 3
f.read
# => "bam\u0000\u0000bah"

f.seek(-3, :END)
# => 0
f.read
# => "bah"

'a+':

Anfängliche Schreibposition der Datei ist 0

path = 't.tmp'
FileUtils.rm_f(path)
f = File.new(path, 'a+')
f.pos # => 0

Schreiben erfolgt nur am Dateiende

f.write('foo')
f.pos # => 3
f.write('bar')
f.pos # => 6
f.flush
File.read(path) # => "foobar"

f.rewind
f.write('baz')
f.flush
File.read(path) # => "foobarbaz"

Datei kann überall gelesen werden (sogar über das Dateiende hinaus); siehe IO#rewind, IO#pos=, IO#seek

f.rewind
f.read # => "foobarbaz"

f.pos = 3
f.read # => "barbaz"

f.seek(-3, :END)
f.read # => "baz"

f.pos = 800
f.read # => ""

Datenmodus

Um anzugeben, ob Daten als Text oder als Binärdaten behandelt werden sollen, kann eines der folgenden Suffixe an einen der obigen Zeichenketten-Lese-/Schreibmodi angehängt werden

't': Textdaten; setzt die Standard-Externe Kodierung auf Encoding::UTF_8; unter Windows, aktiviert die Konvertierung zwischen EOL und CRLF und interpretiert 0x1A als End-of-File-Markierung.
'b': Binärdaten; setzt die Standard-Externe Kodierung auf Encoding::ASCII_8BIT; unter Windows, unterdrückt die Konvertierung zwischen EOL und CRLF und deaktiviert die Interpretation von 0x1A als End-of-File-Markierung.

Wenn keiner angegeben ist, wird der Stream standardmäßig auf Textdaten gesetzt.

Beispiele

File.new('t.txt', 'rt')
File.new('t.dat', 'rb')

Wenn der Datenmodus angegeben ist, darf der Lese-/Schreibmodus nicht weggelassen werden, und der Datenmodus muss dem Datei-Erstellungsmodus vorausgehen, falls angegeben.

File.new('t.dat', 'b')   # Raises an exception.
File.new('t.dat', 'rxb') # Raises an exception.

Datei-Erstellungsmodus

Das Folgende kann an jeden schreibbaren Zeichenkettenmodus angehängt werden.

'x': Erstellt die Datei, falls sie nicht existiert; löst eine Ausnahme aus, falls die Datei existiert.

Beispiel

File.new('t.tmp', 'wx')

Wenn der Datei-Erstellungsmodus angegeben ist, darf der Lese-/Schreibmodus nicht weggelassen werden, und der Datei-Erstellungsmodus muss dem Datenmodus folgen.

File.new('t.dat', 'x')   # Raises an exception.
File.new('t.dat', 'rxb') # Raises an exception.

Ganzzahlige Zugriffsmodi

Wenn der Modus eine ganze Zahl ist, muss er eine oder mehrere der folgenden Konstanten sein, die durch den bitweisen OR-Operator | kombiniert werden können.

File::RDONLY: Zum Nur-Lesen öffnen.
File::WRONLY: Zum Nur-Schreiben öffnen.
File::RDWR: Zum Lesen und Schreiben öffnen.
File::APPEND: Zum Anhängen öffnen.

Beispiele

File.new('t.txt', File::RDONLY)
File.new('t.tmp', File::RDWR | File::CREAT | File::EXCL)

Hinweis: Die Methode IO#set_encoding erlaubt nicht, dass der Modus als Ganzzahl angegeben wird.

Ganzzahliger Datei-Erstellungsmodus

Diese Konstanten können auch in den Ganzzahlmodus mittels OR verknüpft werden.

File::CREAT: Datei erstellen, falls sie nicht existiert.
File::EXCL: Ausnahme auslösen, wenn File::CREAT gegeben ist und die Datei existiert.

Ganzzahliger Datenmodus

Der Datenmodus kann nicht als Ganzzahl angegeben werden. Wenn der Stream-Zugriffsmodus als Ganzzahl angegeben wird, ist der Datenmodus immer Text, niemals Binär.

Beachten Sie, dass es zwar eine Konstante File::BINARY gibt, deren Wert in einem ganzzahligen Stream-Modus jedoch keine Auswirkung hat; dies liegt daran, dass, wie in File::Constants dokumentiert, der Wert File::BINARY die Zeilenkonvertierung deaktiviert, aber nicht die externe Kodierung ändert.

Kodierungen

Jeder der oben genannten Zeichenkettenmodi kann Kodierungen angeben - entweder nur externe Kodierung oder sowohl externe als auch interne Kodierungen - indem ein oder beide Kodierungsnamen, getrennt durch Doppelpunkte, angehängt werden.

f = File.new('t.dat', 'rb')
f.external_encoding # => #<Encoding:ASCII-8BIT>
f.internal_encoding # => nil
f = File.new('t.dat', 'rb:UTF-16')
f.external_encoding # => #<Encoding:UTF-16 (dummy)>
f.internal_encoding # => nil
f = File.new('t.dat', 'rb:UTF-16:UTF-16')
f.external_encoding # => #<Encoding:UTF-16 (dummy)>
f.internal_encoding # => #<Encoding:UTF-16>
f.close

Die zahlreichen Kodierungsnamen sind in der Liste Encoding.name_list verfügbar.

Encoding.name_list.take(3) # => ["ASCII-8BIT", "UTF-8", "US-ASCII"]

Wenn die externe Kodierung gesetzt ist, werden gelesene Zeichenketten beim Lesen mit dieser Kodierung versehen, und geschriebene Zeichenketten werden beim Schreiben in diese Kodierung konvertiert.

Wenn sowohl externe als auch interne Kodierungen gesetzt sind, werden gelesene Zeichenketten von der externen in die interne Kodierung konvertiert, und geschriebene Zeichenketten werden von der internen in die externe Kodierung konvertiert. Weitere Details zur Transkodierung von Ein- und Ausgaben finden Sie unter Encodings.

Wenn die externe Kodierung 'BOM|UTF-8', 'BOM|UTF-16LE' oder 'BOM|UTF16-BE' ist, prüft Ruby auf eine Unicode-BOM im Eingabedokument, um die Kodierung zu ermitteln. Für UTF-16-Kodierungen muss der Dateimodus binär sein. Wenn die BOM gefunden wird, wird sie entfernt und die externe Kodierung aus der BOM verwendet.

Beachten Sie, dass die BOM-Stil-Kodierungsoption nicht zwischen Groß- und Kleinschreibung unterscheidet, sodass 'bom|utf-8' ebenfalls gültig ist.

Dateiberechtigungen

Ein File-Objekt hat Berechtigungen, eine oktale Ganzzahl, die die Berechtigungen einer tatsächlichen Datei im zugrundeliegenden System darstellt.

Beachten Sie, dass Dateiberechtigungen ganz anders sind als der Modus eines Dateistreams (File-Objekt).

In einem File-Objekt sind die Berechtigungen wie folgt verfügbar, wobei die Methode mode trotz ihres Namens die Berechtigungen zurückgibt.

f = File.new('t.txt')
f.lstat.mode.to_s(8) # => "100644"

Auf einem Unix-basierten Betriebssystem stellen die drei niedrigwertigen oktalen Ziffern die Berechtigungen für den Eigentümer (6), die Gruppe (4) und die Welt (4) dar. Das Bit-Tripel in jeder oktalen Ziffer repräsentiert jeweils Lese-, Schreib- und Ausführungsberechtigungen.

Berechtigungen 0644 stellen also Lese-/Schreibzugriff für den Eigentümer und Nur-Lesezugriff für Gruppe und Welt dar. Siehe manpages open(2) und chmod(2).

Für ein Verzeichnis ändert sich die Bedeutung des Ausführungsbits: Wenn es gesetzt ist, kann im Verzeichnis gesucht werden.

Höherwertige Bits in Berechtigungen können den Dateityp (einfach, Verzeichnis, Pipe, Socket usw.) und verschiedene andere spezielle Merkmale anzeigen.

Auf nicht-Posix-Betriebssystemen können Berechtigungen nur Lese-/Schreibzugriff umfassen, in diesem Fall ähneln die verbleibenden Berechtigungen typischen Werten. Unter Windows sind beispielsweise die Standardberechtigungen 0644; Die einzige Änderung, die vorgenommen werden kann, ist, die Datei schreibgeschützt zu machen, was als 0444 gemeldet wird.

Für eine Methode, die tatsächlich eine Datei im zugrundeliegenden System erstellt (im Gegensatz zur bloßen Erstellung eines File-Objekts), können Berechtigungen angegeben werden.

File.new('t.tmp', File::CREAT, 0644)
File.new('t.tmp', File::CREAT, 0444)

Berechtigungen können auch geändert werden.

f = File.new('t.tmp', File::CREAT, 0444)
f.chmod(0644)
f.chmod(0444)

File-Konstanten

Verschiedene Konstanten für die Verwendung in File- und IO-Methoden finden Sie im Modul File::Constants; ein Array ihrer Namen wird von File::Constants.constants zurückgegeben.

Was gibt es hier

Zuerst, was woanders ist. Klasse File

Erbt von Klasse IO, insbesondere Methoden zum Erstellen, Lesen und Schreiben von Dateien.
Enthält das Modul FileTest, das Dutzende weiterer Methoden bietet.

Hier bietet die Klasse File Methoden, die nützlich sind für

Erstellen

::new: Öffnet die Datei unter dem gegebenen Pfad; gibt die Datei zurück.
::open: Dasselbe wie ::new, aber wenn ein Block gegeben wird, wird die Datei an den Block übergeben und die Datei beim Verlassen des Blocks geschlossen.
::link: Erstellt einen neuen Namen für eine existierende Datei mithilfe eines Hardlinks.
::mkfifo: Gibt die FIFO-Datei zurück, die unter dem gegebenen Pfad erstellt wurde.
::symlink: Erstellt einen symbolischen Link für den gegebenen Dateipfad.

Abfragen

Pfade

::absolute_path: Gibt den absoluten Dateipfad für den gegebenen Pfad zurück.
::absolute_path?: Gibt zurück, ob der gegebene Pfad der absolute Dateipfad ist.
::basename: Gibt die letzte Komponente des gegebenen Dateipfads zurück.
::dirname: Gibt alle Komponenten außer der letzten des gegebenen Dateipfads zurück.
::expand_path: Gibt den absoluten Dateipfad für den gegebenen Pfad zurück, wobei ~ für ein Home-Verzeichnis erweitert wird.
::extname: Gibt die Dateierweiterung für den gegebenen Dateipfad zurück.
::fnmatch? (aliasiert als ::fnmatch): Gibt zurück, ob der gegebene Dateipfad dem gegebenen Muster entspricht.
::join: Fügt Pfadkomponenten zu einer einzelnen Pfadzeichenkette zusammen.
::path: Gibt die Zeichenkettenrepräsentation des gegebenen Pfads zurück.
::readlink: Gibt den Pfad zur Datei im gegebenen symbolischen Link zurück.
::realdirpath: Gibt den realen Pfad für den gegebenen Dateipfad zurück, wobei die letzte Komponente nicht existieren muss.
::realpath: Gibt den realen Pfad für den gegebenen Dateipfad zurück, wobei alle Komponenten existieren müssen.
::split: Gibt ein Array aus zwei Zeichenketten zurück: dem Verzeichnisnamen und dem Basenamen der Datei unter dem gegebenen Pfad.
path (aliasiert als to_path): Gibt die Zeichenkettenrepräsentation des gegebenen Pfads zurück.

Zeiten

::atime: Gibt eine Time für den letzten Zugriff auf die gegebene Datei zurück.
::birthtime: Gibt eine Time für die Erstellung der gegebenen Datei zurück.
::ctime: Gibt eine Time für die Änderung der Metadaten der gegebenen Datei zurück.
::mtime: Gibt eine Time für die letzte Datenmodifikation des Inhalts der gegebenen Datei zurück.
atime: Gibt eine Time für den letzten Zugriff auf self zurück.
birthtime: Gibt eine Time für die Erstellung von self zurück.
ctime: Gibt eine Time für die Änderung der Metadaten von self zurück.
mtime: Gibt eine Time für die letzte Datenmodifikation des Inhalts von self zurück.

Typen

::blockdev?: Gibt zurück, ob die Datei unter dem gegebenen Pfad ein Blockgerät ist.
::chardev?: Gibt zurück, ob die Datei unter dem gegebenen Pfad ein Zeichengerät ist.
::directory?: Gibt zurück, ob die Datei unter dem gegebenen Pfad ein Verzeichnis ist.
::executable?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für die effektive Benutzer- und Gruppen-ID des aktuellen Prozesses ausführbar ist.
::executable_real?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für den realen Benutzer und die reale Gruppe des aktuellen Prozesses ausführbar ist.
::exist?: Gibt zurück, ob die Datei unter dem gegebenen Pfad existiert.
::file?: Gibt zurück, ob die Datei unter dem gegebenen Pfad eine reguläre Datei ist.
::ftype: Gibt einen String zurück, der den Typ der Datei unter dem gegebenen Pfad angibt.
::grpowned?: Gibt zurück, ob die effektive Gruppe des aktuellen Prozesses Eigentümer der Datei unter dem gegebenen Pfad ist.
::identical?: Gibt zurück, ob die Dateien unter zwei gegebenen Pfaden identisch sind.
::lstat: Gibt das File::Stat-Objekt für den letzten symbolischen Link im gegebenen Pfad zurück.
::owned?: Gibt zurück, ob der effektive Benutzer des aktuellen Prozesses Eigentümer der Datei unter dem gegebenen Pfad ist.
::pipe?: Gibt zurück, ob die Datei unter dem gegebenen Pfad eine Pipe ist.
::readable?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für die effektive Benutzer- und Gruppen-ID des aktuellen Prozesses lesbar ist.
::readable_real?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für den realen Benutzer und die reale Gruppe des aktuellen Prozesses lesbar ist.
::setgid?: Gibt zurück, ob das Setgid-Bit für die Datei unter dem gegebenen Pfad gesetzt ist.
::setuid?: Gibt zurück, ob das Setuid-Bit für die Datei unter dem gegebenen Pfad gesetzt ist.
::socket?: Gibt zurück, ob die Datei unter dem gegebenen Pfad ein Socket ist.
::stat: Gibt das File::Stat-Objekt für die Datei unter dem gegebenen Pfad zurück.
::sticky?: Gibt zurück, ob die Datei unter dem gegebenen Pfad ihr Sticky-Bit gesetzt hat.
::symlink?: Gibt zurück, ob die Datei unter dem gegebenen Pfad ein symbolischer Link ist.
::umask: Gibt den Umask-Wert für den aktuellen Prozess zurück.
::world_readable?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für andere lesbar ist.
::world_writable?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für andere schreibbar ist.
::writable?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für die effektive Benutzer- und Gruppen-ID des aktuellen Prozesses schreibbar ist.
::writable_real?: Gibt zurück, ob die Datei unter dem gegebenen Pfad für den realen Benutzer und die reale Gruppe des aktuellen Prozesses schreibbar ist.
lstat: Gibt das File::Stat-Objekt für den letzten symbolischen Link im Pfad von self zurück.

Inhalt

::empty? (aliasiert als ::zero?): Gibt zurück, ob die Datei unter dem gegebenen Pfad existiert und leer ist.
::size: Gibt die Größe (in Bytes) der Datei unter dem gegebenen Pfad zurück.
::size?: Gibt nil zurück, wenn keine Datei unter dem gegebenen Pfad existiert oder wenn diese Datei leer ist; andernfalls gibt es die Dateigröße (in Bytes) zurück.
size: Gibt die Größe (in Bytes) von self zurück.

Einstellungen

::chmod: Ändert die Berechtigungen der Datei unter dem gegebenen Pfad.
::chown: Ändert den Besitz der Datei unter dem gegebenen Pfad.
::lchmod: Ändert die Berechtigungen des letzten symbolischen Links im gegebenen Pfad.
::lchown: Ändert den Besitz des letzten symbolischen Links im gegebenen Pfad.
::lutime: Setzt für jeden gegebenen Dateipfad die Zugriffszeit und die Änderungszeit des letzten symbolischen Links im Pfad.
::rename: Verschiebt die Datei von einem gegebenen Pfad zu einem anderen gegebenen Pfad.
::utime: Setzt die Zugriffszeit und die Änderungszeit jeder Datei unter den gegebenen Pfaden.
flock: Sperrt oder entsperrt self.

Sonstiges

::truncate: Kürzt die Datei unter dem gegebenen Dateipfad auf die gegebene Größe.
::unlink (aliasiert als ::delete): Löscht die Datei für jeden gegebenen Dateipfad.
truncate: Kürzt self auf die gegebene Größe.

Constants

ALT_SEPARATOR: plattformspezifischer alternativer Trenner
PATH_SEPARATOR: Pfadlistentrenner
SEPARATOR: trennt Verzeichnisteile in einem Pfad
Separator: trennt Verzeichnisteile in einem Pfad

Öffentliche Klassenmethoden

absolute_path(file_name [, dir_string] ) → abs_file_name

Source

static VALUE
s_absolute_path(int c, const VALUE * v, VALUE _)
{
    return rb_file_s_absolute_path(c, v);
}

Konvertiert einen Pfadnamen in einen absoluten Pfadnamen. Relative Pfade werden vom aktuellen Arbeitsverzeichnis des Prozesses aus referenziert, es sei denn, dir_string wird angegeben, in welchem Fall es als Ausgangspunkt verwendet wird. Wenn der gegebene Pfadname mit einem „~“ beginnt, wird er NICHT erweitert, er wird als normaler Verzeichnisname behandelt.

File.absolute_path("~oracle/bin")       #=> "<relative_path>/~oracle/bin"

absolute_path?(file_name) → true oder false

Source

static VALUE
s_absolute_path_p(VALUE klass, VALUE fname)
{
    VALUE path = rb_get_path(fname);

    if (!rb_is_absolute_path(RSTRING_PTR(path))) return Qfalse;
    return Qtrue;
}

Gibt true zurück, wenn file_name ein absoluter Pfad ist, und andernfalls false.

File.absolute_path?("c:/foo")     #=> false (on Linux), true (on Windows)

atime(file_name) → time

Source

static VALUE
rb_file_s_atime(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return stat_time(stat_atimespec(&st));
}

Gibt die letzte Zugriffszeit für die benannte Datei als Time-Objekt zurück.

file_name kann ein IO-Objekt sein.

File.atime("testfile")   #=> Wed Apr 09 08:51:48 CDT 2003

basename(file_name [, suffix] ) → base_name

Source

static VALUE
rb_file_s_basename(int argc, VALUE *argv, VALUE _)
{
    VALUE fname, fext, basename;
    const char *name, *p;
    long f, n;
    rb_encoding *enc;

    fext = Qnil;
    if (rb_check_arity(argc, 1, 2) == 2) {
        fext = argv[1];
        StringValue(fext);
        enc = check_path_encoding(fext);
    }
    fname = argv[0];
    FilePathStringValue(fname);
    if (NIL_P(fext) || !(enc = rb_enc_compatible(fname, fext))) {
        enc = rb_enc_get(fname);
        fext = Qnil;
    }
    if ((n = RSTRING_LEN(fname)) == 0 || !*(name = RSTRING_PTR(fname)))
        return rb_str_new_shared(fname);

    p = ruby_enc_find_basename(name, &f, &n, enc);
    if (n >= 0) {
        if (NIL_P(fext)) {
            f = n;
        }
        else {
            const char *fp;
            fp = StringValueCStr(fext);
            if (!(f = rmext(p, f, n, fp, RSTRING_LEN(fext), enc))) {
                f = n;
            }
            RB_GC_GUARD(fext);
        }
        if (f == RSTRING_LEN(fname)) return rb_str_new_shared(fname);
    }

    basename = rb_str_new(p, f);
    rb_enc_copy(basename, fname);
    return basename;
}

Gibt die letzte Komponente des Dateinamens zurück, der in file_name angegeben ist (nachdem zuerst nachgestellte Trennzeichen entfernt wurden), der sowohl File::SEPARATOR als auch File::ALT_SEPARATOR als Trennzeichen verwenden kann, wenn File::ALT_SEPARATOR nicht nil ist. Wenn suffix angegeben ist und am Ende von file_name vorhanden ist, wird er entfernt. Wenn suffix „.*“ ist, wird jede Erweiterung entfernt.

File.basename("/home/gumby/work/ruby.rb")          #=> "ruby.rb"
File.basename("/home/gumby/work/ruby.rb", ".rb")   #=> "ruby"
File.basename("/home/gumby/work/ruby.rb", ".*")    #=> "ruby"

birthtime(file_name) → time

Source

VALUE
rb_file_s_birthtime(VALUE klass, VALUE fname)
{
    rb_io_stat_data st;

    if (rb_statx(fname, &st, STATX_BTIME) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return statx_birthtime(&st);
}

Gibt die Erzeugungszeit für die benannte Datei zurück.

file_name kann ein IO-Objekt sein.

File.birthtime("testfile")   #=> Wed Apr 09 08:53:13 CDT 2003

Wenn die Plattform keine Erzeugungszeit hat, wird NotImplementedError ausgelöst.

blockdev?(filepath) → true oder false

Source

static VALUE
rb_file_blockdev_p(VALUE obj, VALUE fname)
{
#ifndef S_ISBLK
#   ifdef S_IFBLK
#       define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
#   else
#       define S_ISBLK(m) (0)  /* anytime false */
#   endif
#endif

#ifdef S_ISBLK
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISBLK(st.st_mode)) return Qtrue;

#endif
    return Qfalse;
}

Gibt true zurück, wenn filepath auf ein Blockgerät zeigt, andernfalls false.

File.blockdev?('/dev/sda1')       # => true
File.blockdev?(File.new('t.tmp')) # => false

chardev?(filepath) → true oder false

Source

static VALUE
rb_file_chardev_p(VALUE obj, VALUE fname)
{
#ifndef S_ISCHR
#   define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
#endif

    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISCHR(st.st_mode)) return Qtrue;

    return Qfalse;
}

Gibt true zurück, wenn filepath auf ein Zeichengerät zeigt, andernfalls false.

File.chardev?($stdin)     # => true
File.chardev?('t.txt')     # => false

chmod(mode_int, file_name, ... ) → integer

Source

static VALUE
rb_file_s_chmod(int argc, VALUE *argv, VALUE _)
{
    mode_t mode;

    apply2args(1);
    mode = NUM2MODET(*argv++);

    return apply2files(chmod_internal, argc, argv, &mode);
}

Ändert die Berechtigungsbits der benannten Datei(en) auf das durch mode_int dargestellte Bitmuster. Tatsächliche Auswirkungen sind betriebssystemabhängig (siehe Anfang dieses Abschnitts). Auf Unix-Systemen siehe chmod(2) für Details. Gibt die Anzahl der verarbeiteten Dateien zurück.

File.chmod(0644, "testfile", "out")   #=> 2

chown(owner_int, group_int, file_name, ...) → integer

Source

static VALUE
rb_file_s_chown(int argc, VALUE *argv, VALUE _)
{
    struct chown_args arg;

    apply2args(2);
    arg.owner = to_uid(*argv++);
    arg.group = to_gid(*argv++);

    return apply2files(chown_internal, argc, argv, &arg);
}

Ändert den Eigentümer und die Gruppe der benannten Datei(en) auf die angegebenen numerischen Owner- und Group-IDs. Nur ein Prozess mit Superuser-Rechten darf den Eigentümer einer Datei ändern. Der aktuelle Eigentümer einer Datei kann die Gruppe der Datei zu jeder Gruppe ändern, zu der der Eigentümer gehört. Eine nil- oder -1-Owner- oder Group-ID wird ignoriert. Gibt die Anzahl der verarbeiteten Dateien zurück.

File.chown(nil, 100, "testfile")

ctime(file_name) → time

Source

static VALUE
rb_file_s_ctime(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return stat_time(stat_ctimespec(&st));
}

Gibt die Änderungszeit für die benannte Datei zurück (die Zeit, zu der die Verzeichnisinformationen über die Datei geändert wurden, nicht die Datei selbst).

file_name kann ein IO-Objekt sein.

Beachten Sie, dass unter Windows (NTFS) die Erzeugungszeit (birth time) zurückgegeben wird.

File.ctime("testfile")   #=> Wed Apr 09 08:53:13 CDT 2003

delete(file_name, ...) → integer

unlink(file_name, ...) → integer

Source

static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
    return apply2files(unlink_internal, argc, argv, 0);
}

Löscht die benannten Dateien und gibt die Anzahl der als Argumente übergebenen Namen zurück. Löst bei jedem Fehler eine Ausnahme aus. Da die zugrundeliegende Implementierung den Systemaufruf unlink(2) verwendet, hängt der ausgelöste Ausnahmetyp von seinem Fehlertyp ab (siehe linux.die.net/man/2/unlink) und hat die Form z.B. Errno::ENOENT.

Siehe auch Dir::rmdir.

directory?(path) → true oder false

Source

VALUE
rb_file_directory_p(VALUE obj, VALUE fname)
{
#ifndef S_ISDIR
#   define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
#endif

    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISDIR(st.st_mode)) return Qtrue;
    return Qfalse;
}

Wenn das Objekt eine Zeichenkette ist, gibt true zurück, wenn path ein Zeichenkettenpfad ist, der zu einem Verzeichnis oder einem symbolischen Link zu einem Verzeichnis führt; andernfalls false.

File.directory?('.')              # => true
File.directory?('foo')            # => false
File.symlink('.', 'dirlink')      # => 0
File.directory?('dirlink')        # => true
File.symlink('t,txt', 'filelink') # => 0
File.directory?('filelink')       # => false

Das Argument path kann ein IO-Objekt sein.

dirname(file_name, level = 1) → dir_name

Source

static VALUE
rb_file_s_dirname(int argc, VALUE *argv, VALUE klass)
{
    int n = 1;
    if ((argc = rb_check_arity(argc, 1, 2)) > 1) {
        n = NUM2INT(argv[1]);
    }
    return rb_file_dirname_n(argv[0], n);
}

Gibt alle Komponenten des Dateinamens zurück, der in file_name angegeben ist, außer der letzten (nachdem zuerst nachgestellte Trennzeichen entfernt wurden). Der Dateiname kann sowohl File::SEPARATOR als auch File::ALT_SEPARATOR als Trennzeichen verwenden, wenn File::ALT_SEPARATOR nicht nil ist.

File.dirname("/home/gumby/work/ruby.rb")   #=> "/home/gumby/work"

Wenn level angegeben ist, werden die letzten level Komponenten entfernt, nicht nur eine.

File.dirname("/home/gumby/work/ruby.rb", 2) #=> "/home/gumby"
File.dirname("/home/gumby/work/ruby.rb", 4) #=> "/"

zero?(file_name) → true oder false

Source

static VALUE
rb_file_zero_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(st.st_size == 0);
}

Gibt true zurück, wenn die benannte Datei existiert und eine Größe von Null hat.

file_name kann ein IO-Objekt sein.

executable?(file_name) → true oder false

Source

static VALUE
rb_file_executable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, X_OK) >= 0);
}

Gibt true zurück, wenn die benannte Datei für die effektive Benutzer- und Gruppen-ID dieses Prozesses ausführbar ist. Siehe eaccess(3).

Windows unterstützt keine Ausführungsberechtigungen getrennt von Leseberechtigungen. Unter Windows gilt eine Datei nur dann als ausführbar, wenn sie auf .bat, .cmd, .com oder .exe endet.

Beachten Sie, dass einige OS-Level-Sicherheitsfunktionen dazu führen können, dass dieser Wert true zurückgibt, obwohl die Datei für den effektiven Benutzer/die effektive Gruppe nicht ausführbar ist.

executable_real?(file_name) → true oder false

Source

static VALUE
rb_file_executable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, X_OK) >= 0);
}

Gibt true zurück, wenn die benannte Datei für die reale Benutzer- und Gruppen-ID dieses Prozesses ausführbar ist. Siehe access(3).

Windows unterstützt keine Ausführungsberechtigungen getrennt von Leseberechtigungen. Unter Windows gilt eine Datei nur dann als ausführbar, wenn sie auf .bat, .cmd, .com oder .exe endet.

Beachten Sie, dass einige OS-Level-Sicherheitsfunktionen dazu führen können, dass dieser Wert true zurückgibt, obwohl die Datei für den realen Benutzer/die reale Gruppe nicht ausführbar ist.

exist?(file_name) → true oder false

Source

static VALUE
rb_file_exist_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return Qtrue;
}

Gibt true zurück, wenn die benannte Datei existiert.

file_name kann ein IO-Objekt sein.

„Datei existiert“ bedeutet, dass der Systemaufruf stat() oder fstat() erfolgreich ist.

expand_path(file_name [, dir_string] ) → abs_file_name

Source

static VALUE
s_expand_path(int c, const VALUE * v, VALUE _)
{
    return rb_file_s_expand_path(c, v);
}

Konvertiert einen Pfadnamen in einen absoluten Pfadnamen. Relative Pfade werden vom aktuellen Arbeitsverzeichnis des Prozesses aus referenziert, es sei denn, dir_string wird angegeben, in welchem Fall es als Ausgangspunkt verwendet wird. Der gegebene Pfadname kann mit einem „~“ beginnen, was zum Home-Verzeichnis des Prozessbenutzers erweitert wird (die Umgebungsvariable HOME muss korrekt gesetzt sein). „~user“ wird zum Home-Verzeichnis des benannten Benutzers erweitert.

File.expand_path("~oracle/bin")           #=> "/home/oracle/bin"

Ein einfaches Beispiel für die Verwendung von dir_string ist wie folgt.

File.expand_path("ruby", "/usr/bin")      #=> "/usr/bin/ruby"

Ein komplexeres Beispiel, das auch das übergeordnete Verzeichnis auflöst, ist wie folgt. Angenommen, wir befinden uns in bin/mygem und möchten den absoluten Pfad zu lib/mygem.rb.

File.expand_path("../../lib/mygem.rb", __FILE__)
#=> ".../path/to/project/lib/mygem.rb"

So löst es zuerst das übergeordnete Verzeichnis von __FILE__ auf, das ist bin/, geht dann zum übergeordneten Verzeichnis, der Wurzel des Projekts und fügt lib/mygem.rb hinzu.

extname(path) → string

Source

static VALUE
rb_file_s_extname(VALUE klass, VALUE fname)
{
    const char *name, *e;
    long len;
    VALUE extname;

    FilePathStringValue(fname);
    name = StringValueCStr(fname);
    len = RSTRING_LEN(fname);
    e = ruby_enc_find_extname(name, &len, rb_enc_get(fname));
    if (len < 1)
        return rb_str_new(0, 0);
    extname = rb_str_subseq(fname, e - name, len); /* keep the dot, too! */
    return extname;
}

Gibt die Erweiterung zurück (der Teil des Dateinamens in path, der mit dem letzten Punkt beginnt).

Wenn path eine Punktdatei ist oder mit einem Punkt beginnt, wird der anfängliche Punkt nicht als Anfang der Erweiterung behandelt.

Eine leere Zeichenkette wird auch zurückgegeben, wenn der Punkt das letzte Zeichen in path ist.

Unter Windows werden nachgestellte Punkte abgeschnitten.

File.extname("test.rb")         #=> ".rb"
File.extname("a/b/d/test.rb")   #=> ".rb"
File.extname(".a/b/d/test.rb")  #=> ".rb"
File.extname("foo.")            #=> "" on Windows
File.extname("foo.")            #=> "." on non-Windows
File.extname("test")            #=> ""
File.extname(".profile")        #=> ""
File.extname(".profile.sh")     #=> ".sh"

file?(file) → true oder false

Source

static VALUE
rb_file_file_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(S_ISREG(st.st_mode));
}

Gibt true zurück, wenn die benannte file existiert und eine reguläre Datei ist.

file kann ein IO-Objekt sein.

Wenn das file-Argument ein symbolischer Link ist, wird der symbolische Link aufgelöst und die vom Link referenzierte Datei verwendet.

fnmatch( pattern, path, [flags] ) → (true oder false)

Source

# File dir.rb, line 503
def fnmatch(pattern, path, flags = 0)
end

Gibt true zurück, wenn path mit pattern übereinstimmt. Das Muster ist kein regulärer Ausdruck; stattdessen folgt es Regeln ähnlich wie die Shell-Dateinamensmuster. Es kann die folgenden Metazeichen enthalten.

*

Passt auf jede Datei. Kann durch andere Werte in der Glob-Syntax eingeschränkt werden. Entspricht /.*/x in regexp.

*: Passt auf alle regulären Dateien.
c*: Passt auf alle Dateien, die mit c beginnen.
*c: Passt auf alle Dateien, die mit c enden.
*c*: Passt auf alle Dateien, die c enthalten (einschließlich am Anfang oder Ende).

Um versteckte Dateien (die mit einem . beginnen) abzugleichen, setzen Sie das Flag File::FNM_DOTMATCH.

**

Passt rekursiv auf Verzeichnisse oder expansiv auf Dateien.

?

Passt auf ein einzelnes Zeichen. Entspricht /.{1}/ in regexp.

[set]

Passt auf ein einzelnes Zeichen in set. Verhält sich genau wie Zeichenmengen in Regexp, einschließlich Mengennegation ([^a-z]).

\

Maskiert das nächste Metazeichen.

{a,b}

Passt auf Muster a und Muster b, wenn das Flag File::FNM_EXTGLOB aktiviert ist. Verhält sich wie eine Regexp-Vereinigung ((?:a|b)).

flags ist ein bitweiser OR der FNM_XXX-Konstanten. Das gleiche Glob-Muster und die gleichen Flags werden von Dir::glob verwendet.

Beispiele

File.fnmatch('cat',       'cat')        #=> true  # match entire string
File.fnmatch('cat',       'category')   #=> false # only match partial string

File.fnmatch('c{at,ub}s', 'cats')                    #=> false # { } isn't supported by default
File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true  # { } is supported on FNM_EXTGLOB

File.fnmatch('c?t',     'cat')          #=> true  # '?' match only 1 character
File.fnmatch('c??t',    'cat')          #=> false # ditto
File.fnmatch('c*',      'cats')         #=> true  # '*' match 0 or more characters
File.fnmatch('c*t',     'c/a/b/t')      #=> true  # ditto
File.fnmatch('ca[a-z]', 'cat')          #=> true  # inclusive bracket expression
File.fnmatch('ca[^t]',  'cat')          #=> false # exclusive bracket expression ('^' or '!')

File.fnmatch('cat', 'CAT')                     #=> false # case sensitive
File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true  # case insensitive
File.fnmatch('cat', 'CAT', File::FNM_SYSCASE)  #=> true or false # depends on the system default

File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false # wildcard doesn't match '/' on FNM_PATHNAME
File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false # ditto
File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false # ditto

File.fnmatch('\?',   '?')                       #=> true  # escaped wildcard becomes ordinary
File.fnmatch('\a',   'a')                       #=> true  # escaped ordinary remains ordinary
File.fnmatch('\a',   '\a', File::FNM_NOESCAPE)  #=> true  # FNM_NOESCAPE makes '\' ordinary
File.fnmatch('[\?]', '?')                       #=> true  # can escape inside bracket expression

File.fnmatch('*',   '.profile')                      #=> false # wildcard doesn't match leading
File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true  # period by default.
File.fnmatch('.*',  '.profile')                      #=> true

File.fnmatch('**/*.rb', 'main.rb')                  #=> false
File.fnmatch('**/*.rb', './main.rb')                #=> false
File.fnmatch('**/*.rb', 'lib/song.rb')              #=> true
File.fnmatch('**.rb', 'main.rb')                    #=> true
File.fnmatch('**.rb', './main.rb')                  #=> false
File.fnmatch('**.rb', 'lib/song.rb')                #=> true
File.fnmatch('*',     'dave/.profile')              #=> true

File.fnmatch('**/foo', 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
File.fnmatch('**/foo', '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
File.fnmatch('**/foo', 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
File.fnmatch('**/foo', 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
File.fnmatch('**/foo', 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

Auch aliased als: fnmatch?

fnmatch?( pattern, path, [flags] ) → (true oder false)

Alias für: fnmatch

ftype(file_name) → string

Source

static VALUE
rb_file_s_ftype(VALUE klass, VALUE fname)
{
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstat_without_gvl(StringValueCStr(fname), &st) == -1) {
        rb_sys_fail_path(fname);
    }

    return rb_file_ftype(st.st_mode);
}

Identifiziert den Typ der benannten Datei; der Rückgabestring ist einer von „file“, „directory“, „characterSpecial“, „blockSpecial“, „fifo“, „link“, „socket“ oder „unknown“.

File.ftype("testfile")            #=> "file"
File.ftype("/dev/tty")            #=> "characterSpecial"
File.ftype("/tmp/.X11-unix/X0")   #=> "socket"

grpowned?(file_name) → true oder false

Source

static VALUE
rb_file_grpowned_p(VALUE obj, VALUE fname)
{
#ifndef _WIN32
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (rb_group_member(st.st_gid)) return Qtrue;
#endif
    return Qfalse;
}

Gibt true zurück, wenn die benannte Datei existiert und die effektive Gruppen-ID des aufrufenden Prozesses der Eigentümer der Datei ist. Gibt unter Windows false zurück.

file_name kann ein IO-Objekt sein.

identical?(file_1, file_2) → true oder false

Source

static VALUE
rb_file_identical_p(VALUE obj, VALUE fname1, VALUE fname2)
{
#ifndef _WIN32
    struct stat st1, st2;

    if (rb_stat(fname1, &st1) < 0) return Qfalse;
    if (rb_stat(fname2, &st2) < 0) return Qfalse;
    if (st1.st_dev != st2.st_dev) return Qfalse;
    if (st1.st_ino != st2.st_ino) return Qfalse;
    return Qtrue;
#else
    extern VALUE rb_w32_file_identical_p(VALUE, VALUE);
    return rb_w32_file_identical_p(fname1, fname2);
#endif
}

Gibt true zurück, wenn die benannten Dateien identisch sind.

file_1 und file_2 können ein IO-Objekt sein.

open("a", "w") {}
p File.identical?("a", "a")      #=> true
p File.identical?("a", "./a")    #=> true
File.link("a", "b")
p File.identical?("a", "b")      #=> true
File.symlink("a", "c")
p File.identical?("a", "c")      #=> true
open("d", "w") {}
p File.identical?("a", "d")      #=> false

join(string, ...) → string

Source

static VALUE
rb_file_s_join(VALUE klass, VALUE args)
{
    return rb_file_join(args);
}

Gibt eine neue Zeichenkette zurück, die durch Zusammenfügen der Zeichenketten mit "/" gebildet wird.

File.join("usr", "mail", "gumby")   #=> "usr/mail/gumby"

lchmod(mode_int, file_name, ...) → integer

Source

static VALUE
rb_file_s_lchmod(int argc, VALUE *argv, VALUE _)
{
    mode_t mode;

    apply2args(1);
    mode = NUM2MODET(*argv++);

    return apply2files(lchmod_internal, argc, argv, &mode);
}

Entspricht File::chmod, folgt aber nicht symbolischen Links (daher werden die Berechtigungen des Links geändert, nicht die der vom Link referenzierten Datei). Oft nicht verfügbar.

lchown(owner_int, group_int, file_name,..) → integer

Source

static VALUE
rb_file_s_lchown(int argc, VALUE *argv, VALUE _)
{
    struct chown_args arg;

    apply2args(2);
    arg.owner = to_uid(*argv++);
    arg.group = to_gid(*argv++);

    return apply2files(lchown_internal, argc, argv, &arg);
}

Entspricht File::chown, folgt aber nicht symbolischen Links (daher wird der Eigentümer des Links geändert, nicht die der vom Link referenzierten Datei). Oft nicht verfügbar. Gibt die Anzahl der Dateien in der Argumentliste zurück.

link(old_name, new_name) → 0

Source

static VALUE
rb_file_s_link(VALUE klass, VALUE from, VALUE to)
{
    FilePathValue(from);
    FilePathValue(to);
    from = rb_str_encode_ospath(from);
    to = rb_str_encode_ospath(to);

    if (link(StringValueCStr(from), StringValueCStr(to)) < 0) {
        sys_fail2(from, to);
    }
    return INT2FIX(0);
}

Erstellt einen neuen Namen für eine existierende Datei mithilfe eines Hardlinks. Überschreibt new_name nicht, wenn es bereits existiert (löst eine Unterklasse von SystemCallError aus). Nicht auf allen Plattformen verfügbar.

File.link("testfile", ".testfile")   #=> 0
IO.readlines(".testfile")[0]         #=> "This is line one\n"

lstat(filepath) → stat

Source

static VALUE
rb_file_s_lstat(VALUE klass, VALUE fname)
{
#ifdef HAVE_LSTAT
    rb_io_stat_data st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstatx_without_gvl(StringValueCStr(fname), &st, STATX_ALL) == -1) {
        rb_sys_fail_path(fname);
    }
    return rb_statx_new(&st);
#else
    return rb_file_s_stat(klass, fname);
#endif
}

Wie File::stat, aber folgt nicht dem letzten symbolischen Link; stattdessen wird ein File::Stat-Objekt für den Link selbst zurückgegeben.

File.symlink('t.txt', 'symlink')
File.stat('symlink').size  # => 47
File.lstat('symlink').size # => 5

lutime(atime, mtime, file_name, ...) → integer

Source

static VALUE
rb_file_s_lutime(int argc, VALUE *argv, VALUE _)
{
    return utime_internal_i(argc, argv, TRUE);
}

Setzt die Zugriffs- und Änderungszeiten jeder benannten Datei auf die ersten beiden Argumente. Wenn eine Datei ein Symlink ist, wirkt diese Methode auf den Link selbst, im Gegensatz zu seinem Referenten; für das umgekehrte Verhalten siehe File.utime. Gibt die Anzahl der Dateinamen in der Argumentliste zurück.

mkfifo(file_name, mode=0666) → 0

Source

static VALUE
rb_file_s_mkfifo(int argc, VALUE *argv, VALUE _)
{
    VALUE path;
    struct mkfifo_arg ma;

    ma.mode = 0666;
    rb_check_arity(argc, 1, 2);
    if (argc > 1) {
        ma.mode = NUM2MODET(argv[1]);
    }
    path = argv[0];
    FilePathValue(path);
    path = rb_str_encode_ospath(path);
    ma.path = RSTRING_PTR(path);
    if (IO_WITHOUT_GVL(nogvl_mkfifo, &ma)) {
        rb_sys_fail_path(path);
    }
    return INT2FIX(0);
}

Erstellt eine FIFO-Spezialdatei mit dem Namen file_name. mode gibt die Berechtigungen des FIFO an. Er wird auf übliche Weise durch die Umask des Prozesses modifiziert: die Berechtigungen der erstellten Datei sind (mode & ~umask).

mtime(file_name) → time

Source

static VALUE
rb_file_s_mtime(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return stat_time(stat_mtimespec(&st));
}

Gibt die Änderungszeit für die benannte Datei als Time-Objekt zurück.

file_name kann ein IO-Objekt sein.

File.mtime("testfile")   #=> Tue Apr 08 12:58:04 CDT 2003

new(path, mode = 'r', perm = 0666, **opts) → file

Source

static VALUE
rb_file_initialize(int argc, VALUE *argv, VALUE io)
{
    if (RFILE(io)->fptr) {
        rb_raise(rb_eRuntimeError, "reinitializing File");
    }
    VALUE fname, vmode, vperm, opt;
    int posargc = rb_scan_args(argc, argv, "12:", &fname, &vmode, &vperm, &opt);
    if (posargc < 3) {          /* perm is File only */
        VALUE fd = rb_check_to_int(fname);

        if (!NIL_P(fd)) {
            return io_initialize(io, fd, vmode, opt);
        }
    }
    return rb_open_file(io, fname, vmode, vperm, opt);
}

Öffnet die Datei unter dem gegebenen path gemäß dem gegebenen mode; erstellt und gibt ein neues File-Objekt für diese Datei zurück.

Das neue File-Objekt ist im gepufferten Modus (oder nicht-synchronen Modus), es sei denn, filename ist ein TTY. Siehe IO#flush, IO#fsync, IO#fdatasync und IO#sync=.

Das Argument path muss ein gültiger Dateipfad sein.

f = File.new('/etc/fstab')
f.close
f = File.new('t.txt')
f.close

Das optionale Argument mode (Standardwert ist 'r') muss einen gültigen Modus angeben; siehe Access Modes.

f = File.new('t.tmp', 'w')
f.close
f = File.new('t.tmp', File::RDONLY)
f.close

Das optionale Argument perm (Standardwert ist 0666) muss gültige Berechtigungen angeben; siehe File Permissions.

f = File.new('t.tmp', File::CREAT, 0644)
f.close
f = File.new('t.tmp', File::CREAT, 0444)
f.close

Optionale Schlüsselwortargumente opts spezifizieren

open(path, mode = 'r', perm = 0666, **opts) → file

open(path, mode = 'r', perm = 0666, **opts) {|f| ... } → object

Source

static VALUE
rb_io_s_open(int argc, VALUE *argv, VALUE klass)
{
    VALUE io = rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);

    if (rb_block_given_p()) {
        return rb_ensure(rb_yield, io, io_close, io);
    }

    return io;
}

Erstellt ein neues File-Objekt über File.new mit den gegebenen Argumenten.

Ohne Block gibt es das File-Objekt zurück.

Mit einem Block gibt es den Block mit dem File-Objekt auf und gibt den Wert des Blocks zurück.

owned?(file_name) → true oder false

Source

static VALUE
rb_file_owned_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(st.st_uid == geteuid());
}

Gibt true zurück, wenn die benannte Datei existiert und die effektive Benutzer-ID des aufrufenden Prozesses der Eigentümer der Datei ist.

file_name kann ein IO-Objekt sein.

path(path) → string

Source

static VALUE
rb_file_s_path(VALUE klass, VALUE fname)
{
    return rb_get_path(fname);
}

Returns the string representation of the path

   File.path(File::NULL)           #=> "/dev/null"
   File.path(Pathname.new("/tmp")) #=> "/tmp"

Wenn path keine Zeichenkette ist.

Wenn es die Methode to_path hat, wird diese Methode aufgerufen, um es in eine String zu konvertieren.
Andernfalls, oder wenn das konvertierte Ergebnis keine String ist, erfolgt die Standardkonvertierung mithilfe der to_str-Methode auf diesem Objekt. (Siehe auch String.try_convert)

Die konvertierte Zeichenkette muss die folgenden Bedingungen erfüllen.

Es muss sich um eine ASCII-kompatible Kodierung handeln, andernfalls wird eine Encoding::CompatibilityError ausgelöst.
Es darf kein NUL-Zeichen (\0) enthalten sein, andernfalls wird ein ArgumentError ausgelöst.

pipe?(filepath) → true oder false

Source

static VALUE
rb_file_pipe_p(VALUE obj, VALUE fname)
{
#ifdef S_IFIFO
#  ifndef S_ISFIFO
#    define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
#  endif

    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISFIFO(st.st_mode)) return Qtrue;

#endif
    return Qfalse;
}

Gibt true zurück, wenn filepath auf eine Pipe verweist, andernfalls false.

File.mkfifo('tmp/fifo')
File.pipe?('tmp/fifo') # => true
File.pipe?('t.txt')    # => false

readable?(file_name) → true oder false

Source

static VALUE
rb_file_readable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, R_OK) >= 0);
}

Gibt true zurück, wenn die benannte Datei für die effektive Benutzer- und Gruppen-ID dieses Prozesses lesbar ist. Siehe eaccess(3).

Beachten Sie, dass einige betriebssystemweite Sicherheitsfunktionen dazu führen können, dass dies true zurückgibt, obwohl die Datei für den effektiven Benutzer/die Gruppe nicht lesbar ist.

readable_real?(file_name) → true oder false

Source

static VALUE
rb_file_readable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, R_OK) >= 0);
}

Gibt true zurück, wenn die benannte Datei für die reale Benutzer- und Gruppen-ID dieses Prozesses lesbar ist. Siehe access(3).

Beachten Sie, dass einige betriebssystemweite Sicherheitsfunktionen dazu führen können, dass dies true zurückgibt, obwohl die Datei für den realen Benutzer/die Gruppe nicht lesbar ist.

readlink(link_name) → file_name

Source

static VALUE
rb_file_s_readlink(VALUE klass, VALUE path)
{
    return rb_readlink(path, rb_filesystem_encoding());
}

Gibt den Namen der Datei zurück, auf die sich der angegebene Link bezieht. Nicht auf allen Plattformen verfügbar.

File.symlink("testfile", "link2test")   #=> 0
File.readlink("link2test")              #=> "testfile"

realdirpath(pathname [, dir_string]) → real_pathname

Source

static VALUE
rb_file_s_realdirpath(int argc, VALUE *argv, VALUE klass)
{
    VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
    VALUE path = argv[0];
    FilePathValue(path);
    return rb_realpath_internal(basedir, path, 0);
}

Gibt den realen (absoluten) Pfadnamen von pathname im tatsächlichen Dateisystem zurück. Der reale Pfadname enthält keine symbolischen Links oder unnötigen Punkte.

Wenn dir_string angegeben ist, wird er als Basisverzeichnis für die Interpretation relativer Pfadnamen anstelle des aktuellen Verzeichnisses verwendet.

Die letzte Komponente des realen Pfadnamens kann nicht existieren.

realpath(pathname [, dir_string]) → real_pathname

Source

static VALUE
rb_file_s_realpath(int argc, VALUE *argv, VALUE klass)
{
    VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
    VALUE path = argv[0];
    FilePathValue(path);
    return rb_realpath_internal(basedir, path, 1);
}

Gibt den realen (absoluten) Pfadnamen von pathname im tatsächlichen Dateisystem zurück, der keine symbolischen Links oder unnötigen Punkte enthält.

Wenn dir_string angegeben ist, wird er als Basisverzeichnis für die Interpretation relativer Pfadnamen anstelle des aktuellen Verzeichnisses verwendet.

Alle Komponenten des Pfadnamens müssen existieren, wenn diese Methode aufgerufen wird.

rename(old_name, new_name) → 0

Source

static VALUE
rb_file_s_rename(VALUE klass, VALUE from, VALUE to)
{
    struct rename_args ra;
    VALUE f, t;

    FilePathValue(from);
    FilePathValue(to);
    f = rb_str_encode_ospath(from);
    t = rb_str_encode_ospath(to);
    ra.src = StringValueCStr(f);
    ra.dst = StringValueCStr(t);
#if defined __CYGWIN__
    errno = 0;
#endif
    if (IO_WITHOUT_GVL_INT(no_gvl_rename, &ra) < 0) {
        int e = errno;
#if defined DOSISH
        switch (e) {
          case EEXIST:
            if (chmod(ra.dst, 0666) == 0 &&
                unlink(ra.dst) == 0 &&
                rename(ra.src, ra.dst) == 0)
                return INT2FIX(0);
        }
#endif
        syserr_fail2(e, from, to);
    }

    return INT2FIX(0);
}

Benennt die angegebene Datei in den neuen Namen um. Löst eine SystemCallError aus, wenn die Datei nicht umbenannt werden kann.

File.rename("afile", "afile.bak")   #=> 0

setgid?(file_name) → true oder false

Source

static VALUE
rb_file_sgid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISGID
    return check3rdbyte(fname, S_ISGID);
#else
    return Qfalse;
#endif
}

Gibt true zurück, wenn das Setgid-Bit der benannten Datei gesetzt ist.

file_name kann ein IO-Objekt sein.

setuid?(file_name) → true oder false

Source

static VALUE
rb_file_suid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISUID
    return check3rdbyte(fname, S_ISUID);
#else
    return Qfalse;
#endif
}

Gibt true zurück, wenn das Setuid-Bit der benannten Datei gesetzt ist.

file_name kann ein IO-Objekt sein.

size(file_name) → integer

Source

static VALUE
rb_file_s_size(VALUE klass, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }
    return OFFT2NUM(st.st_size);
}

Gibt die Größe von file_name zurück.

file_name kann ein IO-Objekt sein.

size?(file_name) → Integer oder nil

Source

static VALUE
rb_file_size_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qnil;
    if (st.st_size == 0) return Qnil;
    return OFFT2NUM(st.st_size);
}

Gibt nil zurück, wenn file_name nicht existiert oder eine Größe von Null hat, andernfalls die Größe der Datei.

file_name kann ein IO-Objekt sein.

socket?(filepath) → true oder false

Source

static VALUE
rb_file_socket_p(VALUE obj, VALUE fname)
{
#ifndef S_ISSOCK
#  ifdef _S_ISSOCK
#    define S_ISSOCK(m) _S_ISSOCK(m)
#  else
#    ifdef _S_IFSOCK
#      define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
#    else
#      ifdef S_IFSOCK
#        define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
#      endif
#    endif
#  endif
#endif

#ifdef S_ISSOCK
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    if (S_ISSOCK(st.st_mode)) return Qtrue;
#endif

    return Qfalse;
}

Gibt true zurück, wenn filepath auf einen Socket verweist, andernfalls false.

require 'socket'
File.socket?(Socket.new(:INET, :STREAM)) # => true
File.socket?(File.new('t.txt'))          # => false

split(file_name) → array

Source

static VALUE
rb_file_s_split(VALUE klass, VALUE path)
{
    FilePathStringValue(path);          /* get rid of converting twice */
    return rb_assoc_new(rb_file_dirname(path), rb_file_s_basename(1,&path,Qundef));
}

Teilt die gegebene Zeichenkette in eine Verzeichnis- und eine Dateikomponente auf und gibt diese in einem Array mit zwei Elementen zurück. Siehe auch File::dirname und File::basename.

File.split("/home/gumby/.profile")   #=> ["/home/gumby", ".profile"]

stat(filepath) → stat

Source

static VALUE
rb_file_s_stat(VALUE klass, VALUE fname)
{
    rb_io_stat_data st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (statx_without_gvl(RSTRING_PTR(fname), &st, STATX_ALL) < 0) {
        rb_sys_fail_path(fname);
    }
    return rb_statx_new(&st);
}

Gibt ein File::Stat-Objekt für die Datei unter filepath zurück (siehe File::Stat).

File.stat('t.txt').class # => File::Stat

sticky?(file_name) → true oder false

Source

static VALUE
rb_file_sticky_p(VALUE obj, VALUE fname)
{
#ifdef S_ISVTX
    return check3rdbyte(fname, S_ISVTX);
#else
    return Qfalse;
#endif
}

Gibt true zurück, wenn das Sticky-Bit der benannten Datei gesetzt ist.

file_name kann ein IO-Objekt sein.

symlink(old_name, new_name) → 0

Source

static VALUE
rb_file_s_symlink(VALUE klass, VALUE from, VALUE to)
{
    FilePathValue(from);
    FilePathValue(to);
    from = rb_str_encode_ospath(from);
    to = rb_str_encode_ospath(to);

    if (symlink(StringValueCStr(from), StringValueCStr(to)) < 0) {
        sys_fail2(from, to);
    }
    return INT2FIX(0);
}

Erstellt einen symbolischen Link namens new_name für die vorhandene Datei old_name. Löst eine NotImplemented-Ausnahme auf Plattformen aus, die keine symbolischen Links unterstützen.

File.symlink("testfile", "link2test")   #=> 0

symlink?(filepath) → true oder false

Source

static VALUE
rb_file_symlink_p(VALUE obj, VALUE fname)
{
#ifndef S_ISLNK
#  ifdef _S_ISLNK
#    define S_ISLNK(m) _S_ISLNK(m)
#  else
#    ifdef _S_IFLNK
#      define S_ISLNK(m) (((m) & S_IFMT) == _S_IFLNK)
#    else
#      ifdef S_IFLNK
#        define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
#      endif
#    endif
#  endif
#endif

#ifdef S_ISLNK
    struct stat st;

    FilePathValue(fname);
    fname = rb_str_encode_ospath(fname);
    if (lstat_without_gvl(StringValueCStr(fname), &st) < 0) return Qfalse;
    if (S_ISLNK(st.st_mode)) return Qtrue;
#endif

    return Qfalse;
}

Gibt true zurück, wenn filepath auf einen symbolischen Link verweist, andernfalls false.

symlink = File.symlink('t.txt', 'symlink')
File.symlink?('symlink') # => true
File.symlink?('t.txt')   # => false

truncate(file_name, integer) → 0

Source

static VALUE
rb_file_s_truncate(VALUE klass, VALUE path, VALUE len)
{
    struct truncate_arg ta;
    int r;

    ta.pos = NUM2OFFT(len);
    FilePathValue(path);
    path = rb_str_encode_ospath(path);
    ta.path = StringValueCStr(path);

    r = IO_WITHOUT_GVL_INT(nogvl_truncate, &ta);
    if (r < 0)
        rb_sys_fail_path(path);
    return INT2FIX(0);
}

Schneidet die Datei file_name auf maximal integer Bytes ab. Nicht auf allen Plattformen verfügbar.

f = File.new("out", "w")
f.write("1234567890")     #=> 10
f.close                   #=> nil
File.truncate("out", 5)   #=> 0
File.size("out")          #=> 5

umask() → integer

umask(integer) → integer

Source

static VALUE
rb_file_s_umask(int argc, VALUE *argv, VALUE _)
{
    mode_t omask = 0;

    switch (argc) {
      case 0:
        omask = umask(0);
        umask(omask);
        break;
      case 1:
        omask = umask(NUM2MODET(argv[0]));
        break;
      default:
        rb_error_arity(argc, 0, 1);
    }
    return MODET2NUM(omask);
}

Gibt den aktuellen umask-Wert für diesen Prozess zurück. Wenn das optionale Argument angegeben ist, wird die umask auf diesen Wert gesetzt und der vorherige Wert zurückgegeben. Umask-Werte werden von den Standardberechtigungen *abgezogen*, sodass eine umask von 0222 eine Datei für jeden schreibgeschützt machen würde.

File.umask(0006)   #=> 18
File.umask         #=> 6

delete(file_name, ...) → integer

unlink(file_name, ...) → integer

Source

static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
    return apply2files(unlink_internal, argc, argv, 0);
}

Siehe auch Dir::rmdir.

utime(atime, mtime, file_name, ...) → integer

Source

static VALUE
rb_file_s_utime(int argc, VALUE *argv, VALUE _)
{
    return utime_internal_i(argc, argv, FALSE);
}

Setzt die Zugriffs- und Änderungszeiten jeder benannten Datei auf die ersten beiden Argumente. Wenn eine Datei ein Symlink ist, wirkt diese Methode auf das Ziel statt auf den Link selbst; für das umgekehrte Verhalten siehe File.lutime. Gibt die Anzahl der Dateinamen in der Argumentliste zurück.

world_readable?(file_name) → integer oder nil

Source

static VALUE
rb_file_world_readable_p(VALUE obj, VALUE fname)
{
#ifdef S_IROTH
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qnil;
    if ((st.st_mode & (S_IROTH)) == S_IROTH) {
        return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
#endif
    return Qnil;
}

Wenn file_name für andere lesbar ist, wird eine Ganzzahl zurückgegeben, die die Dateiberechtigungsbits von file_name darstellt. Andernfalls wird nil zurückgegeben. Die Bedeutung der Bits ist plattformabhängig; auf Unix-Systemen siehe stat(2).

file_name kann ein IO-Objekt sein.

File.world_readable?("/etc/passwd")           #=> 420
m = File.world_readable?("/etc/passwd")
sprintf("%o", m)                              #=> "644"

world_writable?(file_name) → integer oder nil

Source

static VALUE
rb_file_world_writable_p(VALUE obj, VALUE fname)
{
#ifdef S_IWOTH
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qnil;
    if ((st.st_mode & (S_IWOTH)) == S_IWOTH) {
        return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
    }
#endif
    return Qnil;
}

Wenn file_name für andere schreibbar ist, wird eine Ganzzahl zurückgegeben, die die Dateiberechtigungsbits von file_name darstellt. Andernfalls wird nil zurückgegeben. Die Bedeutung der Bits ist plattformabhängig; auf Unix-Systemen siehe stat(2).

file_name kann ein IO-Objekt sein.

File.world_writable?("/tmp")                  #=> 511
m = File.world_writable?("/tmp")
sprintf("%o", m)                              #=> "777"

writable?(file_name) → true oder false

Source

static VALUE
rb_file_writable_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_eaccess(fname, W_OK) >= 0);
}

Gibt true zurück, wenn die benannte Datei für die effektive Benutzer- und Gruppen-ID dieses Prozesses schreibbar ist. Siehe eaccess(3).

Beachten Sie, dass einige betriebssystemweite Sicherheitsfunktionen dazu führen können, dass dies true zurückgibt, obwohl die Datei für den effektiven Benutzer/die Gruppe nicht schreibbar ist.

writable_real?(file_name) → true oder false

Source

static VALUE
rb_file_writable_real_p(VALUE obj, VALUE fname)
{
    return RBOOL(rb_access(fname, W_OK) >= 0);
}

Gibt true zurück, wenn die benannte Datei für die reale Benutzer- und Gruppen-ID dieses Prozesses schreibbar ist. Siehe access(3).

Beachten Sie, dass einige betriebssystemweite Sicherheitsfunktionen dazu führen können, dass dies true zurückgibt, obwohl die Datei für den realen Benutzer/die Gruppe nicht schreibbar ist.

zero?(file_name) → true oder false

Source

static VALUE
rb_file_zero_p(VALUE obj, VALUE fname)
{
    struct stat st;

    if (rb_stat(fname, &st) < 0) return Qfalse;
    return RBOOL(st.st_size == 0);
}

Gibt true zurück, wenn die benannte Datei existiert und eine Größe von Null hat.

file_name kann ein IO-Objekt sein.

Öffentliche Instanzmethoden

atime → time

Source

static VALUE
rb_file_atime(VALUE obj)
{
    rb_io_t *fptr;
    struct stat st;

    GetOpenFile(obj, fptr);
    if (fstat(fptr->fd, &st) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return stat_time(stat_atimespec(&st));
}

Gibt die letzte Zugriffszeit (ein Time-Objekt) für file zurück, oder die Epoche, wenn file noch nicht zugegriffen wurde.

File.new("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969

birthtime → time

Source

static VALUE
rb_file_birthtime(VALUE obj)
{
    rb_io_t *fptr;
    rb_io_stat_data st;

    GetOpenFile(obj, fptr);
    if (fstatx_without_gvl(fptr, &st, STATX_BTIME) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return statx_birthtime(&st);
}

Gibt die Erzeugungszeit für file zurück.

File.new("testfile").birthtime   #=> Wed Apr 09 08:53:14 CDT 2003

Wenn die Plattform keine Erzeugungszeit hat, wird NotImplementedError ausgelöst.

chmod(mode_int) → 0

Source

static VALUE
rb_file_chmod(VALUE obj, VALUE vmode)
{
    rb_io_t *fptr;
    mode_t mode;
#if !defined HAVE_FCHMOD || !HAVE_FCHMOD
    VALUE path;
#endif

    mode = NUM2MODET(vmode);

    GetOpenFile(obj, fptr);
#ifdef HAVE_FCHMOD
    if (rb_fchmod(fptr, mode) == -1) {
        if (HAVE_FCHMOD || errno != ENOSYS)
            rb_sys_fail_path(fptr->pathv);
    }
    else {
        if (!HAVE_FCHMOD) return INT2FIX(0);
    }
#endif
#if !defined HAVE_FCHMOD || !HAVE_FCHMOD
    if (NIL_P(fptr->pathv)) return Qnil;
    path = rb_str_encode_ospath(fptr->pathv);
    if (rb_chmod(RSTRING_PTR(path), mode) == -1)
        rb_sys_fail_path(fptr->pathv);
#endif

    return INT2FIX(0);
}

Ändert die Berechtigungsbits von file auf das durch mode_int dargestellte Bitmuster. Die tatsächlichen Auswirkungen sind plattformabhängig; auf Unix-Systemen siehe chmod(2) für Details. Folgt symbolischen Links. Siehe auch File#lchmod.

f = File.new("out", "w");
f.chmod(0644)   #=> 0

chown(owner_int, group_int ) → 0

Source

static VALUE
rb_file_chown(VALUE obj, VALUE owner, VALUE group)
{
    rb_io_t *fptr;
    rb_uid_t o;
    rb_gid_t g;
#ifndef HAVE_FCHOWN
    VALUE path;
#endif

    o = to_uid(owner);
    g = to_gid(group);
    GetOpenFile(obj, fptr);
#ifndef HAVE_FCHOWN
    if (NIL_P(fptr->pathv)) return Qnil;
    path = rb_str_encode_ospath(fptr->pathv);
    if (rb_chown(RSTRING_PTR(path), o, g) == -1)
        rb_sys_fail_path(fptr->pathv);
#else
    if (rb_fchown(fptr->fd, o, g) == -1)
        rb_sys_fail_path(fptr->pathv);
#endif

    return INT2FIX(0);
}

Ändert den Besitzer und die Gruppe von file auf die angegebenen numerischen Besitzer- und Gruppen-IDs. Nur ein Prozess mit Superuser-Privilegien darf den Besitzer einer Datei ändern. Der aktuelle Besitzer einer Datei kann die Gruppe der Datei in jede Gruppe ändern, der der Besitzer angehört. Eine nil oder -1 Besitzer- oder Gruppen-ID wird ignoriert. Folgt symbolischen Links. Siehe auch File#lchown.

File.new("testfile").chown(502, 1000)

ctime → time

Source

static VALUE
rb_file_ctime(VALUE obj)
{
    rb_io_t *fptr;
    struct stat st;

    GetOpenFile(obj, fptr);
    if (fstat(fptr->fd, &st) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return stat_time(stat_ctimespec(&st));
}

Gibt die Änderungszeit für file zurück (d. h. die Zeit, zu der die Verzeichnisinformationen über die Datei geändert wurden, nicht die Datei selbst).

Beachten Sie, dass unter Windows (NTFS) die Erzeugungszeit (birth time) zurückgegeben wird.

File.new("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003

flock(locking_constant) → 0 oder false

Source

static VALUE
rb_file_flock(VALUE obj, VALUE operation)
{
    rb_io_t *fptr;
    int op[2], op1;
    struct timeval time;

    op[1] = op1 = NUM2INT(operation);
    GetOpenFile(obj, fptr);
    op[0] = fptr->fd;

    if (fptr->mode & FMODE_WRITABLE) {
        rb_io_flush_raw(obj, 0);
    }
    while ((int)rb_io_blocking_region(fptr, rb_thread_flock, op) < 0) {
        int e = errno;
        switch (e) {
          case EAGAIN:
          case EACCES:
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
          case EWOULDBLOCK:
#endif
            if (op1 & LOCK_NB) return Qfalse;

            time.tv_sec = 0;
            time.tv_usec = 100 * 1000;  /* 0.1 sec */
            rb_thread_wait_for(time);
            rb_io_check_closed(fptr);
            continue;

          case EINTR:
#if defined(ERESTART)
          case ERESTART:
#endif
            break;

          default:
            rb_syserr_fail_path(e, fptr->pathv);
        }
    }
    return INT2FIX(0);
}

Sperrt oder entsperrt die Datei self gemäß der angegebenen locking_constant, einem bitweisen OR der Werte aus der unten stehenden Tabelle.

Nicht auf allen Plattformen verfügbar.

Gibt false zurück, wenn File::LOCK_NB angegeben ist und die Operation blockiert hätte; andernfalls wird 0 zurückgegeben.

Konstante	Lock	Effekt
`File::LOCK_EX`	Exklusiv	Nur ein Prozess darf gleichzeitig eine exklusive Sperre für `self` halten.
`File::LOCK_NB`	Nicht-blockierend	Kein Blockieren; kann mit `File::LOCK_SH` oder `File::LOCK_EX` unter Verwendung des bitweisen OR-Operators `\|` kombiniert werden.
`File::LOCK_SH`	Gemeinsam genutzt	Mehrere Prozesse dürfen gleichzeitig eine gemeinsame Sperre für `self` halten.
`File::LOCK_UN`	Unlock	Entfernt eine bestehende Sperre, die von diesem Prozess gehalten wird.

Beispiel

# Update a counter using an exclusive lock.
# Don't use File::WRONLY because it truncates the file.
File.open('counter', File::RDWR | File::CREAT, 0644) do |f|
  f.flock(File::LOCK_EX)
  value = f.read.to_i + 1
  f.rewind
  f.write("#{value}\n")
  f.flush
  f.truncate(f.pos)
end

# Read the counter using a shared lock.
File.open('counter', 'r') do |f|
  f.flock(File::LOCK_SH)
  f.read
end

lstat → stat

Source

static VALUE
rb_file_lstat(VALUE obj)
{
#ifdef HAVE_LSTAT
    rb_io_t *fptr;
    rb_io_stat_data st;
    VALUE path;

    GetOpenFile(obj, fptr);
    if (NIL_P(fptr->pathv)) return Qnil;
    path = rb_str_encode_ospath(fptr->pathv);
    if (lstatx_without_gvl(RSTRING_PTR(path), &st, STATX_ALL) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return rb_statx_new(&st);
#else
    return rb_io_stat(obj);
#endif
}

Ähnlich wie File#stat, aber folgt nicht dem letzten symbolischen Link; stattdessen wird ein File::Stat-Objekt für den Link selbst zurückgegeben.

File.symlink('t.txt', 'symlink')
f = File.new('symlink')
f.stat.size  # => 47
f.lstat.size # => 11

mtime → time

Source

static VALUE
rb_file_mtime(VALUE obj)
{
    rb_io_t *fptr;
    struct stat st;

    GetOpenFile(obj, fptr);
    if (fstat(fptr->fd, &st) == -1) {
        rb_sys_fail_path(fptr->pathv);
    }
    return stat_time(stat_mtimespec(&st));
}

Gibt die Änderungszeit für file zurück.

File.new("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003

size → integer

Source

static VALUE
file_size(VALUE self)
{
    return OFFT2NUM(rb_file_size(self));
}

Gibt die Größe von file in Bytes zurück.

File.new("testfile").size   #=> 66

truncate(integer) → 0

Source

static VALUE
rb_file_truncate(VALUE obj, VALUE len)
{
    rb_io_t *fptr;
    struct ftruncate_arg fa;

    fa.pos = NUM2OFFT(len);
    GetOpenFile(obj, fptr);
    if (!(fptr->mode & FMODE_WRITABLE)) {
        rb_raise(rb_eIOError, "not opened for writing");
    }
    rb_io_flush_raw(obj, 0);
    fa.fd = fptr->fd;
    if ((int)rb_io_blocking_region(fptr, nogvl_ftruncate, &fa) < 0) {
        rb_sys_fail_path(fptr->pathv);
    }
    return INT2FIX(0);
}

Schneidet file auf maximal integer Bytes ab. Die Datei muss zum Schreiben geöffnet sein. Nicht auf allen Plattformen verfügbar.

f = File.new("out", "w")
f.syswrite("1234567890")   #=> 10
f.truncate(5)              #=> 0
f.close()                  #=> nil
File.size("out")           #=> 5