文件系统

    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"

    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"

    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"

    Base.Filesystem.readdir — Function.

    1. readdir(dir::AbstractString=".") -> Vector{String}

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

    Examples

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

    Base.Filesystem.walkdir — Function.

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

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

    Examples

    1. for (root, dirs, files) in walkdir(".")
    2.     println("Directories in $root")
    3.     for dir in dirs
    4.         println(joinpath(root, dir)) # path to directories
    5.     end
    6.     println("Files in $root")
    7.     for file in files
    8.         println(joinpath(root, file)) # path to files
    9.     end
    10. end
    1. julia> mkpath("my/test/dir");
    3. julia> itr = walkdir("my");
    5. julia> (root, dirs, files) = first(itr)
    6. ("my", ["test"], String[])
    8. julia> (root, dirs, files) = first(itr)
    9. ("my/test", ["dir"], String[])
    11. julia> (root, dirs, files) = first(itr)
    12. ("my/test/dir", String[], String[])

    source

    — Function.

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

    1. julia> mkdir("testingdir")
    2. "testingdir"
    4. julia> cd("testingdir")
    6. "/home/JuliaUser/testingdir"

    Base.Filesystem.mkpath — Function.

    1. 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. Return path.

    Examples

    1. julia> mkdir("testingdir")
    2. "testingdir"
    4. julia> cd("testingdir")
    6. julia> pwd()
    7. "/home/JuliaUser/testingdir"
    9. julia> mkpath("my/test/dir")
    10. "my/test/dir"
    12. julia> readdir()
    13. 1-element Array{String,1}:
    14.  "my"
    16. julia> cd("my")
    18. julia> readdir()
    19. 1-element Array{String,1}:
    20.  "test"
    22. julia> readdir("test")
    23. 1-element Array{String,1}:
    24.  "dir"

    Base.Filesystem.symlink — Function.

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

    Base.Filesystem.readlink — Function.

    1. readlink(path::AbstractString) -> AbstractString

    Return the target location a symbolic link path points to.

    Base.Filesystem.chmod — Function.

    1. 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 and the path is a directory all permissions in that directory will be recursively changed. Return path.

    Base.Filesystem.chown — Function.

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

    Base.Libc.RawFD — Type.

    1. RawFD

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

    source

    — Function.

    1. stat(file)

    Returns a structure whose fields contain information about the file. The fields of the structure are:

    source

    — Function.

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

    1. ctime(file)

    Equivalent to stat(file).ctime.

    Base.Filesystem.mtime — Function.

    1. mtime(file)

    Equivalent to stat(file).mtime.

    Base.Filesystem.filemode — Function.

    1. filemode(file)

    Equivalent to stat(file).mode.

    Base.Filesystem.filesize — Function.

    1. filesize(path...)

    Equivalent to stat(file).size.

    Base.Filesystem.uperm — Function.

    1. uperm(file)

    Get the permissions of the owner of the file as a bitfield of

    ValueDescription
    01Execute Permission
    02Write Permission
    04Read Permission

    For allowed arguments, see .

    source

    — Function.

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

    Base.Filesystem.operm — Function.

    1. operm(file)

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

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

    Base.download — Function.

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

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

    1. julia> write("hello.txt", "world");
    3. julia> mv("hello.txt", "goodbye.txt")
    4. "goodbye.txt"
    6. julia> "hello.txt" in readdir()
    7. false
    9. julia> readline("goodbye.txt")
    10. "world"
    12. julia> write("hello.txt", "world2");
    14. julia> mv("hello.txt", "goodbye.txt")
    15. ERROR: ArgumentError: 'goodbye.txt' exists. `force=true` is required to remove 'goodbye.txt' before moving.
    16. Stacktrace:
    17.  [1] #checkfor_mv_cp_cptree#10(::Bool, ::Function, ::String, ::String, ::String) at ./file.jl:293
    18. [...]
    20. julia> mv("hello.txt", "goodbye.txt", force=true)
    21. "goodbye.txt"
    23. julia> rm("goodbye.txt");

    Base.Filesystem.rm — Function.

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

    1. julia> mkpath("my/test/dir");
    3. julia> rm("my", recursive=true)
    5. julia> rm("this_file_does_not_exist", force=true)
    7. julia> rm("this_file_does_not_exist")
    8. ERROR: IOError: unlink: no such file or directory (ENOENT)
    9. Stacktrace:
    10. [...]

    Base.Filesystem.touch — Function.

    1. touch(path::AbstractString)

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

    Examples

    1. julia> write("my_little_file", 2);
    2. julia> mtime("my_little_file")
    3. 1.5273815391135583e9
    5. julia> touch("my_little_file");
    7. julia> mtime("my_little_file")
    8. 1.527381559163435e9

    We can see the has been modified by touch.

    source

    — Function.

    1. tempname()

    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.

    Warning

    This can lead to race conditions if another process obtains the same file name and creates the file before you are able to. Using mktemp() is recommended instead.

    Base.Filesystem.tempdir — Function.

    1. tempdir()

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

    Base.Filesystem.mktemp — Method.

    1. mktemp(parent=tempdir())

    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.

    Base.Filesystem.mktemp — Method.

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

    Apply the function f to the result of and remove the temporary file upon completion.

    source

    — Method.

    1. mktempdir(parent=tempdir())

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

    source

    — Method.

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

    1. isblockdev(path) -> Bool

    Return if path is a block device, false otherwise.

    Base.Filesystem.ischardev — Function.

    1. ischardev(path) -> Bool

    Return true if path is a character device, false otherwise.

    Base.Filesystem.isdir — Function.

    1. isdir(path) -> Bool

    Return true if path is a directory, false otherwise.

    Examples

    1. julia> isdir(homedir())
    2. true
    4. julia> isdir("not/a/directory")
    5. false

    Base.Filesystem.isfifo — Function.

    1. isfifo(path) -> Bool

    Return true if path is a FIFO, false otherwise.

    Base.Filesystem.isfile — Function.

    1. isfile(path) -> Bool

    Return true if path is a regular file, false otherwise.

    Examples

    1. julia> isfile(homedir())
    2. false
    4. julia> f = open("test_file.txt", "w");
    6. julia> isfile(f)
    7. true
    9. julia> close(f); rm("test_file.txt")

    Base.Filesystem.islink — Function.

    1. islink(path) -> Bool

    Return true if path is a symbolic link, false otherwise.

    Base.Filesystem.ismount — Function.

    1. ismount(path) -> Bool

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

    Base.Filesystem.ispath — Function.

    1. ispath(path) -> Bool

    Return true if path is a valid filesystem path, false otherwise.

    Base.Filesystem.issetgid — Function.

    1. issetgid(path) -> Bool

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

    Base.Filesystem.issetuid — Function.

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

    — Function.

    1. issocket(path) -> Bool

    Return true if path is a socket, false otherwise.

    source

    — Function.

    1. issticky(path) -> Bool

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

    source

    — Function.

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

    Base.Filesystem.dirname — Function.

    1. dirname(path::AbstractString) -> AbstractString

    Get the directory part of a path.

    Examples

    1. julia> dirname("/home/myuser")
    2. "/home"

    See also:

    source

    — Function.

    1. basename(path::AbstractString) -> AbstractString

    Get the file name part of a path.

    Examples

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

    See also: dirname

    Base.@FILE — Macro.

    1. @__FILE__ -> AbstractString

    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 .

    source

    — Macro.

    1. @__DIR__ -> AbstractString

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

    source

    — Macro.

    1. @__LINE__ -> Int

    Expand to the line number of the location of the macrocall. Return 0 if the line number could not be determined.

    source

    — Function.

    1. isabspath(path::AbstractString) -> Bool

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

    Examples

    1. julia> isabspath("/home")
    2. true
    4. julia> isabspath("home")
    5. false

    source

    — Function.

    1. isdirpath(path::AbstractString) -> Bool

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

    Examples

    1. julia> isdirpath("/home")
    2. false
    4. julia> isdirpath("/home/")
    5. true

    source

    — Function.

    1. joinpath(parts...) -> AbstractString

    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.

    Examples

    1. julia> joinpath("/home/myuser", "example.jl")
    2. "/home/myuser/example.jl"

    source

    — Function.

    1. abspath(path::AbstractString) -> AbstractString

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

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

    — Function.

    1. normpath(path::AbstractString) -> AbstractString

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

    Examples

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

    source

    — Function.

    1. realpath(path::AbstractString) -> AbstractString

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

    source

    — Function.

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

    — Function.

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

    — Function.

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

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

    Examples

    1. julia> splitdir("/home/myuser")
    2. ("/home", "myuser")

    source

    — Function.

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

    — Function.

    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.

    Examples

    1. julia> splitext("/home/myuser/example.jl")
    2. ("/home/myuser/example", ".jl")

    source