Filesystem

read(filename::AbstractString)

Lee todo el contenido de un archivo como un Vector{UInt8}.

read(filename::AbstractString, String)

Lee todo el contenido de un archivo como una cadena.

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

Abre un archivo y lee su contenido. args se pasa a read: esto es equivalente a open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Escribe la representación binaria canónica de content en un archivo, que se creará si aún no existe o se sobrescribirá si ya existe.

Devuelve el número de bytes escritos en el archivo.

pwd() -> String

Obtiene el directorio de trabajo actual.

Véase también: cd, tempdir.

Ejemplos

julia> pwd()
"/home/JuliaUser"

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

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

cd(dir::AbstractString=homedir())

Establece el directorio de trabajo actual.

Véase también: pwd, mkdir, mkpath, mktempdir.

Ejemplos

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

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

julia> cd()

julia> pwd()
"/home/JuliaUser"

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

Cambia temporalmente el directorio de trabajo actual a dir, aplica la función f y finalmente regresa al directorio original.

Ejemplos

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}

Devuelve los nombres en el directorio dir o el directorio de trabajo actual si no se proporciona. Cuando join es falso, readdir devuelve solo los nombres en el directorio tal como están; cuando join es verdadero, devuelve joinpath(dir, name) para cada name de modo que las cadenas devueltas sean rutas completas. Si deseas obtener rutas absolutas, llama a readdir con una ruta de directorio absoluta y join configurado en verdadero.

Por defecto, readdir ordena la lista de nombres que devuelve. Si deseas omitir el ordenamiento de los nombres y obtenerlos en el orden en que el sistema de archivos los lista, puedes usar readdir(dir, sort=false) para optar por no ordenar.

Ver también: walkdir.

Ejemplos

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)

Devuelve un iterador que recorre el árbol de directorios de un directorio. El iterador devuelve una tupla que contiene (rootpath, dirs, files). El árbol de directorios se puede recorrer de arriba hacia abajo o de abajo hacia arriba. Si walkdir o stat encuentra un IOError, volverá a lanzar el error por defecto. Se puede proporcionar una función de manejo de errores personalizada a través del argumento clave onerror. onerror se llama con un IOError como argumento.

Véase también: readdir.

Ejemplos

for (root, dirs, files) in walkdir(".")
    println("Directorios en $root")
    for dir in dirs
        println(joinpath(root, dir)) # ruta a directorios
    end
    println("Archivos en $root")
    for file in files
        println(joinpath(root, file)) # ruta a archivos
    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)

Crea un nuevo directorio con el nombre path y permisos mode. mode tiene como valor predeterminado 0o777, modificado por la máscara de creación de archivos actual. Esta función nunca crea más de un directorio. Si el directorio ya existe, o si algunos directorios intermedios no existen, esta función lanza un error. Consulta mkpath para una función que crea todos los directorios intermedios requeridos. Devuelve path.

Ejemplos

julia> mkdir("testingdir")
"testingdir"

julia> cd("testingdir")

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

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

Crea todos los directorios intermedios en el path según sea necesario. Los directorios se crean con los permisos mode, que por defecto es 0o777 y se modifica por la máscara de creación de archivos actual. A diferencia de mkdir, mkpath no genera un error si path (o partes de él) ya existe. Sin embargo, se lanzará un error si path (o partes de él) apunta a un archivo existente. Devuelve path.

Si path incluye un nombre de archivo, probablemente querrás usar mkpath(dirname(path)) para evitar crear un directorio usando el nombre del archivo.

Ejemplos

julia> cd(mktempdir())

julia> mkpath("my/test/dir") # crea tres directorios
"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") # crea dos directorios
"intermediate_dir/actually_a_directory.txt"

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

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

Crea un enlace duro a un archivo fuente existente src con el nombre dst. El destino, dst, no debe existir.

Ver también: symlink.

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

Crea un enlace simbólico a target con el nombre link.

En Windows, los enlaces simbólicos deben declararse explícitamente como referentes a un directorio o no. Si target ya existe, por defecto el tipo de link se detectará automáticamente; sin embargo, si target no existe, esta función por defecto crea un enlace simbólico de archivo a menos que dir_target se establezca en true. Ten en cuenta que si el usuario establece dir_target pero target existe y es un archivo, aún se creará un enlace simbólico de directorio, pero la desreferenciación del enlace simbólico fallará, justo como si el usuario crea un enlace simbólico de archivo (llamando a symlink() con dir_target establecido en false antes de que se cree el directorio) y trata de desreferenciarlo a un directorio.

