Filesystem

read(filename::AbstractString)

Lese den gesamten Inhalt einer Datei als Vector{UInt8}.

read(filename::AbstractString, String)

Lese den gesamten Inhalt einer Datei als Zeichenfolge.

read(filename::AbstractString, args...)

Öffne eine Datei und lese ihren Inhalt. args wird an read übergeben: dies entspricht open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Schreibt die kanonische binäre Darstellung von content in eine Datei, die erstellt wird, wenn sie noch nicht existiert, oder überschrieben wird, wenn sie bereits existiert.

Gibt die Anzahl der in die Datei geschriebenen Bytes zurück.

pwd() -> String

Holen Sie das aktuelle Arbeitsverzeichnis.

Siehe auch: cd, tempdir.

Beispiele

julia> pwd()
"/home/JuliaUser"

julia> cd("/home/JuliaUser/Projects/julia")

julia> pwd()
"/home/JuliaUser/Projects/julia"

cd(dir::AbstractString=homedir())

Setzen Sie das aktuelle Arbeitsverzeichnis.

Siehe auch: pwd, mkdir, mkpath, mktempdir.

Beispiele

julia> cd("/home/JuliaUser/Projects/julia")

julia> pwd()
"/home/JuliaUser/Projects/julia"

julia> cd()

julia> pwd()
"/home/JuliaUser"

cd(f::Function, dir::AbstractString=homedir())

Ändert vorübergehend das aktuelle Arbeitsverzeichnis in dir, wendet die Funktion f an und kehrt schließlich zum ursprünglichen Verzeichnis zurück.

Beispiele

julia> pwd()
"/home/JuliaUser"

julia> cd(readdir, "/home/JuliaUser/Projects/julia")
34-element Array{String,1}:
 ".circleci"
 ".freebsdci.sh"
 ".git"
 ".gitattributes"
 ".github"
 ⋮
 "test"
 "ui"
 "usr"
 "usr-staging"

julia> pwd()
"/home/JuliaUser"

readdir(dir::AbstractString=pwd();
    join::Bool = false,
    sort::Bool = true,
) -> Vector{String}

Gibt die Namen im Verzeichnis dir oder im aktuellen Arbeitsverzeichnis zurück, wenn nichts angegeben ist. Wenn join falsch ist, gibt readdir nur die Namen im Verzeichnis so zurück, wie sie sind; wenn join wahr ist, gibt es joinpath(dir, name) für jeden name zurück, sodass die zurückgegebenen Strings vollständige Pfade sind. Wenn Sie absolute Pfade zurückbekommen möchten, rufen Sie readdir mit einem absoluten Verzeichnispfad und join auf true auf.

Standardmäßig sortiert readdir die Liste der Namen, die es zurückgibt. Wenn Sie das Sortieren der Namen überspringen und sie in der Reihenfolge erhalten möchten, in der das Dateisystem sie auflistet, können Sie readdir(dir, sort=false) verwenden, um auf das Sortieren zu verzichten.

Siehe auch: walkdir.

Beispiele

julia> cd("/home/JuliaUser/dev/julia")

julia> readdir()
30-element Array{String,1}:
 ".appveyor.yml"
 ".git"
 ".gitattributes"
 ⋮
 "ui"
 "usr"
 "usr-staging"

julia> readdir(join=true)
30-element Array{String,1}:
 "/home/JuliaUser/dev/julia/.appveyor.yml"
 "/home/JuliaUser/dev/julia/.git"
 "/home/JuliaUser/dev/julia/.gitattributes"
 ⋮
 "/home/JuliaUser/dev/julia/ui"
 "/home/JuliaUser/dev/julia/usr"
 "/home/JuliaUser/dev/julia/usr-staging"

julia> readdir("base")
145-element Array{String,1}:
 ".gitignore"
 "Base.jl"
 "Enums.jl"
 ⋮
 "version_git.sh"
 "views.jl"
 "weakkeydict.jl"

julia> readdir("base", join=true)
145-element Array{String,1}:
 "base/.gitignore"
 "base/Base.jl"
 "base/Enums.jl"
 ⋮
 "base/version_git.sh"
 "base/views.jl"
 "base/weakkeydict.jl"

