I/O和网络

stdout::IO

stderr::IO

stdin::IO

read(filename::AbstractString)

read(filename::AbstractString, String)

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

write(filename::AbstractString, content)

open(f::Function, command, args...; kwargs...)

open(command, stdio=devnull; write::Bool = false, read::Bool = !write)

open(command, mode::AbstractString, stdio=devnull)

open(fd::OS_HANDLE) -> IO

open(filename::AbstractString, [mode::AbstractString]; lock = true) -> IOStream

julia> io = open("myfile.txt", "w");

julia> write(io, "Hello world!");

julia> close(io);

julia> io = open("myfile.txt", "r");

julia> read(io, String)
"Hello world!"

julia>write(io,"此文件为只读")
错误：ArgumentError：写入失败，IOStream不可写
[...]

朱莉娅>关闭(io)

julia>io=open("myfile.txt"，"a"）;

julia>write(io,"此流不是只读的")
28

朱莉娅>关闭(io)

julia>rm("myfile.txt"）

open(filename::AbstractString; lock = true, keywords...) -> IOStream

open(f::Function, args...; kwargs...)

julia> write("myfile.txt", "Hello world!");

julia> open(io->read(io, String), "myfile.txt")
"Hello world!"

julia> rm("myfile.txt")

IOStream

IOBuffer(string::String)

julia> io = IOBuffer("Haho");

julia> String(take!(io))
"Haho"

julia> String(take!(io))
"Haho"

IOBuffer([data::AbstractVector{UInt8}]; keywords...) -> IOBuffer

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

julia> io = IOBuffer(b"JuliaLang is a GitHub organization.")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=35, maxsize=Inf, ptr=1, mark=-1)

julia> read(io, String)
"JuliaLang is a GitHub organization."

julia> write(io, "This isn't writable.")
ERROR: ArgumentError: ensureroom failed, IOBuffer is not writeable

julia> io = IOBuffer(UInt8[], read=true, write=true, maxsize=34)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=34, ptr=1, mark=-1)

julia> write(io, "JuliaLang is a GitHub organization.")
34

julia> String(take!(io))
"JuliaLang is a GitHub organization"

julia> length(read(IOBuffer(b"data", read=true, truncate=false)))
4

julia> length(read(IOBuffer(b"data", read=true, truncate=true)))
0

take!(b::IOBuffer)

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

茱莉亚>字符串（拿！(io))
"JuliaLang是一个GitHub组织。 它有许多成员。"

Pipe()

julia> err = Pipe()

# After this `err` will be initialized and you may read `foo`'s
# stderr from the `err` pipe, or pass `err` to other pipelines.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# Now destroy the write half of the pipe, so that the read half will get EOF
julia> closewrite(err)

julia> read(err, String)
"stderr messages"

link_pipe!(pipe; reader_supports_async=false, writer_supports_async=false)

fdio([name::AbstractString, ]fd::Integer[, own::Bool=false]) -> IOStream

flush(stream)

close(stream)

closewrite(stream)

julia> io = Base.BufferStream(); # this never blocks, so we can read and write on the same Task

julia> write(io, "request");

julia> # calling `read(io)` here would block forever

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

write(io, x, y...)
write(io, x) + write(io, y...)

julia> fname = tempname(); # random temporary filename

julia> open(fname,"w") do f
           # Make sure we write 64bit integer in little-endian byte order
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # Convert back to host byte order and host integer type
           Int(ltoh(read(f,Int64)))
       end
42

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

julia> write(io, "Sometimes those members") + write(io, " write documentation.")
44

julia> String(take!(io))
"Sometimes those members write documentation."

julia> struct MyStruct; x::Float64; end

julia> io = IOBuffer()
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=Inf, ptr=1, mark=-1)

julia> write(io, Ref(MyStruct(42.0)))
8

julia> seekstart(io); read!(io, Ref(MyStruct(NaN)))
Base.RefValue{MyStruct}(MyStruct(42.0))

read(command::Cmd, String)

read(command::Cmd)

read(s::IOStream, nb::Integer; all=true)

read(s::IO, nb=typemax(Int))

read(filename::AbstractString)

read(filename::AbstractString, String)

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

read(io::IO, T)

read(io::IO, String)

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> read(io, Char)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> read(io, String)
"JuliaLang is a GitHub organization"

read!(stream::IO, array::AbstractArray)
read!(filename::AbstractString, array::AbstractArray)

readbytes!(stream::IOStream, b::AbstractVector{UInt8}, nb=length(b); all::Bool=true)

readbytes!(stream::IO, b::AbstractVector{UInt8}, nb=length(b))

unsafe_read(io::IO, ref, nbytes::UInt)

unsafe_write(io::IO, ref, nbytes::UInt)

readeach(io::IO, T)

julia> io = IOBuffer("JuliaLang is a GitHub organization.\n It has many members.\n");

julia> for c in readeach(io, Char)
           c == '\n' && break
           print(c)
       end
