Filesystem

read(filename::AbstractString)

Lire le contenu entier d'un fichier sous forme de Vector{UInt8}.

read(filename::AbstractString, String)

Lire le contenu entier d'un fichier sous forme de chaîne.

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

Ouvrir un fichier et lire son contenu. args est passé à read : cela équivaut à open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Écrit la représentation binaire canonique de content dans un fichier, qui sera créé s'il n'existe pas encore ou écrasé s'il existe.

Retourne le nombre d'octets écrits dans le fichier.

pwd() -> String

Obtenez le répertoire de travail actuel.

Voir aussi : cd, tempdir.

Exemples

julia> pwd()
"/home/JuliaUser"

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

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

cd(dir::AbstractString=homedir())

Définir le répertoire de travail actuel.

Voir aussi : pwd, mkdir, mkpath, mktempdir.

Exemples

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

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

julia> cd()

julia> pwd()
"/home/JuliaUser"

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

Change temporairement le répertoire de travail actuel en dir, applique la fonction f et retourne finalement au répertoire d'origine.

Exemples

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}

Renvoie les noms dans le répertoire dir ou le répertoire de travail actuel si aucun n'est donné. Lorsque join est faux, readdir renvoie simplement les noms dans le répertoire tels quels ; lorsque join est vrai, il renvoie joinpath(dir, name) pour chaque name afin que les chaînes renvoyées soient des chemins complets. Si vous souhaitez obtenir des chemins absolus, appelez readdir avec un chemin de répertoire absolu et join défini sur vrai.

Par défaut, readdir trie la liste des noms qu'il renvoie. Si vous souhaitez ignorer le tri des noms et les obtenir dans l'ordre dans lequel le système de fichiers les liste, vous pouvez utiliser readdir(dir, sort=false) pour ne pas trier.

Voir aussi : walkdir.

Exemples

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)

Renvoie un itérateur qui parcourt l'arborescence des répertoires d'un répertoire. L'itérateur renvoie un tuple contenant (rootpath, dirs, files). L'arborescence des répertoires peut être parcourue de haut en bas ou de bas en haut. Si walkdir ou stat rencontre une IOError, il relancera l'erreur par défaut. Une fonction de gestion des erreurs personnalisée peut être fournie via l'argument clé onerror. onerror est appelé avec une IOError comme argument.

Voir aussi : readdir.

Exemples

for (root, dirs, files) in walkdir(".")
    println("Répertoires dans $root")
    for dir in dirs
        println(joinpath(root, dir)) # chemin vers les répertoires
    end
    println("Fichiers dans $root")
    for file in files
        println(joinpath(root, file)) # chemin vers les fichiers
    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)

Créez un nouveau répertoire avec le nom path et les permissions mode. mode par défaut est 0o777, modifié par le masque de création de fichiers actuel. Cette fonction ne crée jamais plus d'un répertoire. Si le répertoire existe déjà, ou si certains répertoires intermédiaires n'existent pas, cette fonction lance une erreur. Voir mkpath pour une fonction qui crée tous les répertoires intermédiaires requis. Retourne path.

Exemples

julia> mkdir("testingdir")
"testingdir"

julia> cd("testingdir")

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

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

Créez tous les répertoires intermédiaires dans le path selon les besoins. Les répertoires sont créés avec les permissions mode qui par défaut est 0o777 et est modifié par le masque de création de fichiers actuel. Contrairement à mkdir, mkpath ne renvoie pas d'erreur si path (ou des parties de celui-ci) existe déjà. Cependant, une erreur sera lancée si path (ou des parties de celui-ci) pointe vers un fichier existant. Retourne path.

Si path inclut un nom de fichier, vous voudrez probablement utiliser mkpath(dirname(path)) pour éviter de créer un répertoire en utilisant le nom de fichier.

Exemples

julia> cd(mktempdir())

julia> mkpath("my/test/dir") # crée trois répertoires
"my/test/dir"

julia> readdir()
1-élément Array{String,1}:
 "my"

julia> cd("my")

julia> readdir()
1-élément Array{String,1}:
 "test"

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

julia> mkpath("intermediate_dir/actually_a_directory.txt") # crée deux répertoires
"intermediate_dir/actually_a_directory.txt"

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

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

Crée un lien dur vers un fichier source existant src avec le nom dst. La destination, dst, ne doit pas exister.

Voir aussi : symlink.

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

Crée un lien symbolique vers target avec le nom link.