julia> readdir(abspath("base"), join=true)
145-element Array{String,1}:
 "/home/JuliaUser/dev/julia/base/.gitignore"
 "/home/JuliaUser/dev/julia/base/Base.jl"
 "/home/JuliaUser/dev/julia/base/Enums.jl"
 ⋮
 "/home/JuliaUser/dev/julia/base/version_git.sh"
 "/home/JuliaUser/dev/julia/base/views.jl"
 "/home/JuliaUser/dev/julia/base/weakkeydict.jl"

walkdir(dir; topdown=true, follow_symlinks=false, onerror=throw)

Gibt einen Iterator zurück, der den Verzeichnisbaum eines Verzeichnisses durchläuft. Der Iterator gibt ein Tupel zurück, das (rootpath, dirs, files) enthält. Der Verzeichnisbaum kann von oben nach unten oder von unten nach oben durchlaufen werden. Wenn walkdir oder stat auf einen IOError stößt, wird der Fehler standardmäßig erneut ausgelöst. Eine benutzerdefinierte Fehlerbehandlungsfunktion kann über das Schlüsselwortargument onerror bereitgestellt werden. onerror wird mit einem IOError als Argument aufgerufen.

Siehe auch: readdir.

Beispiele

for (root, dirs, files) in walkdir(".")
    println("Verzeichnisse in $root")
    for dir in dirs
        println(joinpath(root, dir)) # Pfad zu Verzeichnissen
    end
    println("Dateien in $root")
    for file in files
        println(joinpath(root, file)) # Pfad zu Dateien
    end
end

julia> mkpath("my/test/dir");

julia> itr = walkdir("my");

julia> (root, dirs, files) = first(itr)
("my", ["test"], String[])

julia> (root, dirs, files) = first(itr)
("my/test", ["dir"], String[])

julia> (root, dirs, files) = first(itr)
("my/test/dir", String[], String[])

mkdir(path::AbstractString; mode::Unsigned = 0o777)

Erstellen Sie ein neues Verzeichnis mit dem Namen path und den Berechtigungen mode. mode hat standardmäßig den Wert 0o777, der durch die aktuelle Dateierstellungsmaske modifiziert wird. Diese Funktion erstellt niemals mehr als ein Verzeichnis. Wenn das Verzeichnis bereits existiert oder einige Zwischenverzeichnisse nicht existieren, wirft diese Funktion einen Fehler. Siehe mkpath für eine Funktion, die alle erforderlichen Zwischenverzeichnisse erstellt. Gibt path zurück.

Beispiele

julia> mkdir("testingdir")
"testingdir"

julia> cd("testingdir")

julia> pwd()
"/home/JuliaUser/testingdir"

mkpath(path::AbstractString; mode::Unsigned = 0o777)

Erstellt alle erforderlichen Zwischenverzeichnisse im path. Verzeichnisse werden mit den Berechtigungen mode erstellt, die standardmäßig auf 0o777 gesetzt sind und durch die aktuelle Dateierstellungsmaske modifiziert werden. Im Gegensatz zu mkdir gibt es bei mkpath keinen Fehler, wenn path (oder Teile davon) bereits existiert. Ein Fehler wird jedoch ausgelöst, wenn path (oder Teile davon) auf eine vorhandene Datei verweist. Gibt path zurück.

Wenn path einen Dateinamen enthält, möchten Sie wahrscheinlich mkpath(dirname(path)) verwenden, um zu vermeiden, dass ein Verzeichnis mit dem Dateinamen erstellt wird.

Beispiele

julia> cd(mktempdir())

julia> mkpath("my/test/dir") # erstellt drei Verzeichnisse
"my/test/dir"

julia> readdir()
1-element Array{String,1}:
 "my"

julia> cd("my")

julia> readdir()
1-element Array{String,1}:
 "test"

julia> readdir("test")
1-element Array{String,1}:
 "dir"

julia> mkpath("intermediate_dir/actually_a_directory.txt") # erstellt zwei Verzeichnisse
"intermediate_dir/actually_a_directory.txt"

julia> isdir("intermediate_dir/actually_a_directory.txt")
true

hardlink(src::AbstractString, dst::AbstractString)

Erstellt einen Hardlink zu einer vorhandenen Quelldatei src mit dem Namen dst. Das Ziel, dst, darf nicht existieren.

Siehe auch: symlink.

symlink(target::AbstractString, link::AbstractString; dir_target = false)

