class Dir

Ein Objekt der Klasse Dir repräsentiert ein Verzeichnis im zugrunde liegenden Dateisystem.

Es besteht hauptsächlich aus

Ein String path, der bei der Erstellung des Objekts angegeben wird und ein Verzeichnis im zugrunde liegenden Dateisystem bezeichnet; die Methode path gibt den Pfad zurück.
Eine Sammlung von String-Eintragsnamen, von denen jeder der Name eines Verzeichnisses oder einer Datei im zugrunde liegenden Dateisystem ist; die Eintragsnamen können in array-ähnlicher Weise oder in stream-ähnlicher Weise abgerufen werden.

Über die Beispiele

Einige Beispiele auf dieser Seite verwenden diesen einfachen Dateibaum

example/
├── config.h
├── lib/
│   ├── song/
│   │   └── karaoke.rb
│   └── song.rb
└── main.rb

Andere verwenden den Dateibaum für das Ruby-Projekt selbst.

Dir als Array-ähnlich

Ein Dir-Objekt ist in gewisser Weise array-ähnlich

Es hat Instanzmethoden children, each und each_child.
Es enthält das Modul Enumerable.

Dir als Stream-ähnlich

Ein Dir-Objekt ist in gewisser Weise stream-ähnlich.

Der Stream ist initial zum Lesen geöffnet, kann aber manuell geschlossen werden (mittels der Methode close) und wird beim Beenden des Blocks geschlossen, wenn er durch Dir.open mit einem Block erstellt wurde. Der geschlossene Stream kann nicht weiter manipuliert und nicht wieder geöffnet werden.

Der Stream hat eine Position, die den Index eines Eintrags im Verzeichnis darstellt

Die Anfangsposition ist null (vor dem ersten Eintrag).
Die Methode tell (alias pos) gibt die Position zurück.
Die Methode pos= setzt die Position (ignoriert aber einen Wert außerhalb des Streams) und gibt die Position zurück.
Die Methode seek ist wie pos=, gibt aber self zurück (praktisch zum Verketten).
Die Methode read liest den nächsten Eintrag und inkrementiert die Position, wenn sie sich nicht am Ende des Streams befindet; wenn sie sich am Ende des Streams befindet, wird die Position nicht inkrementiert.
Die Methode rewind setzt die Position auf null.

Beispiele (unter Verwendung des einfachen Dateibaums)

dir = Dir.new('example') # => #<Dir:example>
dir.pos                  # => 0

dir.read # => "."
dir.read # => ".."
dir.read # => "config.h"
dir.read # => "lib"
dir.read # => "main.rb"
dir.pos  # => 5
dir.read # => nil
dir.pos  # => 5

dir.rewind # => #<Dir:example>
dir.pos    # => 0

dir.pos = 3 # => 3
dir.pos     # => 3

dir.seek(4) # => #<Dir:example>
dir.pos     # => 4

dir.close # => nil
dir.read  # Raises IOError.

Was gibt es hier

Zuerst, was anderswo ist. Klasse Dir

Erbt von Klasse Object.
Beinhaltet das Modul Enumerable, das Dutzende zusätzlicher Methoden bereitstellt.

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

Lesen

close: Schließt den Verzeichnisstream für self.
pos=: Setzt die Position im Verzeichnisstream für self.
read: Liest und gibt den nächsten Eintrag im Verzeichnisstream für self zurück.
rewind: Setzt die Position im Verzeichnisstream für self auf den ersten Eintrag.
seek: Setzt die Position im Verzeichnisstream für self auf den Eintrag mit dem angegebenen Offset.

Einstellen

::chdir: Ändert das Arbeitsverzeichnis des aktuellen Prozesses in das angegebene Verzeichnis.
::chroot: Ändert das Dateisystem-Root für den aktuellen Prozess in das angegebene Verzeichnis.

Abfragen

::[]: Identisch mit ::glob, jedoch ohne die Möglichkeit, Flags zu übergeben.
::children: Gibt ein Array von Namen der Kinder (Dateien und Verzeichnisse) des angegebenen Verzeichnisses zurück, ohne . oder ...
::empty?: Gibt zurück, ob der angegebene Pfad ein leeres Verzeichnis ist.
::entries: Gibt ein Array von Namen der Kinder (Dateien und Verzeichnisse) des angegebenen Verzeichnisses zurück, einschließlich . und ...
::exist?: Gibt zurück, ob der angegebene Pfad ein Verzeichnis ist.
::getwd (alias pwd): Gibt den Pfad zum aktuellen Arbeitsverzeichnis zurück.
::glob: Gibt ein Array von Dateipfaden zurück, die dem angegebenen Muster und den Flags entsprechen.
::home: Gibt den Home-Verzeichnispfad für einen bestimmten Benutzer oder den aktuellen Benutzer zurück.
children: Gibt ein Array von Namen der Kinder (Dateien und Verzeichnisse) von self zurück, ohne . oder ...
fileno: Gibt den ganzzahligen Dateideskriptor für self zurück.
path (alias to_path): Gibt den Pfad zurück, der zur Erstellung von self verwendet wurde.
tell (alias pos): Gibt die ganzzahlige Position im Verzeichnisstream für self zurück.

Iterieren

::each_child: Ruft den angegebenen Block mit jedem Eintrag im angegebenen Verzeichnis auf, ohne . oder ...
::foreach: Ruft den angegebenen Block mit jedem Eintrag im angegebenen Verzeichnis auf, einschließlich . und ...
each: Ruft den angegebenen Block mit jedem Eintrag in self auf, einschließlich . und ...
each_child: Ruft den angegebenen Block mit jedem Eintrag in self auf, ohne . oder ...

Sonstiges

