Engee documentation

Filesystem

read(filename::AbstractString)

Read the entire contents of a file as a Vector{UInt8}.

read(filename::AbstractString, String)

Read the entire contents of a file as a string.

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

Open a file and read its contents. args is passed to read: this is equivalent to open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Write the canonical binary representation of content to a file, which will be created if it does not exist yet or overwritten if it does exist.

Return the number of bytes written into the file.

pwd() -> String

Get the current working directory.

See also: cd, tempdir.

Examples

julia> pwd()
"/home/JuliaUser"

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

julia> pwd()
"/home/JuliaUser/Projects/julia"
cd(dir::AbstractString=homedir())

Set the current working directory.

See also: pwd, mkdir, mkpath, mktempdir.

Examples

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

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

julia> cd()

julia> pwd()
"/home/JuliaUser"
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

julia> pwd()
"/home/JuliaUser"

julia> cd(readdir, "/home/JuliaUser/Projects/julia")
34-element Vector{String}:
 ".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}

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 readdir(dir, sort=false) to opt out of sorting.

See also: walkdir.

Compatibility

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

Examples

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

julia> readdir()
30-element Vector{String}:
 ".appveyor.yml"
 ".git"
 ".gitattributes"
 ⋮
 "ui"
 "usr"
 "usr-staging"

julia> readdir(join=true)
30-element Vector{String}:
 "/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 Vector{String}:
 ".gitignore"
 "Base.jl"
 "Enums.jl"
 ⋮
 "version_git.sh"
 "views.jl"
 "weakkeydict.jl"

julia> readdir("base", join=true)
145-element Vector{String}:
 "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 Vector{String}:
 "/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 = pwd(); topdown=true, follow_symlinks=false, onerror=throw)

Return an iterator that walks the directory tree of a directory.

The iterator returns a tuple containing (path, dirs, files). Each iteration path will change to the next directory in the tree; then dirs and files will be vectors containing the directories and files in the current path directory. The directory tree can be traversed top-down or bottom-up. If walkdir or stat encounters a IOError it will rethrow the error by default. A custom error handling function can be provided through onerror keyword argument. onerror is called with a IOError as argument. The returned iterator is stateful so when accessed repeatedly each access will resume where the last left off, like Iterators.Stateful.

See also: readdir.

Compatibility

Julia 1.12 pwd() as the default directory was added in Julia 1.12.

Examples

for (path, dirs, files) in walkdir(".")
    println("Directories in $path")
    for dir in dirs
        println(joinpath(path, dir)) # path to directories
    end
    println("Files in $path")
    for file in files
        println(joinpath(path, file)) # path to files
    end
end
julia> mkpath("my/test/dir");

julia> itr = walkdir("my");

julia> (path, dirs, files) = first(itr)
("my", ["test"], String[])

julia> (path, dirs, files) = first(itr)
("my/test", ["dir"], String[])

julia> (path, dirs, files) = first(itr)
("my/test/dir", String[], String[])
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. Return path.

Examples

julia> mkdir("testingdir")
"testingdir"

julia> cd("testingdir")

julia> pwd()
"/home/JuliaUser/testingdir"
mkpath(path::AbstractString; mode::Unsigned = 0o777)

Create all intermediate directories in the path as required. Directories are created with the permissions mode which defaults to 0o777 and is modified by the current file creation mask. Unlike mkdir, mkpath does not error if path (or parts of it) already exists. However, an error will be thrown if path (or parts of it) points to an existing file. Return path.

If path includes a filename you will probably want to use mkpath(dirname(path)) to avoid creating a directory using the filename.

Examples

julia> cd(mktempdir())

julia> mkpath("my/test/dir") # creates three directories
"my/test/dir"

julia> readdir()
1-element Vector{String}:
 "my"

julia> cd("my")

julia> readdir()
1-element Vector{String}:
 "test"

julia> readdir("test")
1-element Vector{String}:
 "dir"

julia> mkpath("intermediate_dir/actually_a_directory.txt") # creates two directories
"intermediate_dir/actually_a_directory.txt"

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

julia> mkpath("my/test/dir/") # returns the original `path`
"my/test/dir/"
hardlink(src::AbstractString, dst::AbstractString)

Creates a hard link to an existing source file src with the name dst. The destination, dst, must not exist.

See also: symlink.

Compatibility

Julia 1.8 This method was added in Julia 1.8.

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

Creates a symbolic link to target with the name link.