JuliaLang is a GitHub organization.

peek(stream[, T=UInt8])

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

position(l::Lexer)

position(s)

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> position(io)
5

julia> skip(io, 10);

julia> position(io)
15

julia> seekend(io);

julia> position(io)
35

seek(s, pos)

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)

seekstart(s)

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

seekend(s)

skip(s, offset)

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (category Lu: Letter, uppercase)

mark(s::IO)

unmark(s::IO)

reset(s::IO)

ismarked(s::IO)

eof(stream) -> Bool

julia> b = IOBuffer("my buffer");

julia> eof(b)
false

朱莉娅>seekend(b);

朱莉娅>eof（b）
真的

isreadonly(io) -> Bool

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

iswritable(io) -> Bool

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

isreadable(path::String)

isreadable(io) -> Bool

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")

isexecutable(path::String)

isopen(object) -> Bool

julia> io = open("my_file.txt", "w+");

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(x) -> RawFD

redirect_stdio(f; stdin=nothing, stderr=nothing, stdout=nothing)

julia> redirect_stdio(stdout="stdout.txt", stderr="stderr.txt") do
           print("hello stdout")
           print(stderr, "hello stderr")
       end

julia> read("stdout.txt", String)
"hello stdout"

julia> read("stderr.txt", String)
"hello stderr"

julia> redirect_stdio(stdout="log.txt", stderr="log.txt", stdin=devnull) do
    ...
end

julia> io1 = open("same/path", "w")

julia> io2 = open("same/path", "w")

julia> redirect_stdio(f, stdout=io1, stderr=io2) # not supported

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # not supported

redirect_stdio(;stdin=stdin, stderr=stderr, stdout=stdout)

redirect_stdout([stream]) -> stream

redirect_stdout(f::Function, stream)

redirect_stderr([stream]) -> stream

redirect_stderr(f::Function, stream)

redirect_stdin([stream]) -> stream

redirect_stdin(f::Function, stream)

readchomp(x)

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readchomp("my_file.txt")
"JuliaLang is a GitHub organization.\nIt has many members."

julia> rm("my_file.txt");

truncate(file, n)

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.")
35

julia> truncate(io, 15)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=15, maxsize=Inf, ptr=16, mark=-1)

julia> String(take!(io))
"JuliaLang is a "

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.");

julia> truncate(io, 40);

julia> String(take!(io))
"JuliaLang is a GitHub organization.\0\0\0\0\0"

skipchars(predicate, io::IO; linecomment=nothing)

julia> buf = IOBuffer("    text")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=1, mark=-1)

julia> skipchars(isspace, buf)
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=5, mark=-1)

julia> String(readavailable(buf))
"text"

countlines(io::IO; eol::AbstractChar = '\n')
countlines(filename::AbstractString; eol::AbstractChar = '\n')

julia> io = IOBuffer("JuliaLang is a GitHub organization.\n");

julia> countlines(io)
1

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> countlines(io)
1

julia> eof(io) # counting lines moves the file pointer
true

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> countlines(io, eol = '.')
1

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\n")
36

julia> countlines("my_file.txt")
1

julia> countlines("my_file.txt", eol = 'n')
4

julia> rm("my_file.txt")

PipeBuffer(data::AbstractVector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))

readavailable(stream)

IOContext

IOContext(io::IO,KV::Pair...)

julia>io=IOBuffer（）;

julia>printstyled（IOContext（io，：color=>true），"string"，color=：red）

茱莉亚>字符串（拿！(io))
"\e[31m]\e[39m"

julia>printstyled(io,"string",color=:red)

茱莉亚>字符串（拿！(io))
"字符串"

julia>print（IOContext（stdout，：compact=>false），1.12341234）
1.12341234
julia>打印（iocontext（stdout，：compact=>true），1.12341234）
1.12341

julia>函数f(io::IO)
           如果get(io,:short,false)
               打印(io,"短")
           其他
               打印（io，"loooooong"）
           结束
       结束
f（具有1方法的泛型函数）

朱莉娅>f(stdout)
[医]龙
julia>f（IOContext（stdout，：short=>true））
短

IOContext(io::IO,context::IOContext)

show([io::IO = stdout], x)

julia> show("Hello World!")
"Hello World!"
julia> print("Hello World!")
Hello World!

summary(io::IO, x)
str = summary(x)

julia> summary(1)
"Int64"

julia> summary(zeros(2))
"2-element Vector{Float64}"

print([io::IO], xs...)

julia> print("Hello World!")
Hello World!
julia> io = IOBuffer();

julia> print(io, "Hello", ' ', :World!)

julia> String(take!(io))
"Hello World!"

println([io::IO], xs...)

julia> println("Hello, world")
Hello, world

julia> io = IOBuffer();

julia> println(io, "Hello", ',', " world.")

julia> String(take!(io))
"Hello, world.\n"