Además, hay dos métodos para hacer un enlace en Windows; enlaces simbólicos y puntos de unión. Los puntos de unión son ligeramente más eficientes, pero no admiten rutas relativas, por lo que si se solicita un enlace simbólico de directorio relativo (como lo indica isabspath(target) devolviendo false), se utilizará un enlace simbólico, de lo contrario, se utilizará un punto de unión. La mejor práctica para crear enlaces simbólicos en Windows es crearlos solo después de que los archivos/directorios a los que hacen referencia ya estén creados.

Ver también: hardlink.

readlink(path::AbstractString) -> String

Devuelve la ubicación del objetivo a la que apunta un enlace simbólico path.

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

Cambia el modo de permisos de path a mode. Actualmente, solo se admiten modos mode enteros (por ejemplo, 0o777). Si recursive=true y la ruta es un directorio, todos los permisos en ese directorio se cambiarán recursivamente. Devuelve path.

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

Cambia el propietario y/o grupo de path a owner y/o group. Si el valor ingresado para owner o group es -1, el ID correspondiente no cambiará. Actualmente, solo se admiten owners y groups enteros. Devuelve path.

RawFD

Tipo primitivo que envuelve el descriptor de archivo nativo del sistema operativo. Los RawFD se pueden pasar a métodos como stat para descubrir información sobre el archivo subyacente, y también se pueden usar para abrir flujos, con el RawFD describiendo el archivo del sistema operativo que respalda el flujo.

stat(file)

Devuelve una estructura cuyos campos contienen información sobre el archivo. Los campos de la estructura son:

diskstat(path=pwd())

Devuelve estadísticas en bytes sobre el disco que contiene el archivo o directorio apuntado por path. Si no se pasa ningún argumento, se devuelven estadísticas sobre el disco que contiene el directorio de trabajo actual.

lstat(archivo)

Como stat, pero para enlaces simbólicos obtiene la información del enlace en sí en lugar del archivo al que se refiere. Esta función debe ser llamada en una ruta de archivo en lugar de un objeto de archivo o un descriptor de archivo.

ctime(file)

Equivalente a stat(file).ctime.

mtime(file)

Equivalente a stat(file).mtime.

filemode(file)

Equivalente a stat(file).mode.

filesize(path...)

Equivalente a stat(file).size.

uperm(file)

Obtiene los permisos del propietario del archivo como un campo de bits de

Para los argumentos permitidos, consulta stat.

gperm(file)

Como uperm pero obtiene los permisos del grupo propietario del archivo.

operm(file)

Como uperm pero obtiene los permisos para personas que no son propietarias del archivo ni son miembros del grupo propietario del archivo.

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

Copia el archivo, enlace o directorio de src a dst. force=true eliminará primero un dst existente.

Si follow_symlinks=false, y src es un enlace simbólico, dst se creará como un enlace simbólico. Si follow_symlinks=true y src es un enlace simbólico, dst será una copia del archivo o directorio al que se refiere src. Devuelve dst.

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

Descarga un archivo de la URL dada, guardándolo en la ubicación path, o si no se especifica, en una ruta temporal. Devuelve la ruta del archivo descargado.

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

Mueve el archivo, enlace o directorio de src a dst. force=true eliminará primero un dst existente. Devuelve dst.

Ejemplos

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. Se requiere `force=true` para eliminar 'goodbye.txt' antes de mover.
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)

Elimina el archivo, enlace o directorio vacío en la ruta dada. Si se pasa force=true, una ruta no existente no se trata como un error. Si se pasa recursive=true y la ruta es un directorio, entonces todo el contenido se elimina recursivamente.

Ejemplos

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)

Actualiza el mtime en el bloqueo, para indicar que sigue siendo reciente.

Consulta también la palabra clave refresh en el constructor mkpidlock.

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

Actualiza la marca de tiempo de la última modificación de un archivo a la hora actual.

Si el archivo no existe, se crea un nuevo archivo.

Devuelve path.

Ejemplos

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

Podemos ver que mtime ha sido modificado por touch.

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