On Windows, symlinks must be explicitly declared as referring to a directory or not. If target already exists, by default the type of link will be auto- detected, however if target does not exist, this function defaults to creating a file symlink unless dir_target is set to true. Note that if the user sets dir_target but target exists and is a file, a directory symlink will still be created, but dereferencing the symlink will fail, just as if the user creates a file symlink (by calling symlink() with dir_target set to false before the directory is created) and tries to dereference it to a directory.

Additionally, there are two methods of making a link on Windows; symbolic links and junction points. Junction points are slightly more efficient, but do not support relative paths, so if a relative directory symlink is requested (as denoted by isabspath(target) returning false) a symlink will be used, else a junction point will be used. Best practice for creating symlinks on Windows is to create them only after the files/directories they reference are already created.

See also: hardlink.

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

Julia 1.6 The dir_target keyword argument was added in Julia 1.6. Prior to this, symlinks to nonexistent paths on windows would always be file symlinks, and relative symlinks to directories were not supported.

 
readlink(path::AbstractString) -> String

Return the target location a symbolic link path points to.

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

Change the permissions mode of path to mode. Only integer modes (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.

Note Prior to Julia 1.6, this did not correctly manipulate filesystem ACLs on Windows, therefore it would only set read-only bits on files. It now is able to manipulate ACLs.

 
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 owners and groups are currently supported. Return path.

RawFD

Primitive type which wraps the native OS file descriptor. RawFDs can be passed to methods like 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.

stat(path)
stat(path_elements...)

Return a structure whose fields contain information about the file. If multiple arguments are given, they are joined by joinpath.

The fields of the structure are:

Name Type Description

desc

Union{String, Base.OS_HANDLE}

The path or OS file descriptor

size

Int64

The size (in bytes) of the file

device

UInt

ID of the device that contains the file

inode

UInt

The inode number of the file

mode

UInt

The protection mode of the file

nlink

Int

The number of hard links to the file

uid

UInt

The user id of the owner of the file

gid

UInt

The group id of the file owner

rdev

UInt

If this file refers to a device, the ID of the device it refers to

blksize

Int64

The file-system preferred block size for the file

blocks

Int64

The number of 512-byte blocks allocated

mtime

Float64

Unix timestamp of when the file was last modified

ctime

Float64

Unix timestamp of when the file’s metadata was changed

 
diskstat(path=pwd())

Returns statistics in bytes about the disk that contains the file or directory pointed at by path. If no argument is passed, statistics about the disk that contains the current working directory are returned.

Compatibility

Julia 1.8 This method was added in Julia 1.8.

 
lstat(path)
lstat(path_elements...)

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.

ctime(path)
ctime(path_elements...)
ctime(stat_struct)

Return the unix timestamp of when the metadata of the file at path was last modified, or the last modified metadata timestamp indicated by the file descriptor stat_struct.

Equivalent to stat(path).ctime or stat_struct.ctime.

mtime(path)
mtime(path_elements...)
mtime(stat_struct)

Return the unix timestamp of when the file at path was last modified, or the last modified timestamp indicated by the file descriptor stat_struct.

Equivalent to stat(path).mtime or stat_struct.mtime.

filemode(path)
filemode(path_elements...)
filemode(stat_struct)

Return the mode of the file located at path, or the mode indicated by the file descriptor stat_struct.

Equivalent to stat(path).mode or stat_struct.mode.

filesize(path)
filesize(path_elements...)
filesize(stat_struct)

Return the size of the file located at path, or the size indicated by file descriptor stat_struct.

Equivalent to stat(path).size or stat_struct.size.

uperm(path)
uperm(path_elements...)
uperm(stat_struct)

Return a bitfield of the owner permissions for the file at path or file descriptor stat_struct.

Value Description

01

Execute Permission

02

Write Permission

04

Read Permission

The fact that a bitfield is returned means that if the permission is read+write, the bitfield is "110", which maps to the decimal value of 0+2+4=6. This is reflected in the printing of the returned UInt8 value.

See also gperm and operm.

julia> touch("dummy_file");  # Create test-file without contents

julia> uperm("dummy_file")
0x06

julia> bitstring(ans)
"00000110"

julia> has_read_permission(path) = uperm(path) & 0b00000100 != 0;  # Use bit mask to check specific bit

julia> has_read_permission("dummy_file")
true

julia> rm("dummy_file")     # Clean up test-file
gperm(path)
gperm(path_elements...)
gperm(stat_struct)

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

See also operm.

operm(path)
operm(path_elements...)
operm(stat_struct)

Like uperm but gets the permissions for people who neither own the file nor are a member of the group owning the file.

See also gperm.

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

Copy the file, link, or directory from src to dst. force=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. Return dst.

Note The cp function is different from the cp Unix command. The cp function always operates on the assumption that dst is a file, while the command does different things depending on whether dst is a directory or a file. Using force=true when dst is a directory will result in loss of all the contents present in the dst directory, and dst will become a file that has the contents of src instead.

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

Download a file from the given url, saving it to the location path, or if not specified, a temporary path. Returns the path of the downloaded file.

Note Since Julia 1.6, this function is deprecated and is just a thin wrapper around Downloads.download. In new code, you should use that function directly instead of calling this.

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

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

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");

Note The mv function is different from the mv Unix command. The mv function by default will error if dst exists, while the command will delete an existing dst file by default. Also the mv function always operates on the assumption that dst is a file, while the command does different things depending on whether dst is a directory or a file. Using force=true when dst is a directory will result in loss of all the contents present in the dst directory, and dst will become a file that has the contents of src instead.

 
Base.rename(oldpath::AbstractString, newpath::AbstractString)

Change the name of a file or directory from oldpath to newpath. If newpath is an existing file or empty directory it may be replaced. Equivalent to rename(2) on Unix. If a path contains a "\0" throw an ArgumentError. On other failures throw an IOError. Return newpath.

This is a lower level filesystem operation used to implement mv.

OS-specific restrictions may apply when oldpath and newpath are in different directories.

Currently there are a few differences in behavior on Windows which may be resolved in a future release. Specifically, currently on Windows:

  1. rename will fail if oldpath or newpath are opened files.

  2. rename will fail if newpath is an existing directory.

  3. rename may work if newpath is a file and oldpath is a directory.

  4. rename may remove oldpath if it is a hardlink to newpath.

See also: mv.

Compatibility

Julia 1.12 This method was made public in Julia 1.12.

 
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.

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("this_file_does_not_exist"): no such file or directory (ENOENT)
Stacktrace:
[...]
Base.touch(::Pidfile.LockMonitor)

Update the mtime on the lock, to indicate it is still fresh.

See also the refresh keyword in the mkpidlock constructor.

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

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

If the file does not exist a new file is created.

Return path.

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

We can see the mtime has been modified by touch.

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

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 possibility 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.

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. If a suffix is given the tempname will end with that suffix and be tested for uniqueness with that suffix.

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 cleanup is true it will be deleted upon process termination.

Compatibility

Julia 1.4 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.
Compatibility

Julia 1.12 The suffix keyword argument was added in Julia 1.12.

Warning 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() is also recommended instead.

 
tempdir()

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.

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

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.

Compatibility

Julia 1.3 The cleanup keyword argument was added in Julia 1.3. Relatedly, starting from 1.3, Julia will remove the temporary paths created by mktemp when the Julia process exits, unless cleanup is explicitly set to false.

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

Apply the function f to the result of mktemp(parent) and remove the temporary file upon completion.

See also: mktempdir.

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

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, on some platforms, any trailing 'X' characters in prefix 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.

Compatibility

Julia 1.2 The prefix keyword argument was added in Julia 1.2.
Compatibility

Julia 1.3 The cleanup keyword argument was added in Julia 1.3. Relatedly, starting from 1.3, Julia will remove the temporary paths created by mktempdir when the Julia process exits, unless cleanup is explicitly set to false.

See also: mktemp, mkdir.

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

Apply the function f to the result of mktempdir(parent; prefix) and remove the temporary directory and all of its contents upon completion.

See also: mktemp, mkdir.

Compatibility

Julia 1.2 The prefix keyword argument was added in Julia 1.2.

 
isblockdev(path) -> Bool
isblockdev(path_elements...) -> Bool
isblockdev(stat_struct) -> Bool

Return true if the path path or file descriptor stat_struct refer to a block device, false otherwise.

ischardev(path) -> Bool
ischardev(path_elements...) -> Bool
ischardev(stat_struct) -> Bool

Return true if the path path or file descriptor stat_struct refer to a character device, false otherwise.

isdir(path) -> Bool
isdir(path_elements...) -> Bool

Return true if path points to a directory, false otherwise.

Examples

julia> isdir(homedir())
true

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

See also isfile and ispath.

isfifo(path) -> Bool
isfifo(path_elements...) -> Bool
isfifo(stat_struct) -> Bool

Return true if the file at path or file descriptor stat_struct is FIFO, false otherwise.

isfile(path) -> Bool
isfile(path_elements...) -> Bool

Return true if path points to a regular file, false otherwise.

Examples

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

See also isdir and ispath.

islink(path) -> Bool
islink(path_elements...) -> Bool

Return true if path points to a symbolic link, false otherwise.

ismount(path) -> Bool
ismount(path_elements...) -> Bool

Return true if path is a mount point, false otherwise.

ispath(path) -> Bool
ispath(path_elements...) -> Bool

Return true if a valid filesystem entity exists at path, otherwise returns false.

This is the generalization of isfile, isdir etc.

issetgid(path) -> Bool
issetgid(path_elements...) -> Bool
issetgid(stat_struct) -> Bool

Return true if the file at path or file descriptor stat_struct have the setgid flag set, false otherwise.

issetuid(path) -> Bool
issetuid(path_elements...) -> Bool
issetuid(stat_struct) -> Bool

Return true if the file at path or file descriptor stat_struct have the setuid flag set, false otherwise.

issocket(path) -> Bool
issocket(path_elements...) -> Bool

Return true if path points to a socket, false otherwise.

issticky(path) -> Bool
issticky(path_elements...) -> Bool
issticky(stat_struct) -> Bool

Return true if the file at path or file descriptor stat_struct have the sticky bit set, false otherwise.

homedir() -> String

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.

See also Sys.username.

dirname(path::AbstractString) -> String

Get the directory part of a path. Trailing characters ('/' or '') in the path are counted as part of the path.

Examples

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

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

See also basename.

basename(path::AbstractString) -> String

Get the file name part of a path.

Note This function differs slightly from the Unix basename program, where trailing slashes are ignored, i.e. $ basename /foo/bar/ returns bar, whereas basename in Julia returns an empty string "".

Examples

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

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

See also dirname.

isabspath(path::AbstractString) -> Bool

Determine whether a path is absolute (begins at the root directory).

Examples

julia> isabspath("/home")
true

julia> isabspath("home")
false
isdirpath(path::AbstractString) -> Bool

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

Examples

julia> isdirpath("/home")
false

julia> isdirpath("/home/")
true
joinpath(parts::AbstractString...) -> String
joinpath(parts::Vector{AbstractString}) -> String
joinpath(parts::Tuple{AbstractString}) -> String

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.

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".

Examples

julia> joinpath("/home/myuser", "example.jl")
"/home/myuser/example.jl"
julia> joinpath(["/home/myuser", "example.jl"])
"/home/myuser/example.jl"
abspath(path::AbstractString, paths::AbstractString...) -> String

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

abspath(path::AbstractString) -> String

Convert a path to an absolute path by adding the current directory if necessary. Also normalizes the path as in normpath.

Examples

If you are in a directory called JuliaExample and the data you are using is two levels up relative to the JuliaExample directory, you could write:

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

Which gives a path like "/home/JuliaUser/data/".

See also joinpath, pwd, expanduser.

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

Convert a set of paths to a normalized path by joining them together and removing "." and ".." entries. Equivalent to normpath(joinpath(path, paths...)).

normpath(path::AbstractString) -> String

Normalize a path, removing "." and ".." entries and changing "/" to the canonical path separator for the system.

Examples

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

julia> normpath("Documents/Julia") == joinpath("Documents", "Julia")
true
realpath(path::AbstractString) -> String

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.

(This function throws an exception if path does not exist in the filesystem.)

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

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.

On Windows, case sensitivity is applied to every part of the path except drive letters. If path and startpath refer to different drives, the absolute path of path is returned.

expanduser(path::AbstractString) -> AbstractString

On Unix systems, replace a tilde character at the start of a path with the current user’s home directory.

See also: contractuser.

contractuser(path::AbstractString) -> AbstractString

On Unix systems, if the path starts with homedir(), replace it with a tilde character.

See also: expanduser.

samefile(path_a, path_b)

Check if the paths path_a and path_b refer to the same existing file or directory.

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

Split a path into a tuple of the directory name and file name.

Examples

julia> splitdir("/home/myuser")
("/home", "myuser")
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.

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

If the last component of a path contains one or more dots, split the path into everything before the last dot and everything including and after the dot. Otherwise, return a tuple of the argument unmodified and the empty string. "splitext" is short for "split extension".

Examples

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}

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.

Compatibility

Julia 1.1 This function requires at least Julia 1.1.

Examples

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