printstyled([io], xs...; bold::Bool=false, italic::Bool=false, underline::Bool=false, blink::Bool=false, reverse::Bool=false, hidden::Bool=false, color::Union{Symbol,Int}=:normal)

sprint(f::Function, args...; context=nothing, sizehint=0)

julia> sprint(show, 66.66666; context=:compact => true)
"66.6667"

julia> sprint(showerror, BoundsError([1], 100))
"BoundsError: attempt to access 1-element Vector{Int64} at index [100]"

showerror(io, e)

julia> struct MyException <: Exception
           msg::String
       end

julia> function Base.showerror(io::IO, err::MyException)
           print(io, "MyException: ")
           print(io, err.msg)
       end

julia> err = MyException("test exception")
MyException("test exception")

julia> sprint(showerror, err)
"MyException: test exception"

julia> throw(MyException("test exception"))
ERROR: MyException: test exception

dump(x; maxdepth=8)

julia> struct MyStruct
           x
           y
       end

julia> x = MyStruct(1, (2,3));

julia> dump(x)
MyStruct
  x: Int64 1
  y: Tuple{Int64, Int64}
    1: Int64 2
    2: Int64 3

julia> dump(x; maxdepth = 1)
MyStruct
  x: Int64 1
  y: Tuple{Int64, Int64}

@dump expr

readline(io::IO=stdin; keep::Bool=false)
readline(filename::AbstractString; keep::Bool=false)

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readline("my_file.txt")
"JuliaLang is a GitHub organization."

julia>readline("my_file.txt"，保持=true）
"JuliaLang是一个GitHub组织。\n"

julia>rm("my_file.txt"）

julia> print("Enter your name: ")
Enter your name:

julia> your_name = readline()
Logan
"Logan"

readuntil(stream::IO, delim; keep::Bool = false)
readuntil(filename::AbstractString, delim; keep::Bool = false)

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readuntil("my_file.txt", 'L')
"Julia"

julia> readuntil("my_file.txt", '.', keep = true)
"JuliaLang is a GitHub organization."

julia> rm("my_file.txt")

readlines(io::IO=stdin; keep::Bool=false)
readlines(filename::AbstractString; keep::Bool=false)

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readlines("my_file.txt")
2-element Vector{String}:
 "JuliaLang is a GitHub organization."
 "It has many members."

julia> readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "JuliaLang is a GitHub organization.\n"
 "It has many members.\n"

julia> rm("my_file.txt")

eachline(io::IO=stdin; keep::Bool=false)
eachline(filename::AbstractString; keep::Bool=false)

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\n It has many members.\n");

julia> for line in eachline("my_file.txt")
           print(line)
       end
JuliaLang is a GitHub organization. It has many members.

julia> rm("my_file.txt");

copyline(out::IO, io::IO=stdin; keep::Bool=false)
copyline(out::IO, filename::AbstractString; keep::Bool=false)

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyline(IOBuffer(), "my_file.txt")))
"JuliaLang is a GitHub organization."

julia> String(take!(copyline(IOBuffer(), "my_file.txt", keep=true)))
"JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt")

copyuntil(out::IO, stream::IO, delim; keep::Bool = false)
copyuntil(out::IO, filename::AbstractString, delim; keep::Bool = false)

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", 'L')))
"Julia"

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", '.', keep = true)))
"JuliaLang is a GitHub organization."

julia> rm("my_file.txt")

displaysize([io::IO]) -> (lines, columns)

julia> withenv("LINES" => 30, "COLUMNS" => 100) do
           displaysize()
       end
(30, 100)

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

display(x)
display(d::AbstractDisplay, x)
display(mime, x)
display(d::AbstractDisplay, mime, x)

redisplay(x)
redisplay(d::AbstractDisplay, x)
redisplay(mime, x)
redisplay(d::AbstractDisplay, mime, x)

displayable(mime) -> Bool
displayable(d::AbstractDisplay, mime) -> Bool

show(io::IO, mime, x)

julia> struct Day
           n::Int
       end

julia> Base.show(io::IO, ::MIME"text/plain", d::Day) = print(io, d.n, " day")

julia> Day(1)
1 day

showable(mime, x)

julia> showable(MIME("text/plain"), rand(5))
true

julia> showable("image/png", rand(5))
false

repr(mime, x; context=nothing)

julia> A = [1 2; 3 4];

julia> repr("text/plain", A)
"2×2 Matrix{Int64}:\n 1  2\n 3  4"

MIME

julia> show(stdout, MIME("text/plain"), "hi")
"hi"

@MIME_str

pushdisplay(d::AbstractDisplay)

popdisplay()
popdisplay(d::AbstractDisplay)

TextDisplay(io::IO)

istextmime(m::MIME)

julia> istextmime(MIME("text/plain"))
true

julia> istextmime(MIME("image/png"))
false

bytesavailable(io)

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> bytesavailable(io)
34

ntoh(x)

hton(x)

ltoh(x)

htol(x)

ENDIAN_BOM