# Filesystem

`pwd`() → AbstractString

  Get the current working directory.

`cd`([dir::AbstractString=homedir()])

  Set the current working directory.

`cd`(f[, dir=homedir()])

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

`readdir`([dir]) → Vector{String}

  Returns the files and directories in the directory `dir` (or the current working directory if not given).

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

  The walkdir method 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 it will raise the error. A custom error handling function can be provided through `onerror` keyword argument, the function 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

`mkdir`(path[, mode])

  Make a new directory with name `path` and permissions `mode`. `mode` defaults to `0o777`, modified by the current file creation mask.

`mkpath`(path[, mode])

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

`symlink`(target, link)

  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.

`readlink`(path) → AbstractString

  Returns the value of a symbolic link `path`.

`chmod`(path, mode; recursive=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.

`chown`(path, owner, group=-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.

`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

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

`ctime`(file)

  Equivalent to `stat(file).ctime`

`mtime`(file)

  Equivalent to `stat(file).mtime`.

`filemode`(file)

  Equivalent to `stat(file).mode`

`filesize`(path...)

  Equivalent to `stat(file).size`.

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

`gperm`(file)

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

`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

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

`download`(url[, localfile])

  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.

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

`rm`(path::AbstractString; force=false, recursive=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.

`touch`(path::AbstractString)

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

`tempname`()

  Generate a unique temporary file path.

`tempdir`()

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

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

`mktemp`(f::Function[, parent=tempdir()])

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

`mktempdir`([parent=tempdir()])

  Create a temporary directory in the `parent` directory and return its path.

`mktempdir`(f::Function[, parent=tempdir()])

  Apply the function `f` to the result of `mktempdir(parent)` and remove the temporary directory upon completion.

`isblockdev`(path) → Bool

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

`ischardev`(path) → Bool

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

`isdir`(path) → Bool

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

`isfifo`(path) → Bool

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

`isfile`(path) → Bool

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

`islink`(path) → Bool

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

`ismount`(path) → Bool

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

`ispath`(path) → Bool

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

`issetgid`(path) → Bool

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

`issetuid`(path) → Bool

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

`issocket`(path) → Bool

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

`issticky`(path) → Bool

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

`homedir`() → AbstractString

  Return the current user’s home directory.

`dirname`(path::AbstractString) → AbstractString

  Get the directory part of a path.

`basename`(path::AbstractString) → AbstractString

  Get the file name part of a path.

`@__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`.

`@__LINE__`() → Int

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

`isabspath`(path::AbstractString) → Bool

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

`isdirpath`(path::AbstractString) → Bool

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

`joinpath`(parts...) → AbstractString

  Join path components into a full path. If some argument is an absolute path, then prior components are dropped.

`abspath`(path::AbstractString) → AbstractString

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

`normpath`(path::AbstractString) → AbstractString

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

`realpath`(path::AbstractString) → AbstractString

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

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

`expanduser`(path::AbstractString) → AbstractString

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

`splitdir`(path::AbstractString) → (AbstractString,AbstractString)

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

`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) → (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.