Erstellt einen symbolischen Link zu target mit dem Namen link.

Unter Windows müssen symbolische Links ausdrücklich als Verweis auf ein Verzeichnis oder nicht deklariert werden. Wenn target bereits existiert, wird standardmäßig der Typ von link automatisch erkannt. Wenn target jedoch nicht existiert, erstellt diese Funktion standardmäßig einen Dateisymbollink, es sei denn, dir_target ist auf true gesetzt. Beachten Sie, dass, wenn der Benutzer dir_target festlegt, target jedoch existiert und eine Datei ist, ein Verzeichnissymbollink weiterhin erstellt wird, das Dereferenzieren des Links jedoch fehlschlägt, genau wie wenn der Benutzer einen Dateisymbollink erstellt (indem er symlink() mit dir_target auf false vor dem Erstellen des Verzeichnisses aufruft) und versucht, ihn auf ein Verzeichnis zu dereferenzieren.

Darüber hinaus gibt es zwei Methoden, um einen Link unter Windows zu erstellen: symbolische Links und Junction-Punkte. Junction-Punkte sind etwas effizienter, unterstützen jedoch keine relativen Pfade. Wenn also ein relativer Verzeichnissymbollink angefordert wird (wie durch isabspath(target) angezeigt, das false zurückgibt), wird ein Symbollink verwendet, andernfalls wird ein Junction-Punkt verwendet. Die beste Praxis zum Erstellen von Symbollinks unter Windows besteht darin, sie nur zu erstellen, nachdem die Dateien/Verzeichnisse, auf die sie verweisen, bereits erstellt wurden.

Siehe auch: hardlink.

readlink(pfad::AbstractString) -> String

Gibt den Zielort zurück, auf den ein symbolischer Link pfad zeigt.

chmod(path::AbstractString, mode::Integer; recursive::Bool=false)

Ändern Sie den Berechtigungsmodus von path auf mode. Nur ganzzahlige modes (z. B. 0o777) werden derzeit unterstützt. Wenn recursive=true und der Pfad ein Verzeichnis ist, werden alle Berechtigungen in diesem Verzeichnis rekursiv geändert. Geben Sie path zurück.

!!! Hinweis Vor Julia 1.6 konnte dies die Dateisystem-ACLs unter Windows nicht korrekt manipulieren, daher wurden nur schreibgeschützte Bits für Dateien gesetzt. Es kann jetzt ACLs manipulieren.

chown(path::AbstractString, owner::Integer, group::Integer=-1)

Ändert den Besitzer und/oder die Gruppe von path in owner und/oder group. Wenn der eingegebene Wert für owner oder group -1 ist, wird die entsprechende ID nicht geändert. Derzeit werden nur ganze Zahlen für owner und group unterstützt. Gibt path zurück.

RawFD

Primitiver Typ, der den nativen OS-Dateideskriptor umschließt. RawFDs können an Methoden wie stat übergeben werden, um Informationen über die zugrunde liegende Datei zu erhalten, und können auch verwendet werden, um Streams zu öffnen, wobei der RawFD die OS-Datei beschreibt, die den Stream unterstützt.

stat(file)

Gibt eine Struktur zurück, deren Felder Informationen über die Datei enthalten. Die Felder der Struktur sind:

diskstat(path=pwd())

Gibt Statistiken in Bytes über das Laufwerk zurück, das die Datei oder das Verzeichnis enthält, auf das path verweist. Wenn kein Argument übergeben wird, werden Statistiken über das Laufwerk zurückgegeben, das das aktuelle Arbeitsverzeichnis enthält.

lstat(datei)

Wie stat, aber für symbolische Links erhält die Funktion die Informationen für den Link selbst anstelle der Datei, auf die verwiesen wird. Diese Funktion muss auf einem Dateipfad und nicht auf einem Dateiobjekt oder einem Dateideskriptor aufgerufen werden.

ctime(datei)

Entspricht stat(datei).ctime.

mtime(datei)

Entspricht stat(datei).mtime.

filemode(datei)

Entspricht stat(datei).mode.

filesize(pfad...)

Entspricht stat(datei).größe.

uperm(datei)

Holen Sie sich die Berechtigungen des Eigentümers der Datei als Bitfeld von

Für erlaubte Argumente siehe stat.

