Filesystem

Base.Filesystem.pwd — Function

  1. pwd() -> AbstractString

Get the current working directory.

Examples

  1. julia> pwd()
  2. "/home/JuliaUser"
  4. julia> cd("/home/JuliaUser/Projects/julia")
  6. julia> pwd()
  7. "/home/JuliaUser/Projects/julia"

source

Base.Filesystem.cd — Method

  1. cd(dir::AbstractString=homedir())

Set the current working directory.

Examples

  1. julia> cd("/home/JuliaUser/Projects/julia")
  3. julia> pwd()
  4. "/home/JuliaUser/Projects/julia"
  6. julia> cd()
  8. julia> pwd()
  9. "/home/JuliaUser"

source

Base.Filesystem.cd — Method

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

Temporarily change the current working directory to dir, apply function f and finally return to the original directory.

Examples

  1. julia> pwd()
  2. "/home/JuliaUser"
  4. julia> cd(readdir, "/home/JuliaUser/Projects/julia")
  5. 34-element Array{String,1}:
  6.  ".circleci"
  7.  ".freebsdci.sh"
  8.  ".git"
  9.  ".gitattributes"
  10.  ".github"
  11.  ⋮
  12.  "test"
  13.  "ui"
  14.  "usr"
  15.  "usr-staging"
  17. julia> pwd()
  18. "/home/JuliaUser"

source

Base.Filesystem.readdir — Function

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

Return the names in the directory dir or the current working directory if not given. When join is false, readdir returns just the names in the directory as is; when join is true, it returns joinpath(dir, name) for each name so that the returned strings are full paths. If you want to get absolute paths back, call readdir with an absolute directory path and join set to true.

By default, readdir sorts the list of names it returns. If you want to skip sorting the names and get them in the order that the file system lists them, you can use readir(dir, sort=false) to opt out of sorting.

Julia 1.4

The join and sort keyword arguments require at least Julia 1.4.