::mkdir: Erstellt ein Verzeichnis am angegebenen Pfad mit optionalen Berechtigungen.
::new: Gibt ein neues Dir für den angegebenen Pfad mit optionaler Kodierung zurück.
::open: Identisch mit ::new, aber wenn ein Block gegeben wird, übergibt er das Dir an den Block und schließt es beim Beenden des Blocks.
::unlink (alias ::delete und ::rmdir): Entfernt das angegebene Verzeichnis.
inspect: Gibt eine String-Beschreibung von self zurück.

Öffentliche Klassenmethoden

Dir[*patterns, base: nil, sort: true] → array

Source

# File dir.rb, line 222
def self.[](*args, base: nil, sort: true)
  Primitive.dir_s_aref(args, base, sort)
end

Ruft Dir.glob mit dem Argument patterns und den Werten der Schlüsselwortargumente base und sort auf; gibt das Array der ausgewählten Eintragsnamen zurück.

chdir(new_dirpath) → 0

chdir → 0

chdir(new_dirpath) {|new_dirpath| ... } → object

chdir {|cur_dirpath| ... } → object

Source

static VALUE
dir_s_chdir(int argc, VALUE *argv, VALUE obj)
{
    VALUE path = Qnil;

    if (rb_check_arity(argc, 0, 1) == 1) {
        path = rb_str_encode_ospath(rb_get_path(argv[0]));
    }
    else {
        const char *dist = getenv("HOME");
        if (!dist) {
            dist = getenv("LOGDIR");
            if (!dist) rb_raise(rb_eArgError, "HOME/LOGDIR not set");
        }
        path = rb_str_new2(dist);
    }

    return chdir_path(path, true);
}

Ändert das aktuelle Arbeitsverzeichnis.

Mit dem Argument new_dirpath und ohne Block ändert es zum angegebenen dirpath

Dir.pwd         # => "/example"
Dir.chdir('..') # => 0
Dir.pwd         # => "/"

Ohne Argument und ohne Block

Ändert zum Wert der Umgebungsvariable HOME, falls definiert.
Andernfalls ändert es zum Wert der Umgebungsvariable LOGDIR, falls definiert.
Andernfalls erfolgt keine Änderung.

Mit dem Argument new_dirpath und einem Block ändert es vorübergehend das Arbeitsverzeichnis

Ruft den Block mit dem Argument auf.
Ändert zum angegebenen Verzeichnis.
Führt den Block aus (übergibt den neuen Pfad).
Stellt das vorherige Arbeitsverzeichnis wieder her.
Gibt den Rückgabewert des Blocks zurück.

Beispiel

Dir.chdir('/var/spool/mail')
Dir.pwd   # => "/var/spool/mail"
Dir.chdir('/tmp') do
  Dir.pwd # => "/tmp"
end
Dir.pwd   # => "/var/spool/mail"

Ohne Argument und mit einem Block wird der Block mit dem aktuellen Arbeitsverzeichnis (String) aufgerufen und dessen Rückgabewert zurückgegeben.

Aufrufe von Dir.chdir mit Blöcken können verschachtelt sein

Dir.chdir('/var/spool/mail')
Dir.pwd     # => "/var/spool/mail"
Dir.chdir('/tmp') do
  Dir.pwd   # => "/tmp"
  Dir.chdir('/usr') do
    Dir.pwd # => "/usr"
  end
  Dir.pwd   # => "/tmp"
end
Dir.pwd     # => "/var/spool/mail"

In einem Multithread-Programm wird eine Ausnahme ausgelöst, wenn ein Thread versucht, einen chdir-Block zu öffnen, während ein anderer Thread einen geöffnet hat, oder wenn ein Aufruf von chdir ohne Block innerhalb eines an chdir übergebenen Blocks erfolgt (auch im selben Thread).

Löst eine Ausnahme aus, wenn das Zielverzeichnis nicht existiert.

children(dirpath) → array

children(dirpath, encoding: 'UTF-8') → array

Source

static VALUE
dir_s_children(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    dir = dir_open_dir(argc, argv);
    return rb_ensure(dir_collect_children, dir, dir_close, dir);
}

Gibt ein Array von Eintragsnamen im Verzeichnis unter dirpath zurück, außer '.' und '..'; setzt die angegebene Kodierung auf jeden zurückgegebenen Eintragsnamen

Dir.children('/example') # => ["config.h", "lib", "main.rb"]
Dir.children('/example').first.encoding
# => #<Encoding:UTF-8>
Dir.children('/example', encoding: 'US-ASCII').first.encoding
# => #<Encoding:US-ASCII>

Siehe String Encoding.

Löst eine Ausnahme aus, wenn das Verzeichnis nicht existiert.

chroot(dirpath) → 0

Source

static VALUE
dir_s_chroot(VALUE dir, VALUE path)
{
    path = check_dirname(path);
    if (IO_WITHOUT_GVL_INT(nogvl_chroot, (void *)RSTRING_PTR(path)) == -1)
        rb_sys_fail_path(path);

    return INT2FIX(0);
}

Ändert das Root-Verzeichnis des aufrufenden Prozesses in das in dirpath angegebene Verzeichnis. Das neue Root-Verzeichnis wird für Pfadnamen verwendet, die mit '/' beginnen. Das Root-Verzeichnis wird von allen Kindern des aufrufenden Prozesses geerbt.

Nur ein privilegierter Prozess darf chroot aufrufen.

Siehe Linux chroot.

rmdir(dirpath) → 0

Source

static VALUE
dir_s_rmdir(VALUE obj, VALUE dir)
{
    const char *p;
    int r;

    dir = check_dirname(dir);
    p = RSTRING_PTR(dir);
    r = IO_WITHOUT_GVL_INT(nogvl_rmdir, (void *)p);
    if (r < 0)
        rb_sys_fail_path(dir);

    return INT2FIX(0);
}

Entfernt das Verzeichnis unter dirpath aus dem zugrunde liegenden Dateisystem