gperm(file)

Wie uperm, aber erhält die Berechtigungen der Gruppe, die die Datei besitzt.

operm(datei)

Wie uperm, aber erhält die Berechtigungen für Personen, die weder der Eigentümer der Datei sind noch Mitglied der Gruppe, die die Datei besitzt.

cp(src::AbstractString, dst::AbstractString; force::Bool=false, follow_symlinks::Bool=false)

Kopiere die Datei, den Link oder das Verzeichnis von src nach dst. force=true entfernt zuerst ein vorhandenes dst.

Wenn follow_symlinks=false und src ein symbolischer Link ist, wird dst als symbolischer Link erstellt. Wenn follow_symlinks=true und src ein symbolischer Link ist, wird dst eine Kopie der Datei oder des Verzeichnisses, auf das src verweist. Rückgabe von dst.

download(url::AbstractString, [path::AbstractString = tempname()]) -> path

Lädt eine Datei von der angegebenen URL herunter und speichert sie am Speicherort path, oder, wenn nicht angegeben, an einem temporären Speicherort. Gibt den Pfad der heruntergeladenen Datei zurück.

mv(src::AbstractString, dst::AbstractString; force::Bool=false)

Bewege die Datei, den Link oder das Verzeichnis von src nach dst. force=true entfernt zuerst ein vorhandenes dst. Gibt dst zurück.

Beispiele

julia> write("hello.txt", "world");

julia> mv("hello.txt", "goodbye.txt")
"goodbye.txt"

julia> "hello.txt" in readdir()
false

julia> readline("goodbye.txt")
"world"

julia> write("hello.txt", "world2");

julia> mv("hello.txt", "goodbye.txt")
ERROR: ArgumentError: 'goodbye.txt' existiert. `force=true` ist erforderlich, um 'goodbye.txt' vor dem Verschieben zu entfernen.
Stacktrace:
 [1] #checkfor_mv_cp_cptree#10(::Bool, ::Function, ::String, ::String, ::String) at ./file.jl:293
[...]

julia> mv("hello.txt", "goodbye.txt", force=true)
"goodbye.txt"

julia> rm("goodbye.txt");

rm(path::AbstractString; force::Bool=false, recursive::Bool=false)

Löschen Sie die Datei, den Link oder das leere Verzeichnis am angegebenen Pfad. Wenn force=true übergeben wird, wird ein nicht vorhandener Pfad nicht als Fehler behandelt. Wenn recursive=true übergeben wird und der Pfad ein Verzeichnis ist, werden alle Inhalte rekursiv entfernt.

Beispiele

julia> mkpath("my/test/dir");

julia> rm("my", recursive=true)

julia> rm("this_file_does_not_exist", force=true)

julia> rm("this_file_does_not_exist")
ERROR: IOError: unlink("this_file_does_not_exist"): no such file or directory (ENOENT)
Stacktrace:
[...]

Base.touch(::Pidfile.LockMonitor)

Aktualisiert die mtime des Locks, um anzuzeigen, dass er noch aktuell ist.

Siehe auch das refresh-Schlüsselwort im mkpidlock Konstruktor.

touch(path::AbstractString)
touch(fd::File)

Aktualisiert den Zeitstempel der letzten Änderung einer Datei auf die aktuelle Zeit.

Wenn die Datei nicht existiert, wird eine neue Datei erstellt.

Gibt path zurück.

Beispiele

julia> write("my_little_file", 2);

julia> mtime("my_little_file")
1.5273815391135583e9

julia> touch("my_little_file");

julia> mtime("my_little_file")
1.527381559163435e9

Wir können sehen, dass mtime durch touch geändert wurde.

tempname(parent=tempdir(); cleanup=true) -> String

Generiert einen temporären Dateipfad. Diese Funktion gibt nur einen Pfad zurück; es wird keine Datei erstellt. Der Pfad wird wahrscheinlich einzigartig sein, aber dies kann aufgrund der sehr geringen Möglichkeit, dass zwei gleichzeitige Aufrufe von tempname denselben Dateinamen generieren, nicht garantiert werden. Der Name wird garantiert von allen Dateien abzuweichen, die zum Zeitpunkt des Aufrufs von tempname bereits existieren.