Sous Windows, les liens symboliques doivent être explicitement déclarés comme se référant à un répertoire ou non. Si target existe déjà, par défaut le type de link sera détecté automatiquement, cependant si target n'existe pas, cette fonction crée par défaut un lien symbolique de fichier à moins que dir_target ne soit défini sur true. Notez que si l'utilisateur définit dir_target mais que target existe et est un fichier, un lien symbolique de répertoire sera tout de même créé, mais la désignation du lien symbolique échouera, tout comme si l'utilisateur crée un lien symbolique de fichier (en appelant symlink() avec dir_target défini sur false avant que le répertoire ne soit créé) et essaie de le désigner vers un répertoire.

De plus, il existe deux méthodes pour créer un lien sous Windows : les liens symboliques et les points de jonction. Les points de jonction sont légèrement plus efficaces, mais ne prennent pas en charge les chemins relatifs, donc si un lien symbolique de répertoire relatif est demandé (comme indiqué par isabspath(target) retournant false), un lien symbolique sera utilisé, sinon un point de jonction sera utilisé. La meilleure pratique pour créer des liens symboliques sous Windows est de les créer uniquement après que les fichiers/répertoires auxquels ils font référence ont déjà été créés.

Voir aussi : hardlink.

readlink(path::AbstractString) -> String

Renvoie l'emplacement cible vers lequel un lien symbolique path pointe.

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

Changez le mode de permissions de path à mode. Seuls les modes entiers (par exemple 0o777) sont actuellement pris en charge. Si recursive=true et que le chemin est un répertoire, toutes les permissions dans ce répertoire seront modifiées de manière récursive. Retournez path.

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

Change le propriétaire et/ou le groupe de path en owner et/ou group. Si la valeur saisie pour owner ou group est -1, l'ID correspondant ne changera pas. Seuls les owners et groups de type entier sont actuellement pris en charge. Retourne path.

RawFD

Type primitif qui enveloppe le descripteur de fichier natif du système d'exploitation. Les RawFD peuvent être passés à des méthodes comme stat pour découvrir des informations sur le fichier sous-jacent, et peuvent également être utilisés pour ouvrir des flux, le RawFD décrivant le fichier du système d'exploitation soutenant le flux.

stat(file)

Renvoie une structure dont les champs contiennent des informations sur le fichier. Les champs de la structure sont :

diskstat(path=pwd())

Renvoie des statistiques en octets sur le disque qui contient le fichier ou le répertoire pointé par path. Si aucun argument n'est passé, des statistiques sur le disque qui contient le répertoire de travail actuel sont renvoyées.

lstat(fichier)

Comme stat, mais pour les liens symboliques, obtient les informations pour le lien lui-même plutôt que pour le fichier auquel il fait référence. Cette fonction doit être appelée sur un chemin de fichier plutôt que sur un objet fichier ou un descripteur de fichier.

ctime(fichier)

Équivalent à stat(fichier).ctime.

mtime(fichier)

Équivalent à stat(fichier).mtime.

filemode(fichier)

Équivalent à stat(fichier).mode.

filesize(chemin...)

Équivalent à stat(fichier).size.

uperm(fichier)

Obtenez les permissions du propriétaire du fichier sous forme de champ de bits

Pour les arguments autorisés, voir stat.

gperm(file)

Comme uperm mais obtient les permissions du groupe propriétaire du fichier.

operm(fichier)

Comme uperm mais obtient les permissions pour les personnes qui ne possèdent pas le fichier et ne sont pas membres du groupe possédant le fichier.

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

Copie le fichier, le lien ou le répertoire de src vers dst. force=true supprimera d'abord un dst existant.

Si follow_symlinks=false, et que src est un lien symbolique, dst sera créé en tant que lien symbolique. Si follow_symlinks=true et que src est un lien symbolique, dst sera une copie du fichier ou du répertoire auquel src fait référence. Retourne dst.

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

Télécharge un fichier à partir de l'URL donnée, en le sauvegardant à l'emplacement path, ou si non spécifié, à un chemin temporaire. Renvoie le chemin du fichier téléchargé.

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

Déplace le fichier, le lien ou le répertoire de src vers dst. force=true supprimera d'abord un dst existant. Retourne dst.

Exemples

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' existe. `force=true` est requis pour supprimer 'goodbye.txt' avant de déplacer.
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)

Supprime le fichier, le lien ou le répertoire vide à l'emplacement donné. Si force=true est passé, un chemin non existant n'est pas considéré comme une erreur. Si recursive=true est passé et que le chemin est un répertoire, alors tout le contenu est supprimé de manière récursive.

Exemples

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)

Met à jour le mtime sur le verrou, pour indiquer qu'il est toujours frais.

Voir aussi le mot-clé refresh dans le constructeur mkpidlock.

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

Met à jour l'horodatage de dernière modification d'un fichier à l'heure actuelle.