Dir.rmdir('foo') # => 0

Löst eine Ausnahme aus, wenn das Verzeichnis nicht leer ist.

each_child(dirpath) {|entry_name| ... } → nil

each_child(dirpath, encoding: 'UTF-8') {|entry_name| ... } → nil

Source

static VALUE
dir_s_each_child(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    RETURN_ENUMERATOR(io, argc, argv);
    dir = dir_open_dir(argc, argv);
    rb_ensure(dir_each_child, dir, dir_close, dir);
    return Qnil;
}

Ähnlich wie Dir.foreach, außer dass die Einträge '.' und '..' nicht enthalten sind.

empty?(dirpath) → true oder false

Source

static VALUE
rb_dir_s_empty_p(VALUE obj, VALUE dirname)
{
    VALUE result, orig;
    const char *path;
    enum {false_on_notdir = 1};

    FilePathValue(dirname);
    orig = rb_str_dup_frozen(dirname);
    dirname = rb_str_encode_ospath(dirname);
    dirname = rb_str_dup_frozen(dirname);
    path = RSTRING_PTR(dirname);

#if defined HAVE_GETATTRLIST && defined ATTR_DIR_ENTRYCOUNT
    {
        u_int32_t attrbuf[SIZEUP32(fsobj_tag_t)];
        struct attrlist al = {ATTR_BIT_MAP_COUNT, 0, ATTR_CMN_OBJTAG,};
        struct getattrlist_args args = GETATTRLIST_ARGS(&al, attrbuf, 0);
        if (gvl_getattrlist(&args, path) != 0)
            rb_sys_fail_path(orig);
        if (*(const fsobj_tag_t *)(attrbuf+1) == VT_HFS) {
            al.commonattr = 0;
            al.dirattr = ATTR_DIR_ENTRYCOUNT;
            if (gvl_getattrlist(&args, path) == 0) {
                if (attrbuf[0] >= 2 * sizeof(u_int32_t))
                    return RBOOL(attrbuf[1] == 0);
                if (false_on_notdir) return Qfalse;
            }
            rb_sys_fail_path(orig);
        }
    }
#endif

    result = (VALUE)IO_WITHOUT_GVL(nogvl_dir_empty_p, (void *)path);
    if (FIXNUM_P(result)) {
        rb_syserr_fail_path((int)FIX2LONG(result), orig);
    }
    return result;
}

Gibt zurück, ob dirpath ein leeres Verzeichnis angibt

dirpath = '/tmp/foo'
Dir.mkdir(dirpath)
Dir.empty?(dirpath)            # => true
Dir.empty?('/example')         # => false
Dir.empty?('/example/main.rb') # => false

Löst eine Ausnahme aus, wenn dirpath kein Verzeichnis oder keine Datei im zugrunde liegenden Dateisystem angibt.

entries(dirname, encoding: 'UTF-8') → array

Source

static VALUE
dir_entries(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    dir = dir_open_dir(argc, argv);
    return rb_ensure(dir_collect, dir, dir_close, dir);
}

Gibt ein Array von Eintragsnamen im Verzeichnis unter dirpath zurück; setzt die angegebene Kodierung auf jeden zurückgegebenen Eintragsnamen

Dir.entries('/example') # => ["config.h", "lib", "main.rb", "..", "."]
Dir.entries('/example').first.encoding
# => #<Encoding:UTF-8>
Dir.entries('/example', encoding: 'US-ASCII').first.encoding
# => #<Encoding:US-ASCII>

Siehe String Encoding.

Löst eine Ausnahme aus, wenn das Verzeichnis nicht existiert.

exist?(dirpath) → true oder false

Source

VALUE
rb_file_directory_p(void)
{
}

Gibt zurück, ob dirpath ein Verzeichnis im zugrunde liegenden Dateisystem ist

Dir.exist?('/example')         # => true
Dir.exist?('/nosuch')          # => false
Dir.exist?('/example/main.rb') # => false

Identisch mit File.directory?.

fchdir(fd) → 0

fchdir(fd) { ... } → object

Source

static VALUE
dir_s_fchdir(VALUE klass, VALUE fd_value)
{
    int fd = RB_NUM2INT(fd_value);

    if (chdir_alone_block_p()) {
        struct fchdir_data args;
        args.old_dir = dir_s_alloc(klass);
        dir_initialize(NULL, args.old_dir, rb_fstring_cstr("."), Qnil);
        args.fd = fd;
        args.done = FALSE;
        return rb_ensure(fchdir_yield, (VALUE)&args, fchdir_restore, (VALUE)&args);
    }
    else {
        int r = IO_WITHOUT_GVL_INT(nogvl_fchdir, &fd);
        if (r < 0)
            rb_sys_fail("fchdir");
    }

    return INT2FIX(0);
}

Ändert das aktuelle Arbeitsverzeichnis in das Verzeichnis, das durch den ganzzahligen Dateideskriptor fd angegeben wird.

Beim Übergeben eines Dateideskriptors über einen UNIX-Socket oder an einen Kindprozess vermeidet die Verwendung von fchdir anstelle von chdir die Time-of-Check-to-Time-of-Use-Schwachstelle

Ohne Block ändert es zum Verzeichnis, das von fd angegeben wird

Dir.chdir('/var/spool/mail')
Dir.pwd # => "/var/spool/mail"
dir  = Dir.new('/usr')
fd = dir.fileno
Dir.fchdir(fd)
Dir.pwd # => "/usr"

Mit einem Block ändert es vorübergehend das Arbeitsverzeichnis

Ruft den Block mit dem Argument auf.
Ändert zum angegebenen Verzeichnis.
Führt den Block aus (übergibt keine Argumente).
Stellt das vorherige Arbeitsverzeichnis wieder her.
Gibt den Rückgabewert des Blocks zurück.

Beispiel