Wenn ohne Argumente aufgerufen, wird der temporäre Name ein absoluter Pfad zu einem temporären Namen im temporären Verzeichnis des Systems sein, wie von tempdir() angegeben. Wenn ein parent-Verzeichnisargument angegeben wird, befindet sich der temporäre Pfad stattdessen in diesem Verzeichnis.

Die cleanup-Option steuert, ob der Prozess versucht, den zurückgegebenen Pfad automatisch zu löschen, wenn der Prozess beendet wird. Beachten Sie, dass die Funktion tempname an dem zurückgegebenen Ort keine Datei oder kein Verzeichnis erstellt, sodass es nichts zu bereinigen gibt, es sei denn, Sie erstellen dort eine Datei oder ein Verzeichnis. Wenn Sie dies tun und cleanup true ist, wird es bei der Beendigung des Prozesses gelöscht.

tempdir()

Erhält den Pfad des temporären Verzeichnisses. Unter Windows verwendet tempdir() die erste Umgebungsvariable, die in der geordneten Liste TMP, TEMP, USERPROFILE gefunden wird. Auf allen anderen Betriebssystemen verwendet tempdir() die erste Umgebungsvariable, die in der geordneten Liste TMPDIR, TMP, TEMP und TEMPDIR gefunden wird. Wenn keine dieser Variablen gefunden wird, wird der Pfad "/tmp" verwendet.

mktemp(parent=tempdir(); cleanup=true) -> (path, io)

Gibt (path, io) zurück, wobei path der Pfad einer neuen temporären Datei in parent ist und io ein offenes Dateiobjekt für diesen Pfad ist. Die Option cleanup steuert, ob die temporäre Datei automatisch gelöscht wird, wenn der Prozess beendet wird.

mktemp(f::Function, parent=tempdir())

Wenden Sie die Funktion f auf das Ergebnis von mktemp(parent) an und entfernen Sie die temporäre Datei nach Abschluss.

Siehe auch: mktempdir.

mktempdir(parent=tempdir(); prefix="jl_", cleanup=true) -> path

Erstellt ein temporäres Verzeichnis im parent-Verzeichnis mit einem Namen, der aus dem angegebenen prefix und einem zufälligen Suffix zusammengesetzt ist, und gibt dessen Pfad zurück. Darüber hinaus können auf einigen Plattformen alle nachfolgenden 'X'-Zeichen im prefix durch zufällige Zeichen ersetzt werden. Wenn parent nicht existiert, wird ein Fehler ausgelöst. Die cleanup-Option steuert, ob das temporäre Verzeichnis automatisch gelöscht wird, wenn der Prozess beendet wird.

Siehe auch: mktemp, mkdir.

mktempdir(f::Function, parent=tempdir(); prefix="jl_")

Wenden Sie die Funktion f auf das Ergebnis von mktempdir(parent; prefix) an und entfernen Sie das temporäre Verzeichnis sowie dessen gesamten Inhalt nach Abschluss.

Siehe auch: mktemp, mkdir.

isblockdev(path) -> Bool

Gibt true zurück, wenn path ein Blockgerät ist, andernfalls false.

ischardev(path) -> Bool

Gibt true zurück, wenn path ein Zeichengerät ist, andernfalls false.

isdir(pfad) -> Bool

Gibt true zurück, wenn pfad ein Verzeichnis ist, andernfalls false.

Beispiele

julia> isdir(homedir())
true

julia> isdir("not/a/directory")
false

Siehe auch isfile und ispath.

isfifo(path) -> Bool

Gibt true zurück, wenn path ein FIFO ist, andernfalls false.

isfile(pfad) -> Bool

Gibt true zurück, wenn pfad eine reguläre Datei ist, andernfalls false.

Beispiele

julia> isfile(homedir())
false

julia> dateiname = "test_file.txt";

julia> write(dateiname, "Hallo Welt!");

julia> isfile(dateiname)
true

julia> rm(dateiname);

julia> isfile(dateiname)
false

Siehe auch isdir und ispath.

islink(path) -> Bool

Gibt true zurück, wenn path ein symbolischer Link ist, andernfalls false.

ismount(path) -> Bool

Gibt true zurück, wenn path ein Mountpunkt ist, andernfalls false.

ispath(path) -> Bool

Gibt true zurück, wenn ein gültiges Dateisystem-Element unter path existiert, andernfalls wird false zurückgegeben. Dies ist die Verallgemeinerung von isfile, isdir usw.