Genera una ruta de archivo temporal. Esta función solo devuelve una ruta; no se crea ningún archivo. La ruta es probable que sea única, pero esto no se puede garantizar debido a la muy remota posibilidad de que dos llamadas simultáneas a tempname generen el mismo nombre de archivo. El nombre está garantizado para diferir de todos los archivos que ya existen en el momento de la llamada a tempname.

Cuando se llama sin argumentos, el nombre temporal será una ruta absoluta a un nombre temporal en el directorio temporal del sistema según lo indicado por tempdir(). Si se proporciona un argumento de directorio parent, la ruta temporal estará en ese directorio en su lugar.

La opción cleanup controla si el proceso intenta eliminar la ruta devuelta automáticamente cuando el proceso sale. Tenga en cuenta que la función tempname no crea ningún archivo o directorio en la ubicación devuelta, por lo que no hay nada que limpiar a menos que cree un archivo o directorio allí. Si lo hace y cleanup es true, se eliminará al finalizar el proceso.

tempdir()

Obtiene la ruta del directorio temporal. En Windows, tempdir() utiliza la primera variable de entorno encontrada en la lista ordenada TMP, TEMP, USERPROFILE. En todos los demás sistemas operativos, tempdir() utiliza la primera variable de entorno encontrada en la lista ordenada TMPDIR, TMP, TEMP y TEMPDIR. Si ninguna de estas se encuentra, se utiliza la ruta "/tmp".

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

Devuelve (path, io), donde path es la ruta de un nuevo archivo temporal en parent y io es un objeto de archivo abierto para esta ruta. La opción cleanup controla si el archivo temporal se elimina automáticamente cuando el proceso finaliza.

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

Aplica la función f al resultado de mktemp(parent) y elimina el archivo temporal al finalizar.

Véase también: mktempdir.

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

Crea un directorio temporal en el directorio parent con un nombre construido a partir del prefix dado y un sufijo aleatorio, y devuelve su ruta. Además, en algunas plataformas, cualquier carácter 'X' final en prefix puede ser reemplazado por caracteres aleatorios. Si parent no existe, se lanzará un error. La opción cleanup controla si el directorio temporal se elimina automáticamente cuando el proceso finaliza.

Ver también: mktemp, mkdir.

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

Aplica la función f al resultado de mktempdir(parent; prefix) y elimina el directorio temporal y todo su contenido al finalizar.

Véase también: mktemp, mkdir.

isblockdev(path) -> Bool

Devuelve true si path es un dispositivo de bloque, false en caso contrario.

ischardev(path) -> Bool

Devuelve true si path es un dispositivo de caracteres, false en caso contrario.

isdir(path) -> Bool

Devuelve true si path es un directorio, false en caso contrario.

Ejemplos

julia> isdir(homedir())
true

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