Dir.chdir('/var/spool/mail')
Dir.pwd # => "/var/spool/mail"
dir  = Dir.new('/tmp')
fd = dir.fileno
Dir.fchdir(fd) do
  Dir.pwd # => "/tmp"
end
Dir.pwd # => "/var/spool/mail"

Diese Methode verwendet die von POSIX 2008 definierte Funktion fchdir(); die Methode wird auf nicht-POSIX-Plattformen nicht implementiert (löst NotImplementedError aus).

Löst eine Ausnahme aus, wenn der Dateideskriptor ungültig ist.

for_fd(fd) → dir

Source

static VALUE
dir_s_for_fd(VALUE klass, VALUE fd)
{
    struct dir_data *dp;
    VALUE dir = TypedData_Make_Struct(klass, struct dir_data, &dir_data_type, dp);

    if (!(dp->dir = IO_WITHOUT_GVL(nogvl_fdopendir, (void *)(VALUE)NUM2INT(fd)))) {
        rb_sys_fail("fdopendir");
        UNREACHABLE_RETURN(Qnil);
    }

    RB_OBJ_WRITE(dir, &dp->path, Qnil);
    return dir;
}

Gibt ein neues Dir-Objekt zurück, das das durch den gegebenen ganzzahligen Verzeichnisfiledeskriptor fd angegebene Verzeichnis repräsentiert

d0 = Dir.new('..')
d1 = Dir.for_fd(d0.fileno)

Beachten Sie, dass das zurückgegebene d1 keinen zugehörigen Pfad hat

d0.path # => '..'
d1.path # => nil

Diese Methode verwendet die von POSIX 2008 definierte Funktion fdopendir(); die Methode wird auf nicht-POSIX-Plattformen nicht implementiert (löst NotImplementedError aus).

foreach(dirpath, encoding: 'UTF-8') {|entry_name| ... } → nil

Source

static VALUE
dir_foreach(int argc, VALUE *argv, VALUE io)
{
    VALUE dir;

    RETURN_ENUMERATOR(io, argc, argv);
    dir = dir_open_dir(argc, argv);
    rb_ensure(dir_each, dir, dir_close, dir);
    return Qnil;
}

Ruft den Block mit jedem Eintragsnamen im Verzeichnis unter dirpath auf; setzt die angegebene Kodierung auf jeden übergebenen entry_name

Dir.foreach('/example') {|entry_name| p entry_name }

Ausgabe

"config.h"
"lib"
"main.rb"
".."
"."

Encoding

Dir.foreach('/example') {|entry_name| p entry_name.encoding; break }
Dir.foreach('/example', encoding: 'US-ASCII') {|entry_name| p entry_name.encoding; break }

Ausgabe

#<Encoding:UTF-8>
#<Encoding:US-ASCII>

Siehe String Encoding.

Gibt einen Enumerator zurück, wenn kein Block gegeben wird.

pwd → string

Source

static VALUE
dir_s_getwd(VALUE dir)
{
    return rb_dir_getwd();
}

Gibt den Pfad zum aktuellen Arbeitsverzeichnis zurück

Dir.chdir("/tmp") # => 0
Dir.pwd           # => "/tmp"

glob(patterns, flags: 0, base: nil, sort: true) → array

glob(patterns, flags: 0, base: nil, sort: true) {|entry_name| ... } → nil

Source

# File dir.rb, line 410
def self.glob(pattern, _flags = 0, flags: _flags, base: nil, sort: true)
  Primitive.attr! :use_block
  Primitive.dir_s_glob(pattern, flags, base, sort)
end

Bildet ein Array von Eintragsnamen, die durch die Argumente ausgewählt wurden.

Das Argument patterns ist ein String-Muster oder ein Array von String-Mustern; beachten Sie, dass dies keine Regexps sind; siehe unten.

Hinweise für die folgenden Beispiele

'*' ist das Muster, das jeden Eintragsnamen außer denen, die mit '.' beginnen, abgleicht.
Wir verwenden die Methode Array#take, um zurückgegebene Arrays zu kürzen, die sonst sehr groß wären.

Ohne Block wird das Array entry_names zurückgegeben; Beispiel (unter Verwendung des einfachen Dateibaums)

Dir.glob('*') # => ["config.h", "lib", "main.rb"]

Mit einem Block wird der Block mit jedem der Eintragsnamen aufgerufen und nil zurückgegeben

Dir.glob('*') {|entry_name| puts entry_name } # => nil

Ausgabe

config.h
lib
main.rb

Wenn das optionale Schlüsselwortargument flags gegeben ist, modifiziert der Wert den Abgleich; siehe unten.

Wenn das optionale Schlüsselwortargument base gegeben ist, gibt sein Wert das Basisverzeichnis an. Jede Musterzeichenkette gibt Einträge relativ zum Basisverzeichnis an; der Standardwert ist '.'. Das Basisverzeichnis wird den Eintragsnamen im Ergebnis nicht vorangestellt

Dir.glob(pattern, base: 'lib').take(5)
# => ["abbrev.gemspec", "abbrev.rb", "base64.gemspec", "base64.rb", "benchmark.gemspec"]
Dir.glob(pattern, base: 'lib/irb').take(5)
# => ["cmd", "color.rb", "color_printer.rb", "completion.rb", "context.rb"]

Wenn das optionale Schlüsselwort sort gegeben ist, gibt sein Wert an, ob das Array sortiert werden soll; der Standardwert ist true. Wenn der Wert false übergeben wird, deaktiviert dieses Schlüsselwort die Sortierung (obwohl das zugrunde liegende Dateisystem das Array möglicherweise bereits sortiert hat).

Muster

Jede Musterzeichenkette wird gemäß bestimmten Metazeichen erweitert; die Beispiele unten verwenden den Ruby-Dateibaum