issetgid(path) -> Bool

Gibt true zurück, wenn path das setgid-Flag gesetzt hat, andernfalls false.

issetuid(path) -> Bool

Gibt true zurück, wenn path das setuid-Flag gesetzt hat, andernfalls false.

issocket(path) -> Bool

Gibt true zurück, wenn path ein Socket ist, andernfalls false.

issticky(path) -> Bool

Gibt true zurück, wenn path das Sticky-Bit gesetzt hat, andernfalls false.

homedir() -> String

Gibt das Home-Verzeichnis des aktuellen Benutzers zurück.

Siehe auch Sys.username.

dirname(path::AbstractString) -> String

Holen Sie den Verzeichnisteil eines Pfades. Nachfolgende Zeichen ('/' oder '\') im Pfad werden als Teil des Pfades gezählt.

Beispiele

julia> dirname("/home/myuser")
"/home"

julia> dirname("/home/myuser/")
"/home/myuser"

Siehe auch basename.

basename(path::AbstractString) -> String

Holen Sie sich den Dateinamensteil eines Pfades.

!!! Hinweis Diese Funktion unterscheidet sich leicht vom Unix-Programm basename, bei dem abschließende Schrägstriche ignoriert werden, d.h. $ basename /foo/bar/ gibt bar zurück, während basename in Julia einen leeren String "" zurückgibt.

Beispiele

julia> basename("/home/myuser/example.jl")
"example.jl"

julia> basename("/home/myuser/")
""

Siehe auch dirname.

isabspath(path::AbstractString) -> Bool

Bestimmen Sie, ob ein Pfad absolut ist (am Wurzelverzeichnis beginnt).

Beispiele

julia> isabspath("/home")
true

julia> isabspath("home")
false

isdirpath(path::AbstractString) -> Bool

Bestimmen Sie, ob ein Pfad auf ein Verzeichnis verweist (zum Beispiel, ob er mit einem Pfadtrennzeichen endet).

Beispiele

julia> isdirpath("/home")
false

julia> isdirpath("/home/")
true

joinpath(parts::AbstractString...) -> String
joinpath(parts::Vector{AbstractString}) -> String
joinpath(parts::Tuple{AbstractString}) -> String

Fügt Pfadkomponenten zu einem vollständigen Pfad zusammen. Wenn ein Argument ein absoluter Pfad ist oder (unter Windows) eine Laufwerkspezifikation hat, die nicht mit dem für die Verbindung der vorhergehenden Pfade berechneten Laufwerk übereinstimmt, werden vorherige Komponenten verworfen.

Hinweis zu Windows: Da es für jedes Laufwerk ein aktuelles Verzeichnis gibt, stellt joinpath("c:", "foo") einen Pfad dar, der relativ zum aktuellen Verzeichnis auf Laufwerk "c:" ist, sodass dies gleichbedeutend mit "c:foo" ist, nicht mit "c:\foo". Darüber hinaus behandelt joinpath dies als einen nicht absoluten Pfad und ignoriert die Groß- und Kleinschreibung des Laufwerksbuchstabens, daher gilt joinpath("C:\A","c:b") = "C:\A\b".

Beispiele

julia> joinpath("/home/myuser", "example.jl")
"/home/myuser/example.jl"

julia> joinpath(["/home/myuser", "example.jl"])
"/home/myuser/example.jl"

abspath(path::AbstractString) -> String

Konvertiert einen Pfad in einen absoluten Pfad, indem das aktuelle Verzeichnis hinzugefügt wird, falls erforderlich. Normalisiert auch den Pfad wie in normpath.

Beispiele

Wenn Sie sich in einem Verzeichnis namens JuliaExample befinden und die Daten, die Sie verwenden, zwei Ebenen über dem Verzeichnis JuliaExample liegen, könnten Sie schreiben:

abspath("../../data")

Was einen Pfad wie "/home/JuliaUser/data/" ergibt.

Siehe auch joinpath, pwd, expanduser.

abspath(pfad::AbstractString, pfade::AbstractString...) -> String

Konvertiert eine Menge von Pfaden in einen absoluten Pfad, indem sie zusammengefügt werden und das aktuelle Verzeichnis hinzugefügt wird, falls erforderlich. Entspricht abspath(joinpath(pfad, pfade...)).

normpath(path::AbstractString) -> String

Normalisiert einen Pfad, entfernt "." und ".." Einträge und ändert "/" in den kanonischen Pfadtrennzeichen für das System.

Beispiele

julia> normpath("/home/myuser/../example.jl")
"/home/example.jl"

julia> normpath("Documents/Julia") == joinpath("Documents", "Julia")
true

normpath(pfad::AbstractString, pfade::AbstractString...) -> String

Konvertiert eine Menge von Pfaden in einen normalisierten Pfad, indem sie zusammengefügt und "." und ".." Einträge entfernt werden. Entspricht normpath(joinpath(pfad, pfade...)).

realpath(path::AbstractString) -> String

Kanonisiert einen Pfad, indem symbolische Links aufgelöst und "." und ".." Einträge entfernt werden. Auf dateisystemen, die die Groß- und Kleinschreibung nicht unterscheiden und die Groß- und Kleinschreibung beibehalten (typischerweise Mac und Windows), wird die im Dateisystem gespeicherte Groß- und Kleinschreibung für den Pfad zurückgegeben.

(Diese Funktion wirft eine Ausnahme, wenn path im Dateisystem nicht existiert.)

relpath(path::AbstractString, startpath::AbstractString = ".") -> String

Gibt einen relativen Dateipfad zu path entweder vom aktuellen Verzeichnis oder von einem optionalen Startverzeichnis zurück. Dies ist eine Pfadberechnung: Das Dateisystem wird nicht aufgerufen, um die Existenz oder Art von path oder startpath zu bestätigen.

Unter Windows wird die Groß- und Kleinschreibung auf jeden Teil des Pfades angewendet, mit Ausnahme der Laufwerksbuchstaben. Wenn path und startpath auf unterschiedliche Laufwerke verweisen, wird der absolute Pfad von path zurückgegeben.

expanduser(pfad::AbstractString) -> AbstractString

Unter Unix-Systemen wird ein Tilde-Zeichen am Anfang eines Pfades durch das Home-Verzeichnis des aktuellen Benutzers ersetzt.

Siehe auch: contractuser.

contractuser(path::AbstractString) -> AbstractString

Unter Unix-Systemen, wenn der Pfad mit homedir() beginnt, ersetzen Sie ihn durch ein Tilde-Zeichen.

Siehe auch: expanduser.

samefile(path_a::AbstractString, path_b::AbstractString)

Überprüfen Sie, ob die Pfade path_a und path_b auf dieselbe vorhandene Datei oder Verzeichnis verweisen.

splitdir(pfad::AbstractString) -> (AbstractString, AbstractString)

Teile einen Pfad in ein Tupel aus dem Verzeichnisnamen und dem Dateinamen.

Beispiele

julia> splitdir("/home/myuser")
("/home", "myuser")

splitdrive(path::AbstractString) -> (AbstractString, AbstractString)

Unter Windows wird ein Pfad in den Laufwerksbuchstaben und den Pfadteil aufgeteilt. Unter Unix-Systemen ist die erste Komponente immer der leere String.

splitext(pfad::AbstractString) -> (String, String)

Wenn die letzte Komponente eines Pfades einen oder mehrere Punkte enthält, teile den Pfad in alles vor dem letzten Punkt und alles einschließlich und nach dem Punkt. Andernfalls gib ein Tupel des Arguments unverändert und den leeren String zurück. "splitext" ist die Abkürzung für "split extension".

Beispiele

julia> splitext("/home/myuser/example.jl")
("/home/myuser/example", ".jl")

julia> splitext("/home/myuser/example.tar.gz")
("/home/myuser/example.tar", ".gz")

julia> splitext("/home/my.user/example")
("/home/my.user/example", "")

splitpath(path::AbstractString) -> Vector{String}

Teile einen Dateipfad in alle seine Pfadkomponenten auf. Dies ist das Gegenteil von joinpath. Gibt ein Array von Teilstrings zurück, eines für jedes Verzeichnis oder jede Datei im Pfad, einschließlich des Wurzelverzeichnisses, falls vorhanden.

Beispiele

julia> splitpath("/home/myuser/example.jl")
4-element Vector{String}:
 "/"
 "home"
 "myuser"
 "example.jl"