Examples

  1. julia> cd("/home/JuliaUser/dev/julia")
  3. julia> readdir()
  4. 30-element Array{String,1}:
  5.  ".appveyor.yml"
  6.  ".git"
  7.  ".gitattributes"
  8.  ⋮
  9.  "ui"
  10.  "usr"
  11.  "usr-staging"
  13. julia> readdir(join=true)
  14. 30-element Array{String,1}:
  15.  "/home/JuliaUser/dev/julia/.appveyor.yml"
  16.  "/home/JuliaUser/dev/julia/.git"
  17.  "/home/JuliaUser/dev/julia/.gitattributes"
  18.  ⋮
  19.  "/home/JuliaUser/dev/julia/ui"
  20.  "/home/JuliaUser/dev/julia/usr"
  21.  "/home/JuliaUser/dev/julia/usr-staging"
  23. julia> readdir("base")
  24. 145-element Array{String,1}:
  25.  ".gitignore"
  26.  "Base.jl"
  27.  "Enums.jl"
  28.  ⋮
  29.  "version_git.sh"
  30.  "views.jl"
  31.  "weakkeydict.jl"
  33. julia> readdir("base", join=true)
  34. 145-element Array{String,1}:
  35.  "base/.gitignore"
  36.  "base/Base.jl"
  37.  "base/Enums.jl"
  38.  ⋮
  39.  "base/version_git.sh"
  40.  "base/views.jl"
  41.  "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”

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L699-L772)
  4. [`Base.Filesystem.walkdir`](#Base.Filesystem.walkdir) — Function

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

  2. Return 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`]($24af525c4e2127d3.md#Base.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.
  4. **Examples**

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

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[])

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L801-L840)
  4. [`Base.Filesystem.mkdir`](#Base.Filesystem.mkdir) — Function

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

  2. 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`](#Base.Filesystem.mkpath) for a function which creates all required intermediate directories. Return `path`.
  4. **Examples**

julia> mkdir(“testingdir”) “testingdir”

julia> cd(“testingdir”)

julia> pwd() “/home/JuliaUser/testingdir”

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L148-L168)
  4. [`Base.Filesystem.mkpath`](#Base.Filesystem.mkpath) — Function

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

  2. Create all directories in the given `path`, with permissions `mode`. `mode` defaults to `0o777`, modified by the current file creation mask. Return `path`.
  4. **Examples**

julia> mkdir(“testingdir”) “testingdir”

julia> cd(“testingdir”)

julia> pwd() “/home/JuliaUser/testingdir”

julia> mkpath(“my/test/dir”) “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”

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L186-L220)
  4. [`Base.Filesystem.symlink`](#Base.Filesystem.symlink) — Function

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

  2. Creates a symbolic link to `target` with the name `link`.
  4. Note
  6. This function raises an error under operating systems that do not support soft symbolic links, such as Windows XP.
  8. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L930-L938)
  10. [`Base.Filesystem.readlink`](#Base.Filesystem.readlink) — Function

readlink(path::AbstractString) -> AbstractString

  2. Return the target location a symbolic link `path` points to.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L961-L965)
  6. [`Base.Filesystem.chmod`](#Base.Filesystem.chmod) — Function

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

  2. 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. Return `path`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L985-L992)
  6. [`Base.Filesystem.chown`](#Base.Filesystem.chown) — Function

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

  2. 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. Return `path`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L1006-L1012)
  6. [`Base.Libc.RawFD`](#Base.Libc.RawFD) — Type

RawFD

  2. Primitive type which wraps the native OS file descriptor. `RawFD`s can be passed to methods like [`stat`](#Base.stat) to discover information about the underlying file, and can also be used to open streams, with the `RawFD` describing the OS file backing the stream.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/libc.jl#L22-L30)
  6. [`Base.stat`](#Base.stat) — Function

stat(file)

  2. Returns a structure whose fields contain information about the file. The fields of the structure are:
  4. <table><tbody><tr><th>Name</th><th>Description</th></tr><tr><td>size</td><td>The size (in bytes) of the file</td></tr><tr><td>device</td><td>ID of the device that contains the file</td></tr><tr><td>inode</td><td>The inode number of the file</td></tr><tr><td>mode</td><td>The protection mode of the file</td></tr><tr><td>nlink</td><td>The number of hard links to the file</td></tr><tr><td>uid</td><td>The user id of the owner of the file</td></tr><tr><td>gid</td><td>The group id of the file owner</td></tr><tr><td>rdev</td><td>If this file refers to a device, the ID of the device it refers to</td></tr><tr><td>blksize</td><td>The file-system preferred block size for the file</td></tr><tr><td>blocks</td><td>The number of such blocks allocated</td></tr><tr><td>mtime</td><td>Unix timestamp of when the file was last modified</td></tr><tr><td>ctime</td><td>Unix timestamp of when the file was created</td></tr></tbody></table>
  6. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L87-L108)
  8. [`Base.Filesystem.lstat`](#Base.Filesystem.lstat) — Function

lstat(file)

  2. Like [`stat`](#Base.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.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L111-L118)
  6. [`Base.Filesystem.ctime`](#Base.Filesystem.ctime) — Function

ctime(file)

  2. Equivalent to `stat(file).ctime`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L144-L148)
  6. [`Base.Filesystem.mtime`](#Base.Filesystem.mtime) — Function

mtime(file)

  2. Equivalent to `stat(file).mtime`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L137-L141)
  6. [`Base.Filesystem.filemode`](#Base.Filesystem.filemode) — Function

filemode(file)

  2. Equivalent to `stat(file).mode`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L123-L127)
  6. [`Base.Filesystem.filesize`](#Base.Filesystem.filesize) — Function

filesize(path…)

  2. Equivalent to `stat(file).size`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L130-L134)
  6. [`Base.Filesystem.uperm`](#Base.Filesystem.uperm) — Function

uperm(file)

  2. Get the permissions of the owner of the file as a bitfield of
  4. <table><tbody><tr><th>Value</th><th>Description</th></tr><tr><td>01</td><td>Execute Permission</td></tr><tr><td>02</td><td>Write Permission</td></tr><tr><td>04</td><td>Read Permission</td></tr></tbody></table>
  6. For allowed arguments, see [`stat`](#Base.stat).
  8. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L260-L272)
  10. [`Base.Filesystem.gperm`](#Base.Filesystem.gperm) — Function

gperm(file)

  2. Like [`uperm`](#Base.Filesystem.uperm) but gets the permissions of the group owning the file.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L275-L279)
  6. [`Base.Filesystem.operm`](#Base.Filesystem.operm) — Function

operm(file)

  2. Like [`uperm`](#Base.Filesystem.uperm) but gets the permissions for people who neither own the file nor are a member of the group owning the file
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L282-L287)
  6. [`Base.Filesystem.cp`](#Base.Filesystem.cp) — Function

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

  2. Copy the file, link, or directory from `src` to `dst`. `force=true` will first remove an existing `dst`.
  4. 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. Return `dst`.
  6. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L332-L342)
  8. [`Base.download`](#Base.download) — Function

download(url::AbstractString, [localfile::AbstractString])

  2. Download a file from the given url, optionally renaming it to the given local file name. If no filename is given this will download into a randomly-named file in your temp directory. 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.
  4. Returns the filename of the downloaded file.
  6. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/download.jl#L92-L103)
  8. [`Base.Filesystem.mv`](#Base.Filesystem.mv) — Function

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

  2. Move the file, link, or directory from `src` to `dst`. `force=true` will first remove an existing `dst`. Return `dst`.
  4. **Examples**

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’ exists. force=true is required to remove ‘goodbye.txt’ before moving. 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”);

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L356-L390)
  4. [`Base.Filesystem.rm`](#Base.Filesystem.rm) — Function

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

  2. 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.
  4. **Examples**

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: no such file or directory (ENOENT) Stacktrace: […]

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L238-L258)
  4. [`Base.Filesystem.touch`](#Base.Filesystem.touch) — Function

touch(path::AbstractString)

  2. Update the last-modified timestamp on a file to the current time.
  4. If the file does not exist a new file is created.
  6. Return `path`.
  8. **Examples**

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

  2. We can see the [`mtime`](#Base.Filesystem.mtime) has been modified by `touch`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L397-L420)
  6. [`Base.Filesystem.tempname`](#Base.Filesystem.tempname) — Function

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

  2. Generate a temporary file path. This function only returns a path; no file is created. The path is likely to be unique, but this cannot be guaranteed due to the very remote posibility of two simultaneous calls to `tempname` generating the same file name. The name is guaranteed to differ from all files already existing at the time of the call to `tempname`.
  4. When called with no arguments, the temporary name will be an absolute path to a temporary name in the system temporary directory as given by `tempdir()`. If a `parent` directory argument is given, the temporary path will be in that directory instead.
  6. The `cleanup` option controls whether the process attempts to delete the returned path automatically when the process exits. Note that the `tempname` function does not create any file or directory at the returned location, so there is nothing to cleanup unless you create a file or directory there. If you do and `clean` is `true` it will be deleted upon process termination.
  8. Julia 1.4
  10. The `parent` and `cleanup` arguments were added in 1.4. Prior to Julia 1.4 the path `tempname` would never be cleaned up at process termination.
  12. Warning
  14. This can lead to security holes if another process obtains the same file name and creates the file before you are able to. Open the file with `JL_O_EXCL` if this is a concern. Using [`mktemp()`](#Base.Filesystem.mktemp-Tuple{AbstractString}) is also recommended instead.
  16. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L571-L601)
  18. [`Base.Filesystem.tempdir`](#Base.Filesystem.tempdir) — Function

tempdir()

  2. Gets the path of the temporary directory. On Windows, `tempdir()` uses the first environment variable found in the ordered list `TMP`, `TEMP`, `USERPROFILE`. On all other operating systems, `tempdir()` uses the first environment variable found in the ordered list `TMPDIR`, `TMP`, `TEMP`, and `TEMPDIR`. If none of these are found, the path `"/tmp"` is used.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L437-L444)
  6. [`Base.Filesystem.mktemp`](#Base.Filesystem.mktemp-Tuple{AbstractString}) — Method

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

  2. Return `(path, io)`, where `path` is the path of a new temporary file in `parent` and `io` is an open file object for this path. The `cleanup` option controls whether the temporary file is automatically deleted when the process exits.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L604-L610)
  6. [`Base.Filesystem.mktemp`](#Base.Filesystem.mktemp-Tuple{Function,AbstractString}) — Method

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

  2. Apply the function `f` to the result of [`mktemp(parent)`](#Base.Filesystem.mktemp-Tuple{AbstractString}) and remove the temporary file upon completion.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L650-L655)
  6. [`Base.Filesystem.mktempdir`](#Base.Filesystem.mktempdir-Tuple{AbstractString}) — Method

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

  2. Create a temporary directory in the `parent` directory with a name constructed from the given prefix and a random suffix, and return its path. Additionally, any trailing `X` characters may be replaced with random characters. If `parent` does not exist, throw an error. The `cleanup` option controls whether the temporary directory is automatically deleted when the process exits.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L613-L621)
  6. [`Base.Filesystem.mktempdir`](#Base.Filesystem.mktempdir-Tuple{Function,AbstractString}) — Method

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

  2. Apply the function `f` to the result of [`mktempdir(parent; prefix)`](#Base.Filesystem.mktempdir-Tuple{AbstractString}) and remove the temporary directory all of its contents upon completion.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/file.jl#L672-L677)
  6. [`Base.Filesystem.isblockdev`](#Base.Filesystem.isblockdev) — Function

isblockdev(path) -> Bool

  2. Return `true` if `path` is a block device, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L194-L198)
  6. [`Base.Filesystem.ischardev`](#Base.Filesystem.ischardev) — Function

ischardev(path) -> Bool

  2. Return `true` if `path` is a character device, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L169-L173)
  6. [`Base.Filesystem.isdir`](#Base.Filesystem.isdir) — Function

isdir(path) -> Bool

  2. Return `true` if `path` is a directory, `false` otherwise.
  4. **Examples**

julia> isdir(homedir()) true

julia> isdir(“not/a/directory”) false

  2. See also: [`isfile`](#Base.Filesystem.isfile) and [`ispath`](#Base.Filesystem.ispath).
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L176-L191)
  6. [`Base.Filesystem.isfifo`](#Base.Filesystem.isfifo) — Function

isfifo(path) -> Bool

  2. Return `true` if `path` is a FIFO, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L162-L166)
  6. [`Base.Filesystem.isfile`](#Base.Filesystem.isfile) — Function

isfile(path) -> Bool

  2. Return `true` if `path` is a regular file, `false` otherwise.
  4. **Examples**

julia> isfile(homedir()) false

julia> f = open(“test_file.txt”, “w”);

julia> isfile(f) true

julia> close(f); rm(“test_file.txt”)

  2. See also: [`isdir`](#Base.Filesystem.isdir) and [`ispath`](#Base.Filesystem.ispath).
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L201-L220)
  6. [`Base.Filesystem.islink`](#Base.Filesystem.islink) — Function

islink(path) -> Bool

  2. Return `true` if `path` is a symbolic link, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L223-L227)
  6. [`Base.Filesystem.ismount`](#Base.Filesystem.ismount) — Function

ismount(path) -> Bool

  2. Return `true` if `path` is a mount point, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L328-L332)
  6. [`Base.Filesystem.ispath`](#Base.Filesystem.ispath) — Function

ispath(path) -> Bool

  2. Return `true` if a valid filesystem entity exists at `path`, otherwise returns `false`. This is the generalization of [`isfile`](#Base.Filesystem.isfile), [`isdir`](#Base.Filesystem.isdir) etc.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L153-L159)
  6. [`Base.Filesystem.issetgid`](#Base.Filesystem.issetgid) — Function

issetgid(path) -> Bool

  2. Return `true` if `path` has the setgid flag set, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L246-L250)
  6. [`Base.Filesystem.issetuid`](#Base.Filesystem.issetuid) — Function

issetuid(path) -> Bool

  2. Return `true` if `path` has the setuid flag set, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L239-L243)
  6. [`Base.Filesystem.issocket`](#Base.Filesystem.issocket) — Function

issocket(path) -> Bool

  2. Return `true` if `path` is a socket, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L230-L234)
  6. [`Base.Filesystem.issticky`](#Base.Filesystem.issticky) — Function

issticky(path) -> Bool

  2. Return `true` if `path` has the sticky bit set, `false` otherwise.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/stat.jl#L253-L257)
  6. [`Base.Filesystem.homedir`](#Base.Filesystem.homedir) — Function

homedir() -> String

  2. Return the current user's home directory.
  4. Note
  6. `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](http://docs.libuv.org/en/v1.x/misc.html#c.uv_os_homedir).
  8. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L54-L63)
  10. [`Base.Filesystem.dirname`](#Base.Filesystem.dirname) — Function

dirname(path::AbstractString) -> AbstractString

  2. Get the directory part of a path. Trailing characters ('/' or '\\') in the path are counted as part of the path.
  4. **Examples**

julia> dirname(“/home/myuser”) “/home”

julia> dirname(“/home/myuser/“) “/home/myuser”

  2. See also: [`basename`](#Base.Filesystem.basename)
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L144-L160)
  6. [`Base.Filesystem.basename`](#Base.Filesystem.basename) — Function

basename(path::AbstractString) -> AbstractString

  2. Get the file name part of a path.
  4. **Examples**

julia> basename(“/home/myuser/example.jl”) “example.jl”

  2. See also: [`dirname`](#Base.Filesystem.dirname)
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L163-L175)
  6. [`Base.@__FILE__`](#Base.@__FILE__) — Macro

@FILE -> AbstractString

  2. Expand to a string with the path to the file containing the macrocall, or an empty string if evaluated by `julia -e <expr>`. Return `nothing` if the macro was missing parser source information. Alternatively see [`PROGRAM_FILE`]($8ed71b5a22d07bdf.md#Base.PROGRAM_FILE).
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/loading.jl#L1498-L1505)
  6. [`Base.@__DIR__`](#Base.@__DIR__) — Macro

@DIR -> AbstractString

  2. Expand to a string with the absolute path to the directory of the file containing the macrocall. Return the current working directory if run from a REPL or if evaluated by `julia -e <expr>`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/loading.jl#L1511-L1517)
  6. [`Base.@__LINE__`](#Base.@__LINE__) — Macro

@LINE -> Int

  2. Expand to the line number of the location of the macrocall. Return `0` if the line number could not be determined.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/essentials.jl#L815-L820)
  6. [`Base.Filesystem.isabspath`](#Base.Filesystem.isabspath) — Function

isabspath(path::AbstractString) -> Bool

  2. Determine whether a path is absolute (begins at the root directory).
  4. **Examples**

julia> isabspath(“/home”) true

julia> isabspath(“home”) false

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L87-L100)
  4. [`Base.Filesystem.isdirpath`](#Base.Filesystem.isdirpath) — Function

isdirpath(path::AbstractString) -> Bool

  2. Determine whether a path refers to a directory (for example, ends with a path separator).
  4. **Examples**

julia> isdirpath(“/home”) false

julia> isdirpath(“/home/“) true

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L103-L116)
  4. [`Base.Filesystem.joinpath`](#Base.Filesystem.joinpath) — Function

joinpath(parts::AbstractString…) -> String

  2. Join path components into a full path. If some argument is an absolute path or (on Windows) has a drive specification that doesn't match the drive computed for the join of the preceding paths, then prior components are dropped.
  4. Note on Windows since there is a current directory for each drive, `joinpath("c:", "foo")` represents a path relative to the current directory on drive "c:" so this is equal to "c:foo", not "c:\\foo". Furthermore, `joinpath` treats this as a non-absolute path and ignores the drive letter casing, hence `joinpath("C:\A","c:b") = "C:\A\b"`.
  6. **Examples**

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

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L304-L321)
  4. [`Base.Filesystem.abspath`](#Base.Filesystem.abspath) — Function

abspath(path::AbstractString) -> String

  2. Convert a path to an absolute path by adding the current directory if necessary. Also normalizes the path as in [`normpath`](#Base.Filesystem.normpath).
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L377-L382)

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

  2. 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...))`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L385-L390)
  6. [`Base.Filesystem.normpath`](#Base.Filesystem.normpath) — Function

normpath(path::AbstractString) -> String

  2. Normalize a path, removing "." and ".." entries.
  4. **Examples**

julia> normpath(“/home/myuser/../example.jl”) “/home/example.jl”

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L324-L334)

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

  2. Convert a set of paths to a normalized path by joining them together and removing "." and ".." entries. Equivalent to `normpath(joinpath(path, paths...))`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L369-L374)
  6. [`Base.Filesystem.realpath`](#Base.Filesystem.realpath) — Function

realpath(path::AbstractString) -> String

  2. Canonicalize a path by expanding symbolic links and removing "." and ".." entries. On case-insensitive case-preserving filesystems (typically Mac and Windows), the filesystem's stored case for the path is returned.
  4. (This function throws an exception if `path` does not exist in the filesystem.)
  6. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L412-L420)
  8. [`Base.Filesystem.relpath`](#Base.Filesystem.relpath) — Function

relpath(path::AbstractString, startpath::AbstractString = “.”) -> AbstractString

  2. 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`.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L482-L488)
  6. [`Base.Filesystem.expanduser`](#Base.Filesystem.expanduser) — Function

expanduser(path::AbstractString) -> AbstractString

  2. On Unix systems, replace a tilde character at the start of a path with the current user's home directory.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L467-L471)
  6. [`Base.Filesystem.splitdir`](#Base.Filesystem.splitdir) — Function

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

  2. Split a path into a tuple of the directory name and file name.
  4. **Examples**

julia> splitdir(“/home/myuser”) (“/home”, “myuser”)

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L119-L129)
  4. [`Base.Filesystem.splitdrive`](#Base.Filesystem.splitdrive) — Function

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

  2. 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.
  4. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L46-L51)
  6. [`Base.Filesystem.splitext`](#Base.Filesystem.splitext) — Function

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

  2. 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.
  4. **Examples**

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

julia> splitext(“/home/myuser/example”) (“/home/myuser/example”, “”)

  2. [source](https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/base/path.jl#L178-L193)
  4. [`Base.Filesystem.splitpath`](#Base.Filesystem.splitpath) — Function

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

  2. Split a file path into all its path components. This is the opposite of `joinpath`. Returns an array of substrings, one for each directory or file in the path, including the root directory if present.
  4. Julia 1.1
  6. This function requires at least Julia 1.1.
  8. **Examples**

julia> splitpath(“/home/myuser/example.jl”) 4-element Array{String,1}: “/“ “home” “myuser” “example.jl” ```

source