'*': Gleicht jede Teilzeichenkette in einem Eintragsnamen ab, ähnlich der Bedeutung von Regexp /.*/mx; kann durch andere Werte in den Musterzeichenketten eingeschränkt werden
- '*' gleicht alle Eintragsnamen ab
```
Dir.glob('*').take(3)  # => ["BSDL", "CONTRIBUTING.md", "COPYING"]
```
- 'c*' gleicht Eintragsnamen ab, die mit 'c' beginnen
```
Dir.glob('c*').take(3) # => ["CONTRIBUTING.md", "COPYING", "COPYING.ja"]
```
- '*c' gleicht Eintragsnamen ab, die mit 'c' enden
```
Dir.glob('*c').take(3) # => ["addr2line.c", "array.c", "ast.c"]
```
- '*c*' gleicht Eintragsnamen ab, die 'c' enthalten, auch am Anfang oder Ende
```
Dir.glob('*c*').take(3) # => ["CONTRIBUTING.md", "COPYING", "COPYING.ja"]
```
Gleicht keine Unix-ähnlichen versteckten Eintragsnamen ("Dotfiles") ab. Um diese in die abgeglichenen Eintragsnamen einzuschließen, verwenden Sie das Flag IO::FNM_DOTMATCH oder etwas wie '{*,.*}'.
'**': Gleicht Eintragsnamen rekursiv ab, wenn gefolgt von einem Schrägstrich '/'
```
Dir.glob('**/').take(3) # => ["basictest/", "benchmark/", "benchmark/gc/"]
```
Wenn die Zeichenkette kein anderes Zeichen enthält oder nicht von einem Schrägstrich gefolgt wird, ist sie äquivalent zu '*'.
'?' Gleicht jedes einzelne Zeichen ab; ähnlich der Bedeutung von Regexp /./
```
Dir.glob('io.?') # => ["io.c"]
```
'[set]': Gleicht jedes Zeichen in der Zeichenkette set ab; verhält sich wie eine Regexp-Zeichenklasse, einschließlich Mengennegation ('[^a-z]')
```
Dir.glob('*.[a-z][a-z]').take(3)
# => ["CONTRIBUTING.md", "COPYING.ja", "KNOWNBUGS.rb"]
```
'{abc,xyz}': Gleicht entweder die Zeichenkette abc oder die Zeichenkette xyz ab; verhält sich wie Regexp-Alternation
```
Dir.glob('{LEGAL,BSDL}') # => ["LEGAL", "BSDL"]
```
Mehr als zwei Alternativen können angegeben werden.
\: Escaped das folgende Metazeichen.

Beachten Sie, dass unter Windows das umgekehrte Schrägstrichzeichen nicht in einer Musterzeichenkette verwendet werden kann: Dir['c:\foo*'] funktioniert nicht, verwenden Sie stattdessen Dir['c:/foo*'].

Weitere Beispiele (unter Verwendung des einfachen Dateibaums)

# We're in the example directory.
File.basename(Dir.pwd) # => "example"
Dir.glob('config.?')              # => ["config.h"]
Dir.glob('*.[a-z][a-z]')          # => ["main.rb"]
Dir.glob('*.[^r]*')               # => ["config.h"]
Dir.glob('*.{rb,h}')              # => ["main.rb", "config.h"]
Dir.glob('*')                     # => ["config.h", "lib", "main.rb"]
Dir.glob('*', File::FNM_DOTMATCH) # => [".", "config.h", "lib", "main.rb"]
Dir.glob(["*.rb", "*.h"])         # => ["main.rb", "config.h"]

Dir.glob('**/*.rb')
=> ["lib/song/karaoke.rb", "lib/song.rb", "main.rb"]

Dir.glob('**/*.rb', base: 'lib')  #   => ["song/karaoke.rb", "song.rb"]

Dir.glob('**/lib')                # => ["lib"]

Dir.glob('**/lib/**/*.rb')        # => ["lib/song/karaoke.rb", "lib/song.rb"]

Dir.glob('**/lib/*.rb')           # => ["lib/song.rb"]

Flags

Wenn das optionale Schlüsselwortargument flags gegeben ist (der Standardwert ist Null – keine Flags), sollte sein Wert das bitweise ODER von einem oder mehreren der in Modul File::Constants definierten Konstanten sein.

Beispiel

flags = File::FNM_EXTGLOB | File::FNM_DOTMATCH

Die Angabe von Flags kann den Abgleich erweitern, einschränken oder anderweitig modifizieren.

Die Flags für diese Methode (andere Konstanten in File::Constants gelten nicht)

File::FNM_DOTMATCH: Gibt an, dass Eintragsnamen, die mit '.' beginnen, für den Abgleich berücksichtigt werden sollten

Dir.glob('*').take(5)
# => ["BSDL", "CONTRIBUTING.md", "COPYING", "COPYING.ja", "GPL"]
Dir.glob('*', flags: File::FNM_DOTMATCH).take(5)
# => [".", ".appveyor.yml", ".cirrus.yml", ".dir-locals.el", ".document"]

File::FNM_EXTGLOB: Aktiviert die Mustererweiterung '{a,b}', die die Muster a und b abgleicht; verhält sich wie eine Regexp-Vereinigung (z. B. '(?:a|b)')
```
pattern = '{LEGAL,BSDL}'
Dir.glob(pattern)      # => ["LEGAL", "BSDL"]
```
File::FNM_NOESCAPE: Gibt an, dass das Escaping mit dem umgekehrten Schrägstrich '\' deaktiviert ist; das Zeichen ist kein Escape-Zeichen.
File::FNM_PATHNAME: Gibt an, dass Metazeichen '*' und '?' keine Verzeichnistrennzeichen abgleichen.
File::FNM_SHORTNAME: Gibt an, dass Muster kurze Namen abgleichen können, wenn sie existieren; nur Windows.

home(user_name = nil) → dirpath

Source

