Filesystem
Base.Filesystem.pwd
— Function.pwd() -> AbstractString
Get the current working directory.
Base.Filesystem.cd
— Method.cd(dir::AbstractString=homedir())
Set the current working directory.
Base.Filesystem.cd
— Method.cd(f::Function, dir::AbstractString=homedir())
Temporarily changes the current working directory and applies function f
before returning.
Base.Filesystem.readdir
— Function.readdir(dir::AbstractString=".") -> Vector{String}
Returns the files and directories in the directory dir
(or the current working directory if not given).
Base.Filesystem.walkdir
— Function.walkdir(dir; topdown=true, follow_symlinks=false, onerror=throw)
The walkdir
method returns an iterator that walks the directory tree of a directory. The iterator returns a tuple containing (rootpath, dirs, files)
. The directory tree can be traversed top-down or bottom-up. If walkdir
encounters a SystemError
it will rethrow the error by default. A custom error handling function can be provided through onerror
keyword argument. onerror
is called with a SystemError
as argument.
for (root, dirs, files) in walkdir(".")
println("Directories in $root")
for dir in dirs
println(joinpath(root, dir)) # path to directories
end
println("Files in $root")
for file in files
println(joinpath(root, file)) # path to files
end
end
Base.Filesystem.mkdir
— Function.mkdir(path::AbstractString, mode::Unsigned=0o777)
Make a new directory with name path
and permissions mode
. mode
defaults to 0o777
, modified by the current file creation mask.
Base.Filesystem.mkpath
— Function.mkpath(path::AbstractString, mode::Unsigned=0o777)
Create all directories in the given path
, with permissions mode
. mode
defaults to 0o777
, modified by the current file creation mask.
Base.Filesystem.symlink
— Function.symlink(target::AbstractString, link::AbstractString)
Creates a symbolic link to target
with the name link
.
This function raises an error under operating systems that do not support soft symbolic links, such as Windows XP.
Base.Filesystem.readlink
— Function.readlink(path::AbstractString) -> AbstractString
Returns the target location a symbolic link path
points to.
Base.Filesystem.chmod
— Function.chmod(path::AbstractString, mode::Integer; recursive::Bool=false)
Change the permissions mode of path
to mode
. Only integer mode
s (e.g. 0o777
) are currently supported. If recursive=true
and the path is a directory all permissions in that directory will be recursively changed.
Base.Filesystem.chown
— Function.chown(path::AbstractString, owner::Integer, group::Integer=-1)
Change the owner and/or group of path
to owner
and/or group
. If the value entered for owner
or group
is -1
the corresponding ID will not change. Only integer owner
s and group
s are currently supported.
Base.stat
— Function.stat(file)
Returns a structure whose fields contain information about the file. The fields of the structure are:
Name | Description |
---|---|
size | The size (in bytes) of the file |
device | ID of the device that contains the file |
inode | The inode number of the file |
mode | The protection mode of the file |
nlink | The number of hard links to the file |
uid | The user id of the owner of the file |
gid | The group id of the file owner |
rdev | If this file refers to a device, the ID of the device it refers to |
blksize | The file-system preferred block size for the file |
blocks | The number of such blocks allocated |
mtime | Unix timestamp of when the file was last modified |
ctime | Unix timestamp of when the file was created |
Base.Filesystem.lstat
— Function.lstat(file)
Like stat
, but for symbolic links gets the info for the link itself rather than the file it refers to. This function must be called on a file path rather than a file object or a file descriptor.
Base.Filesystem.ctime
— Function.ctime(file)
Equivalent to stat(file).ctime
Base.Filesystem.mtime
— Function.mtime(file)
Equivalent to stat(file).mtime
.
Base.Filesystem.filemode
— Function.filemode(file)
Equivalent to stat(file).mode
Base.Filesystem.filesize
— Function.filesize(path...)
Equivalent to stat(file).size
.
Base.Filesystem.uperm
— Function.uperm(file)
Gets the permissions of the owner of the file as a bitfield of
Value | Description |
---|---|
01 | Execute Permission |
02 | Write Permission |
04 | Read Permission |
For allowed arguments, see stat
.
Base.Filesystem.gperm
— Function.gperm(file)
Like uperm
but gets the permissions of the group owning the file.
Base.Filesystem.operm
— Function.operm(file)
Like uperm
but gets the permissions for people who neither own the file nor are a member of the group owning the file
Base.Filesystem.cp
— Function.cp(src::AbstractString, dst::AbstractString; remove_destination::Bool=false, follow_symlinks::Bool=false)
Copy the file, link, or directory from src
to dest
. remove_destination=true
will first remove an existing dst
.
If follow_symlinks=false
, and src
is a symbolic link, dst
will be created as a symbolic link. If follow_symlinks=true
and src
is a symbolic link, dst
will be a copy of the file or directory src
refers to.
Base.download
— Function.download(url::AbstractString, [localfile::AbstractString])
Download a file from the given url, optionally renaming it to the given local file name. Note that this function relies on the availability of external tools such as curl
, wget
or fetch
to download the file and is provided for convenience. For production use or situations in which more options are needed, please use a package that provides the desired functionality instead.
Base.Filesystem.mv
— Function.mv(src::AbstractString, dst::AbstractString; remove_destination::Bool=false)
Move the file, link, or directory from src
to dst
. remove_destination=true
will first remove an existing dst
.
Base.Filesystem.rm
— Function.rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
Delete the file, link, or empty directory at the given path. If force=true
is passed, a non-existing path is not treated as error. If recursive=true
is passed and the path is a directory, then all contents are removed recursively.
Base.Filesystem.touch
— Function.touch(path::AbstractString)
Update the last-modified timestamp on a file to the current time.
Base.Filesystem.tempname
— Function.tempname()
Generate a unique temporary file path.
Base.Filesystem.tempdir
— Function.tempdir()
Obtain the path of a temporary directory (possibly shared with other processes).
Base.Filesystem.mktemp
— Method.mktemp(parent=tempdir())
Returns (path, io)
, where path
is the path of a new temporary file in parent
and io
is an open file object for this path.
Base.Filesystem.mktemp
— Method.mktemp(f::Function, parent=tempdir())
Apply the function f
to the result of mktemp(parent)
and remove the temporary file upon completion.
Base.Filesystem.mktempdir
— Method.mktempdir(parent=tempdir())
Create a temporary directory in the parent
directory and return its path.
Base.Filesystem.mktempdir
— Method.mktempdir(f::Function, parent=tempdir())
Apply the function f
to the result of mktempdir(parent)
and remove the temporary directory upon completion.
Base.Filesystem.isblockdev
— Function.isblockdev(path) -> Bool
Returns true
if path
is a block device, false
otherwise.
Base.Filesystem.ischardev
— Function.ischardev(path) -> Bool
Returns true
if path
is a character device, false
otherwise.
Base.Filesystem.isdir
— Function.isdir(path) -> Bool
Returns true
if path
is a directory, false
otherwise.
Base.Filesystem.isfifo
— Function.isfifo(path) -> Bool
Returns true
if path
is a FIFO, false
otherwise.
Base.Filesystem.isfile
— Function.isfile(path) -> Bool
Returns true
if path
is a regular file, false
otherwise.
Base.Filesystem.islink
— Function.islink(path) -> Bool
Returns true
if path
is a symbolic link, false
otherwise.
Base.Filesystem.ismount
— Function.ismount(path) -> Bool
Returns true
if path
is a mount point, false
otherwise.
Base.Filesystem.ispath
— Function.ispath(path) -> Bool
Returns true
if path
is a valid filesystem path, false
otherwise.
Base.Filesystem.issetgid
— Function.issetgid(path) -> Bool
Returns true
if path
has the setgid flag set, false
otherwise.
Base.Filesystem.issetuid
— Function.issetuid(path) -> Bool
Returns true
if path
has the setuid flag set, false
otherwise.
Base.Filesystem.issocket
— Function.issocket(path) -> Bool
Returns true
if path
is a socket, false
otherwise.
Base.Filesystem.issticky
— Function.issticky(path) -> Bool
Returns true
if path
has the sticky bit set, false
otherwise.
Base.Filesystem.homedir
— Function.homedir() -> AbstractString
Return the current user's home directory.
Base.Filesystem.dirname
— Function.dirname(path::AbstractString) -> AbstractString
Get the directory part of a path.
julia> dirname("/home/myuser")
"/home"
Base.Filesystem.basename
— Function.basename(path::AbstractString) -> AbstractString
Get the file name part of a path.
julia> basename("/home/myuser/example.jl")
"example.jl"
Base.@__FILE__
— Macro.@__FILE__ -> AbstractString
@__FILE__
expands to a string with the absolute file path of the file containing the macro. Returns nothing
if run from a REPL or an empty string if evaluated by julia -e <expr>
. Alternatively see PROGRAM_FILE
.
Base.@__DIR__
— Macro.@__DIR__ -> AbstractString
@__DIR__
expands to a string with the directory part of the absolute path of the file containing the macro. Returns nothing
if run from a REPL or an empty string if evaluated by julia -e <expr>
.
@__LINE__
— Macro.@__LINE__ -> Int
@__LINE__
expands to the line number of the call-site.
Base.Filesystem.isabspath
— Function.isabspath(path::AbstractString) -> Bool
Determines whether a path is absolute (begins at the root directory).
julia> isabspath("/home")
true
julia> isabspath("home")
false
Base.Filesystem.isdirpath
— Function.isdirpath(path::AbstractString) -> Bool
Determines whether a path refers to a directory (for example, ends with a path separator).
julia> isdirpath("/home")
false
julia> isdirpath("/home/")
true
Base.Filesystem.joinpath
— Function.joinpath(parts...) -> AbstractString
Join path components into a full path. If some argument is an absolute path, then prior components are dropped.
julia> joinpath("/home/myuser","example.jl")
"/home/myuser/example.jl"
Base.Filesystem.abspath
— Function.abspath(path::AbstractString) -> AbstractString
Convert a path to an absolute path by adding the current directory if necessary.
Base.Filesystem.normpath
— Function.normpath(path::AbstractString) -> AbstractString
Normalize a path, removing "." and ".." entries.
julia> normpath("/home/myuser/../example.jl")
"/home/example.jl"
Base.Filesystem.realpath
— Function.realpath(path::AbstractString) -> AbstractString
Canonicalize a path by expanding symbolic links and removing "." and ".." entries.
Base.Filesystem.relpath
— Function.relpath(path::AbstractString, startpath::AbstractString = ".") -> AbstractString
Return a relative filepath to path
either from the current directory or from an optional start directory. This is a path computation: the filesystem is not accessed to confirm the existence or nature of path
or startpath
.
Base.Filesystem.expanduser
— Function.expanduser(path::AbstractString) -> AbstractString
On Unix systems, replace a tilde character at the start of a path with the current user's home directory.
Base.Filesystem.splitdir
— Function.splitdir(path::AbstractString) -> (AbstractString, AbstractString)
Split a path into a tuple of the directory name and file name.
julia> splitdir("/home/myuser")
("/home", "myuser")
Base.Filesystem.splitdrive
— Function.splitdrive(path::AbstractString) -> (AbstractString, AbstractString)
On Windows, split a path into the drive letter part and the path part. On Unix systems, the first component is always the empty string.
Base.Filesystem.splitext
— Function.splitext(path::AbstractString) -> (AbstractString, AbstractString)
If the last component of a path contains a dot, split the path into everything before the dot and everything including and after the dot. Otherwise, return a tuple of the argument unmodified and the empty string.
julia> splitext("/home/myuser/example.jl")
("/home/myuser/example", ".jl")
julia> splitext("/home/myuser/example")
("/home/myuser/example", "")