Si le fichier n'existe pas, un nouveau fichier est créé.

Retourne path.

Exemples

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

Nous pouvons voir que mtime a été modifié par touch.

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

Génère un chemin de fichier temporaire. Cette fonction ne renvoie qu'un chemin ; aucun fichier n'est créé. Le chemin est susceptible d'être unique, mais cela ne peut pas être garanti en raison de la très faible possibilité que deux appels simultanés à tempname génèrent le même nom de fichier. Le nom est garanti de différer de tous les fichiers déjà existants au moment de l'appel à tempname.

Lorsqu'il est appelé sans arguments, le nom temporaire sera un chemin absolu vers un nom temporaire dans le répertoire temporaire du système tel que donné par tempdir(). Si un argument de répertoire parent est donné, le chemin temporaire sera dans ce répertoire à la place.

L'option cleanup contrôle si le processus tente de supprimer automatiquement le chemin renvoyé lorsque le processus se termine. Notez que la fonction tempname ne crée aucun fichier ou répertoire à l'emplacement renvoyé, donc il n'y a rien à nettoyer à moins que vous ne créiez un fichier ou un répertoire là-bas. Si vous le faites et que cleanup est true, il sera supprimé à la fin du processus.

tempdir()

Obtient le chemin du répertoire temporaire. Sur Windows, tempdir() utilise la première variable d'environnement trouvée dans la liste ordonnée TMP, TEMP, USERPROFILE. Sur tous les autres systèmes d'exploitation, tempdir() utilise la première variable d'environnement trouvée dans la liste ordonnée TMPDIR, TMP, TEMP et TEMPDIR. Si aucune de ces variables n'est trouvée, le chemin "/tmp" est utilisé.

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

Retourne (path, io), où path est le chemin d'un nouveau fichier temporaire dans parent et io est un objet de fichier ouvert pour ce chemin. L'option cleanup contrôle si le fichier temporaire est automatiquement supprimé lorsque le processus se termine.

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

Appliquez la fonction f au résultat de mktemp(parent) et supprimez le fichier temporaire une fois terminé.

Voir aussi : mktempdir.

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

Crée un répertoire temporaire dans le répertoire parent avec un nom construit à partir du prefix donné et d'un suffixe aléatoire, et retourne son chemin. De plus, sur certaines plateformes, tout caractère 'X' final dans prefix peut être remplacé par des caractères aléatoires. Si parent n'existe pas, une erreur est levée. L'option cleanup contrôle si le répertoire temporaire est automatiquement supprimé lorsque le processus se termine.

Voir aussi : mktemp, mkdir.

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

Appliquez la fonction f au résultat de mktempdir(parent; prefix) et supprimez le répertoire temporaire ainsi que tout son contenu une fois terminé.

Voir aussi : mktemp, mkdir.

isblockdev(path) -> Bool

Retourne true si path est un périphérique de bloc, false sinon.

ischardev(path) -> Bool

Retourne true si path est un périphérique de caractère, false sinon.

isdir(path) -> Bool

Retourne true si path est un répertoire, false sinon.

Exemples

julia> isdir(homedir())
true

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

Voir aussi isfile et ispath.

isfifo(path) -> Bool

Retourne true si path est un FIFO, false sinon.

isfile(path) -> Bool

Retourne true si path est un fichier régulier, false sinon.

Exemples

julia> isfile(homedir())
false

julia> filename = "test_file.txt";

julia> write(filename, "Hello world!");

julia> isfile(filename)
true

julia> rm(filename);

julia> isfile(filename)
false

Voir aussi isdir et ispath.

islink(path) -> Bool

Retourne true si path est un lien symbolique, false sinon.

ismount(path) -> Bool

Retourne true si path est un point de montage, false sinon.

ispath(path) -> Bool

Retourne true si une entité de système de fichiers valide existe à path, sinon retourne false. C'est la généralisation de isfile, isdir etc.

issetgid(path) -> Bool

Retourne true si path a le drapeau setgid activé, false sinon.

issetuid(path) -> Bool

Retourne true si path a le drapeau setuid activé, false sinon.

issocket(path) -> Bool

Retourne true si path est un socket, false sinon.

issticky(path) -> Bool

Retourne true si path a le bit collant activé, false sinon.

homedir() -> String

Renvoie le répertoire personnel de l'utilisateur actuel.

Voir aussi Sys.username.

dirname(path::AbstractString) -> String

Obtenez la partie répertoire d'un chemin. Les caractères de fin ('/' ou '\') dans le chemin sont comptés comme faisant partie du chemin.

Exemples

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

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

Voir aussi basename.

basename(path::AbstractString) -> String