static VALUE
dir_s_home(int argc, VALUE *argv, VALUE obj)
{
    VALUE user;
    const char *u = 0;

    rb_check_arity(argc, 0, 1);
    user = (argc > 0) ? argv[0] : Qnil;
    if (!NIL_P(user)) {
        StringValue(user);
        rb_must_asciicompat(user);
        u = StringValueCStr(user);
        if (*u) {
            return rb_home_dir_of(user, rb_str_new(0, 0));
        }
    }
    return rb_default_home_dir(rb_str_new(0, 0));

}

Gibt den Home-Verzeichnispfad des mit user_name angegebenen Benutzers zurück, wenn dieser nicht nil ist, oder des aktuellen Anmeldbenutzers

Dir.home         # => "/home/me"
Dir.home('root') # => "/root"

Löst ArgumentError aus, wenn user_name kein Benutzername ist.

mkdir(dirpath, permissions = 0775) → 0

Source

static VALUE
dir_s_mkdir(int argc, VALUE *argv, VALUE obj)
{
    struct mkdir_arg m;
    VALUE path, vmode;
    int r;

    if (rb_scan_args(argc, argv, "11", &path, &vmode) == 2) {
        m.mode = NUM2MODET(vmode);
    }
    else {
        m.mode = 0777;
    }

    path = check_dirname(path);
    m.path = RSTRING_PTR(path);
    r = IO_WITHOUT_GVL_INT(nogvl_mkdir, &m);
    if (r < 0)
        rb_sys_fail_path(path);

    return INT2FIX(0);
}

Erstellt ein Verzeichnis im zugrunde liegenden Dateisystem unter dirpath mit den angegebenen permissions; gibt Null zurück

Dir.mkdir('foo')
File.stat(Dir.new('foo')).mode.to_s(8)[1..4] # => "0755"
Dir.mkdir('bar', 0644)
File.stat(Dir.new('bar')).mode.to_s(8)[1..4] # => "0644"

Siehe File Permissions. Beachten Sie, dass das Argument permissions unter Windows ignoriert wird.

mktmpdir (prefix_suffix=nil, *rest, **options) { |dup| ... }

Source

# File lib/tmpdir.rb, line 97
def self.mktmpdir(prefix_suffix=nil, *rest, **options, &block)
  base = nil
  path = Tmpname.create(prefix_suffix || "d", *rest, **options) {|path, _, _, d|
    base = d
    mkdir(path, 0700)
  }
  if block
    begin
      yield path.dup
    ensure
      unless base
        base = File.dirname(path)
        stat = File.stat(base)
        if stat.world_writable? and !stat.sticky?
          raise ArgumentError, "parent directory is world writable but not sticky: #{base}"
        end
      end
      FileUtils.remove_entry path
    end
  else
    path
  end
end

Dir.mktmpdir erstellt ein temporäres Verzeichnis.

require 'tmpdir'
Dir.mktmpdir {|dir|
  # use the directory
}

Das Verzeichnis wird mit der Berechtigung 0700 erstellt. Die Anwendung sollte die Berechtigung nicht ändern, um das temporäre Verzeichnis für andere Benutzer zugänglich zu machen.

Das Präfix und Suffix des Verzeichnisnamens werden durch das optionale erste Argument, prefix_suffix, angegeben.

Wenn es nicht angegeben oder nil ist, wird "d" als Präfix und kein Suffix verwendet.
Wenn es ein String ist, wird es als Präfix und kein Suffix verwendet.
Wenn es ein Array ist, wird das erste Element als Präfix und das zweite Element als Suffix verwendet.

Dir.mktmpdir {|dir| dir is ".../d..." }
Dir.mktmpdir("foo") {|dir| dir is ".../foo..." }
Dir.mktmpdir(["foo", "bar"]) {|dir| dir is ".../foo...bar" }

Das Verzeichnis wird unter Dir.tmpdir oder dem optionalen zweiten Argument tmpdir erstellt, wenn ein nicht-nil-Wert angegeben wird.

Dir.mktmpdir {|dir| dir is "#{Dir.tmpdir}/d..." }
Dir.mktmpdir(nil, "/var/tmp") {|dir| dir is "/var/tmp/d..." }

Wenn ein Block gegeben wird, wird er mit dem Pfad des Verzeichnisses übergeben. Das Verzeichnis und sein Inhalt werden mit FileUtils.remove_entry entfernt, bevor Dir.mktmpdir zurückkehrt. Der Wert des Blocks wird zurückgegeben.

Dir.mktmpdir {|dir|
  # use the directory...
  open("#{dir}/foo", "w") { something using the file }
}

Wenn kein Block gegeben wird, wird der Pfad des Verzeichnisses zurückgegeben. In diesem Fall entfernt Dir.mktmpdir das Verzeichnis nicht.

dir = Dir.mktmpdir
begin
  # use the directory...
  open("#{dir}/foo", "w") { something using the file }
ensure
  # remove the directory.
  FileUtils.remove_entry dir
end

new(dirpath) → dir

new(dirpath, encoding: nil) → dir

Source

# File dir.rb, line 211
def initialize(name, encoding: nil)
  Primitive.dir_initialize(name, encoding)
end

Gibt ein neues Dir-Objekt für das Verzeichnis unter dirpath zurück

Dir.new('.') # => #<Dir:.>

Der Wert, der mit dem optionalen Schlüsselwortargument encoding angegeben wird, bestimmt die Kodierung für die Verzeichniseintragsnamen; wenn nil (Standard), wird die Kodierung des Dateisystems verwendet

Dir.new('.').read.encoding                       # => #<Encoding:UTF-8>
Dir.new('.', encoding: Encoding::US_ASCI).read.encoding # => #<Encoding:US-ASCII>

open(dirpath) → dir

open(dirpath, encoding: nil) → dir

open(dirpath) {|dir| ... } → object

