Filesystem

# Filesystem

`Base.Filesystem.pwd` — Function.

    pwd() -> AbstractString

Get the current working directory.

source
`Base.Filesystem.cd` — Method.

    cd(dir::AbstractString=homedir())

Set the current working directory.

source
`Base.Filesystem.cd` — Method.

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

Temporarily changes the current working directory and applies function `f` before returning.

source
`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).

source
`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

source
`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. This function never creates more than one directory. If the directory already exists, or some intermediate directories do not exist, this function throws an error. See `mkpath` for a function which creates all required intermediate directories.

source
`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.

source
`Base.Filesystem.symlink` — Function.

    symlink(target::AbstractString, link::AbstractString)

Creates a symbolic link to `target` with the name `link`.

Note

This function raises an error under operating systems that do not support soft symbolic links, such as Windows XP.

source
`Base.Filesystem.readlink` — Function.

    readlink(path::AbstractString) -> AbstractString

Returns the target location a symbolic link `path` points to.

source
`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.

source
`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.

source
`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

source
`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.

source
`Base.Filesystem.ctime` — Function.

    ctime(file)

Equivalent to `stat(file).ctime`

source
`Base.Filesystem.mtime` — Function.

    mtime(file)

Equivalent to `stat(file).mtime`.

source
`Base.Filesystem.filemode` — Function.

    filemode(file)

Equivalent to `stat(file).mode`

source
`Base.Filesystem.filesize` — Function.

    filesize(path...)

Equivalent to `stat(file).size`.

source
`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`.

source
`Base.Filesystem.gperm` — Function.

    gperm(file)

Like `uperm` but gets the permissions of the group owning the file.

source
`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

source
`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.

source
`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.

source
`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`.

source
`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.

source
`Base.Filesystem.touch` — Function.

    touch(path::AbstractString)

Update the last-modified timestamp on a file to the current time.

source
`Base.Filesystem.tempname` — Function.

    tempname()

Generate a unique temporary file path.

source
`Base.Filesystem.tempdir` — Function.

    tempdir()

Obtain the path of a temporary directory (possibly shared with other processes).

source
`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.

source
`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.

source
`Base.Filesystem.mktempdir` — Method.

    mktempdir(parent=tempdir())

Create a temporary directory in the `parent` directory and return its path. If `parent` does not exist, throw an error.

source
`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.

source
`Base.Filesystem.isblockdev` — Function.

    isblockdev(path) -> Bool

Returns `true` if `path` is a block device, `false` otherwise.

source
`Base.Filesystem.ischardev` — Function.

    ischardev(path) -> Bool

Returns `true` if `path` is a character device, `false` otherwise.

source
`Base.Filesystem.isdir` — Function.

    isdir(path) -> Bool

Returns `true` if `path` is a directory, `false` otherwise.

source
`Base.Filesystem.isfifo` — Function.

    isfifo(path) -> Bool

Returns `true` if `path` is a FIFO, `false` otherwise.

source
`Base.Filesystem.isfile` — Function.

    isfile(path) -> Bool

Returns `true` if `path` is a regular file, `false` otherwise.

source
`Base.Filesystem.islink` — Function.

    islink(path) -> Bool

Returns `true` if `path` is a symbolic link, `false` otherwise.

source
`Base.Filesystem.ismount` — Function.

    ismount(path) -> Bool

Returns `true` if `path` is a mount point, `false` otherwise.

source
`Base.Filesystem.ispath` — Function.

    ispath(path) -> Bool

Returns `true` if `path` is a valid filesystem path, `false` otherwise.

source
`Base.Filesystem.issetgid` — Function.

    issetgid(path) -> Bool

Returns `true` if `path` has the setgid flag set, `false` otherwise.

source
`Base.Filesystem.issetuid` — Function.

    issetuid(path) -> Bool

Returns `true` if `path` has the setuid flag set, `false` otherwise.

source
`Base.Filesystem.issocket` — Function.

    issocket(path) -> Bool

Returns `true` if `path` is a socket, `false` otherwise.

source
`Base.Filesystem.issticky` — Function.

    issticky(path) -> Bool

Returns `true` if `path` has the sticky bit set, `false` otherwise.

source
`Base.Filesystem.homedir` — Function.

    homedir() -> AbstractString

Return the current user's home directory.

Note

`homedir` determines the home directory via `libuv`'s `uv_os_homedir`. For details (for example on how to specify the home directory via environment variables), see the `uv_os_homedir` documentation.

source
`Base.Filesystem.dirname` — Function.

    dirname(path::AbstractString) -> AbstractString

Get the directory part of a path.

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

See also: `basename`

source
`Base.Filesystem.basename` — Function.

    basename(path::AbstractString) -> AbstractString

Get the file name part of a path.

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

See also: `dirname`

source
`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`.

source
`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>`.

source
`@__LINE__` — Macro.

    @__LINE__ -> Int

`@__LINE__` expands to the line number of the call-site.

source
`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

source
`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

source
`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"

source
`Base.Filesystem.abspath` — Function.

    abspath(path::AbstractString) -> AbstractString

Convert a path to an absolute path by adding the current directory if necessary.

source

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

Convert a set of paths to an absolute path by joining them together and adding the current directory if necessary. Equivalent to `abspath(joinpath(path, paths...))`.

source
`Base.Filesystem.normpath` — Function.

    normpath(path::AbstractString) -> AbstractString

Normalize a path, removing "." and ".." entries.

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

source
`Base.Filesystem.realpath` — Function.

    realpath(path::AbstractString) -> AbstractString

Canonicalize a path by expanding symbolic links and removing "." and ".." entries.

source
`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`.

source
`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.

source
`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")

source
`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.

source
`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", "")

source