Consulta también isfile y ispath. ```

isfifo(path) -> Bool

Devuelve true si path es un FIFO, false en caso contrario.

isfile(path) -> Bool

Devuelve true si path es un archivo regular, false en caso contrario.

Ejemplos

julia> isfile(homedir())
false

julia> filename = "test_file.txt";

julia> write(filename, "¡Hola mundo!");

julia> isfile(filename)
true

julia> rm(filename);

julia> isfile(filename)
false

Consulta también isdir y ispath.

islink(path) -> Bool

Devuelve true si path es un enlace simbólico, false en caso contrario.

ismount(path) -> Bool

Devuelve true si path es un punto de montaje, false en caso contrario.

ispath(path) -> Bool

Devuelve true si existe una entidad de sistema de archivos válida en path, de lo contrario devuelve false. Esta es la generalización de isfile, isdir etc.

issetgid(path) -> Bool

Devuelve true si path tiene el flag setgid establecido, false en caso contrario.

issetuid(path) -> Bool

Devuelve true si path tiene el flag setuid establecido, false en caso contrario.

issocket(path) -> Bool

Devuelve true si path es un socket, false en caso contrario.

issticky(path) -> Bool

Devuelve true si path tiene el bit sticky establecido, false de lo contrario.

homedir() -> String

Devuelve el directorio home del usuario actual.

Consulta también Sys.username.

dirname(path::AbstractString) -> String

Obtiene la parte del directorio de una ruta. Los caracteres finales ('/' o '\') en la ruta se cuentan como parte de la ruta.

Ejemplos

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

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

Ver también basename.

basename(path::AbstractString) -> String

Obtiene la parte del nombre del archivo de una ruta.

Ejemplos

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

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

Ver también dirname.

isabspath(path::AbstractString) -> Bool

Determina si una ruta es absoluta (comienza en el directorio raíz).

Ejemplos

julia> isabspath("/home")
true

julia> isabspath("home")
false

isdirpath(path::AbstractString) -> Bool

Determina si una ruta se refiere a un directorio (por ejemplo, termina con un separador de ruta).

Ejemplos

julia> isdirpath("/home")
false

julia> isdirpath("/home/")
true

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

Une los componentes de la ruta en una ruta completa. Si algún argumento es una ruta absoluta o (en Windows) tiene una especificación de unidad que no coincide con la unidad calculada para la unión de las rutas anteriores, entonces se descartan los componentes anteriores.

Nota sobre Windows: dado que hay un directorio actual para cada unidad, joinpath("c:", "foo") representa una ruta relativa al directorio actual en la unidad "c:", por lo que esto es igual a "c:foo", no "c:\foo". Además, joinpath trata esto como una ruta no absoluta e ignora la capitalización de la letra de la unidad, por lo tanto, joinpath("C:\A","c:b") = "C:\A\b".

Ejemplos

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

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

abspath(path::AbstractString) -> String

Convierte una ruta a una ruta absoluta añadiendo el directorio actual si es necesario. También normaliza la ruta como en normpath.

Ejemplos

Si estás en un directorio llamado JuliaExample y los datos que estás utilizando están dos niveles arriba en relación con el directorio JuliaExample, podrías escribir:

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

Lo que da una ruta como "/home/JuliaUser/data/".

Consulta también joinpath, pwd, expanduser.

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

Convierte un conjunto de rutas a una ruta absoluta al unirlas y agregar el directorio actual si es necesario. Equivalente a abspath(joinpath(path, paths...)).

normpath(path::AbstractString) -> String

Normaliza una ruta, eliminando las entradas "." y ".." y cambiando "/" al separador de ruta canónico para el sistema.

Ejemplos

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

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

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

Convierte un conjunto de rutas a una ruta normalizada al unirlas y eliminar las entradas "." y "..". Equivalente a normpath(joinpath(path, paths...)).

realpath(path::AbstractString) -> String

Canonicaliza una ruta expandiendo enlaces simbólicos y eliminando entradas "." y "..". En sistemas de archivos que son insensibles a mayúsculas y conservan el caso (típicamente Mac y Windows), se devuelve el caso almacenado por el sistema de archivos para la ruta.

(Esta función lanza una excepción si path no existe en el sistema de archivos.)

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

Devuelve una ruta de archivo relativa a path ya sea desde el directorio actual o desde un directorio de inicio opcional. Este es un cálculo de ruta: no se accede al sistema de archivos para confirmar la existencia o naturaleza de path o startpath.

En Windows, la sensibilidad a mayúsculas y minúsculas se aplica a cada parte de la ruta, excepto a las letras de unidad. Si path y startpath se refieren a diferentes unidades, se devuelve la ruta absoluta de path.

expanduser(path::AbstractString) -> AbstractString

En sistemas Unix, reemplaza un carácter de tilde al inicio de una ruta con el directorio home del usuario actual.

Véase también: contractuser.

contractuser(path::AbstractString) -> AbstractString

En sistemas Unix, si la ruta comienza con homedir(), reemplázala con un carácter de tilde.

Véase también: expanduser.

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

Verifica si las rutas path_a y path_b se refieren al mismo archivo o directorio existente.

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

Divide una ruta en una tupla del nombre del directorio y el nombre del archivo.

Ejemplos

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

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

En Windows, divide una ruta en la parte de la letra de unidad y la parte de la ruta. En sistemas Unix, el primer componente es siempre la cadena vacía.

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

Si el último componente de una ruta contiene uno o más puntos, divide la ruta en todo lo que está antes del último punto y todo lo que incluye y después del punto. De lo contrario, devuelve una tupla del argumento sin modificar y la cadena vacía. "splitext" es una abreviatura de "dividir extensión".

Ejemplos

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}

Divide una ruta de archivo en todos sus componentes de ruta. Esto es lo opuesto a joinpath. Devuelve un arreglo de subcadenas, una para cada directorio o archivo en la ruta, incluyendo el directorio raíz si está presente.

Ejemplos

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