open(dirpath, encoding: nil) {|dir| ... } → object

Source

# File dir.rb, line 183
def self.open(name, encoding: nil, &block)
  dir = Primitive.dir_s_open(name, encoding)
  if block
    begin
      yield dir
    ensure
      Primitive.dir_s_close(dir)
    end
  else
    dir
  end
end

Erstellt ein neues Dir-Objekt dir für das Verzeichnis unter dirpath.

Ohne Block ist die Methode identisch mit Dir.new(dirpath, encoding)

Dir.open('.') # => #<Dir:.>

Mit einem gegebenen Block wird der Block mit dem erstellten dir aufgerufen; beim Beenden des Blocks wird dir geschlossen und der Wert des Blocks zurückgegeben

Dir.open('.') {|dir| dir.inspect } # => "#<Dir:.>"

Dir.open('.').read.encoding                       # => #<Encoding:UTF-8>
Dir.open('.', encoding: Encoding::US_ASCII).read.encoding # => #<Encoding:US-ASCII>

pwd → string

Source

static VALUE
dir_s_getwd(VALUE dir)
{
    return rb_dir_getwd();
}

Gibt den Pfad zum aktuellen Arbeitsverzeichnis zurück

Dir.chdir("/tmp") # => 0
Dir.pwd           # => "/tmp"

rmdir(dirpath) → 0

Source

static VALUE
dir_s_rmdir(VALUE obj, VALUE dir)
{
    const char *p;
    int r;

    dir = check_dirname(dir);
    p = RSTRING_PTR(dir);
    r = IO_WITHOUT_GVL_INT(nogvl_rmdir, (void *)p);
    if (r < 0)
        rb_sys_fail_path(dir);

    return INT2FIX(0);
}

Entfernt das Verzeichnis unter dirpath aus dem zugrunde liegenden Dateisystem

Dir.rmdir('foo') # => 0

Löst eine Ausnahme aus, wenn das Verzeichnis nicht leer ist.

tmpdir ()

Source

# File lib/tmpdir.rb, line 25
def self.tmpdir
  Tmpname::TMPDIR_CANDIDATES.find do |name, dir|
    unless dir
      next if !(dir = ENV[name] rescue next) or dir.empty?
    end
    dir = File.expand_path(dir)
    stat = File.stat(dir) rescue next
    case
    when !stat.directory?
      warn "#{name} is not a directory: #{dir}"
    when !File.writable?(dir)
      # We call File.writable?, not stat.writable?, because you can't tell if a dir is actually
      # writable just from stat; OS mechanisms other than user/group/world bits can affect this.
      warn "#{name} is not writable: #{dir}"
    when stat.world_writable? && !stat.sticky?
      warn "#{name} is world-writable: #{dir}"
    else
      break dir
    end
  end or raise ArgumentError, "could not find a temporary directory"
end

Gibt den temporären Dateipfad des Betriebssystems zurück.

require 'tmpdir'
Dir.tmpdir # => "/tmp"

rmdir(dirpath) → 0

Source

static VALUE
dir_s_rmdir(VALUE obj, VALUE dir)
{
    const char *p;
    int r;

    dir = check_dirname(dir);
    p = RSTRING_PTR(dir);
    r = IO_WITHOUT_GVL_INT(nogvl_rmdir, (void *)p);
    if (r < 0)
        rb_sys_fail_path(dir);

    return INT2FIX(0);
}

Entfernt das Verzeichnis unter dirpath aus dem zugrunde liegenden Dateisystem

Dir.rmdir('foo') # => 0

Löst eine Ausnahme aus, wenn das Verzeichnis nicht leer ist.

Öffentliche Instanzmethoden

chdir → 0

chdir { ... } → object

Source

static VALUE
dir_chdir(VALUE dir)
{
#if defined(HAVE_FCHDIR) && defined(HAVE_DIRFD) && HAVE_FCHDIR && HAVE_DIRFD
    return dir_s_fchdir(rb_cDir, dir_fileno(dir));
#else
    return chdir_path(dir_get(dir)->path, false);
#endif
}

Ändert das aktuelle Arbeitsverzeichnis in self

Dir.pwd # => "/"
dir = Dir.new('example')
dir.chdir
Dir.pwd # => "/example"

Mit einem Block ändert es vorübergehend das Arbeitsverzeichnis

Ruft den Block auf.
Ändert zum angegebenen Verzeichnis.
Führt den Block aus (übergibt keine Argumente).
Stellt das vorherige Arbeitsverzeichnis wieder her.
Gibt den Rückgabewert des Blocks zurück.

Verwendet Dir.fchdir, falls verfügbar, und Dir.chdir, falls nicht. Siehe die genannten Methoden für Vorbehalte.

children → array

Source

static VALUE
dir_collect_children(VALUE dir)
{
    VALUE ary = rb_ary_new();
    dir_each_entry(dir, rb_ary_push, ary, TRUE);
    return ary;
}

Gibt ein Array von Eintragsnamen in self zurück, außer '.' und '..'

dir = Dir.new('/example')
dir.children # => ["config.h", "lib", "main.rb"]

close → nil

Source

static VALUE
dir_close(VALUE dir)
{
    struct dir_data *dirp;

    dirp = dir_get(dir);
    if (!dirp->dir) return Qnil;
    close_dir_data(dirp);

    return Qnil;
}

Schließt den Stream in self, falls er geöffnet ist, und gibt nil zurück; wird ignoriert, wenn self bereits geschlossen ist

dir = Dir.new('example')
dir.read     # => "."
dir.close     # => nil
dir.close     # => nil
dir.read # Raises IOError.

each {|entry_name| ... } → self

Source

static VALUE
dir_each(VALUE dir)
{
    RETURN_ENUMERATOR(dir, 0, 0);
    return dir_each_entry(dir, dir_yield, Qnil, FALSE);
}

