文件系统

read(filename::AbstractString)

read(filename::AbstractString, String)

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

write(filename::AbstractString, content)

pwd() -> String

julia> pwd()
"/home/JuliaUser"

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

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

cd(dir::AbstractString=homedir())

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

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

julia> cd()

julia> pwd()
"/home/JuliaUser"

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

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}

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)

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)

julia> mkdir("testingdir")
"testingdir"

julia> cd("testingdir")

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

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

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（"测试"）
1元素向量{String}:
 "署长"

julia>mkpath（"intermediate_dir/actually_a_directory。txt")#创建两个目录
"intermediate_dir/actually_a_directory。txt"

julia>isdir("intermediate_dir/actually_a_directory.txt"）
真的

julia>mkpath("my/test/dir/")#返回原始 `路径`
"我的/测试/目录/"

hardlink(src::AbstractString, dst::AbstractString)

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

readlink(path::AbstractString) -> String

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

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

RawFD

stat(path)
stat(path_elements...)

diskstat(path=pwd())

lstat(path)
lstat(path_elements...)

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

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

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

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

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

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)

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

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

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

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

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

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

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

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)

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

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

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

tempdir()

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

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

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

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

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

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

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

julia> isdir(homedir())
true

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

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

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

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

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

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

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

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

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

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

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

homedir() -> String

dirname(path::AbstractString) -> String

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

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

basename(path::AbstractString) -> String

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

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

isabspath(path::AbstractString) -> Bool

julia> isabspath("/home")
true

julia> isabspath("home")
false

isdirpath(path::AbstractString) -> Bool

julia> isdirpath("/home")
false

julia> isdirpath("/home/")
true

joinpath(parts::AbstractString...) -> String
joinpath(parts::Vector{AbstractString}) -> String
joinpath(parts::Tuple{AbstractString}) -> String

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

abspath(path::AbstractString) -> String

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

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

normpath(path::AbstractString) -> String

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

julia> normpath("Documents/Julia") == joinpath("Documents", "Julia")
true

realpath(path::AbstractString) -> String

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

expanduser(path::AbstractString) -> AbstractString

contractuser(path::AbstractString) -> AbstractString

samefile(path_a, path_b)

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

julia> splitdir("/home/myuser")
("/home", "myuser")

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

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

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}

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