Obtenez la partie nom de fichier d'un chemin.

Exemples

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

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

Voir aussi dirname.

isabspath(path::AbstractString) -> Bool

Déterminez si un chemin est absolu (commence à partir du répertoire racine).

Exemples

julia> isabspath("/home")
true

julia> isabspath("home")
false

isdirpath(path::AbstractString) -> Bool

Déterminez si un chemin fait référence à un répertoire (par exemple, se termine par un séparateur de chemin).

Exemples

julia> isdirpath("/home")
false

julia> isdirpath("/home/")
true

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

Joindre des composants de chemin en un chemin complet. Si un argument est un chemin absolu ou (sur Windows) a une spécification de lecteur qui ne correspond pas au lecteur calculé pour la jonction des chemins précédents, alors les composants précédents sont supprimés.

Note sur Windows, puisque chaque lecteur a un répertoire courant, joinpath("c:", "foo") représente un chemin relatif au répertoire courant sur le lecteur "c:", donc cela est égal à "c:foo", pas "c:\foo". De plus, joinpath traite cela comme un chemin non absolu et ignore la casse de la lettre du lecteur, donc joinpath("C:\A","c:b") = "C:\A\b".

Exemples

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

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

abspath(path::AbstractString) -> String

Convertit un chemin en un chemin absolu en ajoutant le répertoire actuel si nécessaire. Normalise également le chemin comme dans normpath.

Exemples

Si vous êtes dans un répertoire appelé JuliaExample et que les données que vous utilisez se trouvent deux niveaux au-dessus par rapport au répertoire JuliaExample, vous pourriez écrire :

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

Ce qui donne un chemin comme "/home/JuliaUser/data/".

Voir aussi joinpath, pwd, expanduser.

abspath(path::AbstractString, paths::AbstractString...) -> String

Convertir un ensemble de chemins en un chemin absolu en les joignant ensemble et en ajoutant le répertoire courant si nécessaire. Équivalent à abspath(joinpath(path, paths...)).

normpath(path::AbstractString) -> String

Normaliser un chemin, en supprimant les entrées "." et ".." et en changeant "/" par le séparateur de chemin canonique pour le système.

Exemples

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

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

normpath(path::AbstractString, paths::AbstractString...) -> String

Convertir un ensemble de chemins en un chemin normalisé en les joignant ensemble et en supprimant les entrées "." et "..". Équivalent à normpath(joinpath(path, paths...)).

realpath(path::AbstractString) -> String

Canonicaliser un chemin en développant les liens symboliques et en supprimant les entrées "." et "..". Sur les systèmes de fichiers insensibles à la casse et préservant la casse (typiquement Mac et Windows), la casse stockée par le système de fichiers pour le chemin est renvoyée.

(Cette fonction lance une exception si path n'existe pas dans le système de fichiers.)

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

Renvoie un chemin de fichier relatif à path soit depuis le répertoire actuel, soit depuis un répertoire de départ optionnel. Il s'agit d'un calcul de chemin : le système de fichiers n'est pas accédé pour confirmer l'existence ou la nature de path ou startpath.

Sous Windows, la sensibilité à la casse est appliquée à chaque partie du chemin sauf pour les lettres de lecteur. Si path et startpath se réfèrent à des lecteurs différents, le chemin absolu de path est renvoyé.

expanduser(path::AbstractString) -> AbstractString

Sur les systèmes Unix, remplacez un caractère tilde au début d'un chemin par le répertoire personnel de l'utilisateur actuel.

Voir aussi : contractuser.

contractuser(path::AbstractString) -> AbstractString

Sur les systèmes Unix, si le chemin commence par homedir(), remplacez-le par un caractère tilde.

Voir aussi : expanduser.

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

Vérifiez si les chemins path_a et path_b font référence au même fichier ou répertoire existant.

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

Divise un chemin en un tuple contenant le nom du répertoire et le nom du fichier.

Exemples

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

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

Sur Windows, divise un chemin en la partie de la lettre de lecteur et la partie du chemin. Sur les systèmes Unix, le premier composant est toujours la chaîne vide.

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

Si le dernier composant d'un chemin contient un ou plusieurs points, divisez le chemin en tout ce qui se trouve avant le dernier point et tout ce qui inclut et après le point. Sinon, renvoyez un tuple de l'argument non modifié et de la chaîne vide. "splitext" est l'abréviation de "split extension".

Exemples

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}

Divise un chemin de fichier en tous ses composants de chemin. C'est l'opposé de joinpath. Renvoie un tableau de sous-chaînes, une pour chaque répertoire ou fichier dans le chemin, y compris le répertoire racine s'il est présent.

Exemples

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