Ruft den Block mit jedem Eintragsnamen in self auf

Dir.new('example').each {|entry_name| p entry_name }

Ausgabe

"."
".."
"config.h"
"lib"
"main.rb"

Ohne Block wird ein Enumerator zurückgegeben.

each_child {|entry_name| ... } → self

Source

static VALUE
dir_each_child_m(VALUE dir)
{
    RETURN_ENUMERATOR(dir, 0, 0);
    return dir_each_entry(dir, dir_yield, Qnil, TRUE);
}

Ruft den Block mit jedem Eintragsnamen in self auf, außer '.' und '..'

dir = Dir.new('/example')
dir.each_child {|entry_name| p entry_name }

Ausgabe

"config.h"
"lib"
"main.rb"

Wenn kein Block gegeben wird, gibt er einen Enumerator zurück.

fileno → integer

Source

static VALUE
dir_fileno(VALUE dir)
{
    struct dir_data *dirp;
    int fd;

    GetDIR(dir, dirp);
    fd = dirfd(dirp->dir);
    if (fd == -1)
        rb_sys_fail("dirfd");
    return INT2NUM(fd);
}

Gibt den Dateideskriptor zurück, der in dir verwendet wird.

d = Dir.new('..')
d.fileno # => 8

Diese Methode verwendet die von POSIX 2008 definierte Funktion dirfd(); die Methode wird auf nicht-POSIX-Plattformen nicht implementiert (löst NotImplementedError aus).

inspect → String

Source

static VALUE
dir_inspect(VALUE dir)
{
    struct dir_data *dirp;

    TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);
    if (!NIL_P(dirp->path)) {
        VALUE str = rb_str_new_cstr("#<");
        rb_str_append(str, rb_class_name(CLASS_OF(dir)));
        rb_str_cat2(str, ":");
        rb_str_append(str, dirp->path);
        rb_str_cat2(str, ">");
        return str;
    }
    return rb_funcallv(dir, idTo_s, 0, 0);
}

Gibt eine String-Beschreibung von self zurück

Dir.new('example').inspect # => "#<Dir:example>"

path → string or nil

Source

static VALUE
dir_path(VALUE dir)
{
    struct dir_data *dirp;

    TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);
    if (NIL_P(dirp->path)) return Qnil;
    return rb_str_dup(dirp->path);
}

Gibt den String dirpath zurück, der zur Erstellung von self verwendet wurde (oder nil, wenn er von der Methode Dir.for_fd erstellt wurde)

Dir.new('example').path # => "example"

Auch alias für: to_path

pos

Alias für: tell

pos = position → integer

Source

static VALUE
dir_set_pos(VALUE dir, VALUE pos)
{
    dir_seek(dir, pos);
    return pos;
}

Setzt die Position in self und gibt position zurück. Der Wert von position sollte von einem früheren Aufruf von tell zurückgegeben worden sein; wenn nicht, sind die Rückgabewerte von nachfolgenden Aufrufen von read nicht spezifiziert.

Siehe Dir As Stream-Like.

Beispiele

dir = Dir.new('example')
dir.pos      # => 0
dir.pos = 3  # => 3
dir.pos      # => 3
dir.pos = 30 # => 30
dir.pos      # => 5

read → string or nil

Source

static VALUE
dir_read(VALUE dir)
{
    struct dir_data *dirp;
    struct dirent *dp;

    GetDIR(dir, dirp);
    rb_errno_set(0);
    if ((dp = READDIR(dirp->dir, dirp->enc)) != NULL) {
        return rb_external_str_new_with_enc(dp->d_name, NAMLEN(dp), dirp->enc);
    }
    else {
        int e = errno;
        if (e != 0) rb_syserr_fail(e, 0);
        return Qnil;            /* end of stream */
    }
}

Liest und gibt den nächsten Eintragsnamen aus self zurück; gibt nil zurück, wenn das Ende des Streams erreicht ist; siehe Dir As Stream-Like

dir = Dir.new('example')
dir.read # => "."
dir.read # => ".."
dir.read # => "config.h"

rewind → self

Source

static VALUE
dir_rewind(VALUE dir)
{
    struct dir_data *dirp;

    GetDIR(dir, dirp);
    rewinddir(dirp->dir);
    return dir;
}

Setzt die Position in self auf Null; siehe Dir As Stream-Like

dir = Dir.new('example')
dir.read    # => "."
dir.read    # => ".."
dir.pos     # => 2
dir.rewind  # => #<Dir:example>
dir.pos     # => 0

seek(position) → self

Source

static VALUE
dir_seek(VALUE dir, VALUE pos)
{
    struct dir_data *dirp;
    long p = NUM2LONG(pos);

    GetDIR(dir, dirp);
    seekdir(dirp->dir, p);
    return dir;
}

Setzt die Position in self und gibt self zurück. Der Wert von position sollte von einem früheren Aufruf von tell zurückgegeben worden sein; wenn nicht, sind die Rückgabewerte von nachfolgenden Aufrufen von read nicht spezifiziert.

Siehe Dir As Stream-Like.

Beispiele

dir = Dir.new('example')
dir.pos      # => 0
dir.seek(3)  # => #<Dir:example>
dir.pos      # => 3
dir.seek(30) # => #<Dir:example>
dir.pos      # => 5

tell → integer

Source

static VALUE
dir_tell(VALUE dir)
{
    struct dir_data *dirp;
    long pos;

    GetDIR(dir, dirp);
    if((pos = telldir(dirp->dir)) < 0)
        rb_sys_fail("telldir");
    return rb_int2inum(pos);
}

Gibt die aktuelle Position von self zurück; siehe Dir As Stream-Like

dir = Dir.new('example')
dir.tell  # => 0
dir.read  # => "."
dir.tell  # => 1

Auch alias für: pos

to_path

Alias für: path