I/O and Network

stdout::IO

全局变量，指向标准输出流。

stderr::IO

全局变量，指向标准错误流。

stdin::IO

全局变量，指向标准输入流。

read(filename::AbstractString)

将文件的全部内容读取为 Vector{UInt8}。

read(filename::AbstractString, String)

将文件的全部内容读取为字符串。

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

打开一个文件并读取其内容。args 被传递给 read：这相当于 open(io->read(io, args...), filename)。

write(filename::AbstractString, content)

将 content 的规范二进制表示写入文件，如果文件尚不存在，则会创建该文件；如果文件已存在，则会覆盖该文件。

返回写入文件的字节数。

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

将函数 f 应用到 open(args...; kwargs...) 的结果上，并在完成后关闭结果文件描述符。

示例

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

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

julia> rm("myfile.txt")

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

以五个布尔关键字参数指定的模式打开文件：

当没有传递关键字时，默认以只读模式打开文件。返回一个用于访问打开文件的流。

lock关键字参数控制操作是否会被锁定以确保安全的多线程访问。

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

打开的替代语法，其中使用基于字符串的模式说明符，而不是五个布尔值。mode 的值对应于 fopen(3) 或 Perl open 中的值，并等同于设置以下布尔组：

lock 关键字参数控制操作是否会被锁定以确保安全的多线程访问。

示例

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, "This file is read only")
ERROR: ArgumentError: write failed, IOStream is not writeable
[...]

julia> close(io)

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

julia> write(io, "This stream is not read only")
28

julia> close(io)

julia> rm("myfile.txt")

open(fd::OS_HANDLE) -> IO

将原始文件描述符包装在一个Julia感知的IO类型中，并接管fd句柄的所有权。调用open(Libc.dup(fd))以避免原始句柄的所有权捕获。

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

异步运行 command。类似于 open(command, stdio; read, write)，但通过模式字符串而不是关键字参数来指定读取和写入标志。可能的模式字符串有：

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

开始异步运行 command，并返回一个 process::IO 对象。如果 read 为真，则从进程的标准输出读取数据，stdio 可选地指定进程的标准输入流。如果 write 为真，则写入数据到进程的标准输入，stdio 可选地指定进程的标准输出流。进程的标准错误流连接到当前全局的 stderr。

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

类似于 open(command, args...; kwargs...)，但在结果进程流上调用 f(stream)，然后关闭输入流并等待进程完成。成功时返回 f 返回的值。如果进程失败，或者进程尝试向 stdout 打印任何内容，则抛出错误。

IOStream

一个缓冲的 IO 流，包装一个操作系统文件描述符。主要用于表示由 open 返回的文件。

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

创建一个内存中的 I/O 流，可以选择性地操作一个预先存在的数组。

它可以接受可选的关键字参数：

• read, write, append: 限制操作在缓冲区内；有关详细信息，请参见 open。
• truncate: 将缓冲区大小截断为零长度。
• maxsize: 指定缓冲区不能超过的大小。
• sizehint: 建议缓冲区的容量（data 必须实现 sizehint!(data, size)）。

当未给定 data 时，缓冲区默认是可读和可写的。

示例

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

IOBuffer(string::String)

在给定字符串的基础上创建一个只读的 IOBuffer。

示例

julia> io = IOBuffer("Haho");

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

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

take!(b::IOBuffer)

获取 IOBuffer 的内容作为数组。之后，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."

Pipe()

构造一个未初始化的 Pipe 对象，特别用于多个进程之间的 IO 通信。

如果在进程生成中使用该对象，管道的适当端将自动初始化。这对于在进程管道中轻松获取引用非常有用，例如：

julia> err = Pipe()

# 在此之后，`err` 将被初始化，您可以从 `err` 管道读取 `foo` 的
# stderr，或者将 `err` 传递给其他管道。
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# 现在销毁管道的写入部分，以便读取部分将获得 EOF
julia> closewrite(err)

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

另请参见 Base.link_pipe!.

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

初始化 pipe 并将 in 端点链接到 out 端点。关键字参数 reader_supports_async/writer_supports_async 对应于 Windows 上的 OVERLAPPED 和 POSIX 系统上的 O_NONBLOCK。除非将被外部程序使用（例如，通过 run 执行的命令的输出），否则它们应该为 true。

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

从整数文件描述符创建一个IOStream对象。如果own为true，关闭此对象将关闭底层描述符。默认情况下，当IOStream被垃圾回收时会被关闭。name允许您将描述符与命名文件关联。

flush(stream)

将所有当前缓冲的写入提交到给定的流。

close(stream)

关闭一个 I/O 流。首先执行 flush。

closewrite(stream)

关闭全双工 I/O 流的写入部分。首先执行 flush。通知另一端不再向底层文件写入数据。这并不是所有 I/O 类型都支持的。

如果实现了 closewrite，则后续的 read 或 eof 调用如果会阻塞，则会抛出 EOF 或分别返回 true。如果流已经关闭，这个操作是幂等的。

示例

julia> io = Base.BufferStream(); # 这永远不会阻塞，因此我们可以在同一个任务上进行读写

julia> write(io, "request");

julia> # 在这里调用 `read(io)` 会永远阻塞

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

将值的规范二进制表示写入给定的 I/O 流或文件。返回写入流中的字节数。另请参见 print 以写入文本表示（其编码可能依赖于 io）。

写入值的字节序取决于主机系统的字节序。在写入/读取时转换为/从固定字节序（例如使用 htol 和 ltoh）以获得跨平台一致的结果。

您可以使用相同的 write 调用写入多个值。即以下两者是等效的：

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

示例

一致的序列化：

julia> fname = tempname(); # 随机临时文件名

julia> open(fname,"w") do f
           # 确保我们以小端字节顺序写入 64 位整数
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # 转换回主机字节顺序和主机整数类型
           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."

没有 write 方法的用户定义的简单数据类型可以在 Ref 中包装后写入：

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(io::IO, T)

从 io 中读取一个类型为 T 的单个值，采用规范的二进制表示。

请注意，Julia 不会为您转换字节序。请使用 ntoh 或 ltoh 来实现此目的。

read(io::IO, String)

将 io 的全部内容读取为 String（另见 readchomp）。

示例

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(filename::AbstractString)

将文件的全部内容读取为 Vector{UInt8}。

read(filename::AbstractString, String)

将文件的全部内容读取为字符串。

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

打开一个文件并读取其内容。args 被传递给 read：这相当于 open(io->read(io, args...), filename)。

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

从 s 中最多读取 nb 字节，返回读取的字节的 Vector{UInt8}。

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

从 s 中最多读取 nb 字节，返回读取的字节的 Vector{UInt8}。

如果 all 为 true（默认值），此函数将阻塞并反复尝试读取所有请求的字节，直到发生错误或文件结束。如果 all 为 false，则最多执行一次 read 调用，返回的数据量依赖于设备。请注意，并非所有流类型都支持 all 选项。

read(command::Cmd)

运行 command 并将结果输出作为字节数组返回。

read(command::Cmd, String)

运行 command 并将结果输出作为 String 返回。

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

从 I/O 流或文件中读取二进制数据，填充 array。

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

从 stream 中最多读取 nb 个字节到 b，返回读取的字节数。如果需要，b 的大小将会增加（即如果 nb 大于 length(b) 并且可以读取足够的字节），但永远不会减少。

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

从 stream 中最多读取 nb 字节到 b，返回读取的字节数。如果需要，b 的大小将会增加（即如果 nb 大于 length(b) 并且可以读取足够的字节），但永远不会减少。

如果 all 为 true（默认值），此函数将会阻塞并重复尝试读取所有请求的字节，直到发生错误或文件结束。如果 all 为 false，最多只执行一次 read 调用，返回的数据量依赖于设备。请注意，并非所有流类型都支持 all 选项。

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

将 nbytes 从 IO 流对象复制到 ref（转换为指针）。

建议子类型 T<:IO 重写以下方法签名，以提供更高效的实现：unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

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

将 ref（转换为指针）中的 nbytes 复制到 IO 对象中。

建议子类型 T<:IO 重写以下方法签名，以提供更高效的实现：unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

返回一个可迭代对象，生成 read(io, T)。

另请参见 skipchars，eachline，readuntil。

示例

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

从流中读取并返回类型 T 的值，而不推进流中的当前位置。另见 startswith(stream, char_or_string)。

示例

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)

返回当前的位置。

位置

获取流的当前位置信息。

示例

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 (类别 Lu: 字母, 大写)

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 (类别 Lu: 字母，大写)

mark(s::IO)

在流s的当前位置添加一个标记。返回标记的位置。

另请参见 unmark, reset, ismarked.

unmark(s::IO)

从流 s 中移除标记。如果流被标记，则返回 true，否则返回 false。

另见 mark, reset, ismarked.

reset(s::IO)

将流 s 重置为先前标记的位置，并移除标记。返回先前标记的位置。如果流未标记，则抛出错误。

另请参见 mark, unmark, ismarked.

ismarked(s::IO)

如果流 s 被标记，则返回 true。

另请参见 mark, unmark, reset。

eof(stream) -> Bool

测试一个 I/O 流是否到达文件末尾。如果流尚未耗尽，则此函数将在必要时阻塞以等待更多数据，然后返回 false。因此，在看到 eof 返回 false 后，始终安全地读取一个字节。只要缓冲的数据仍然可用，即使连接的远程端已关闭，eof 也会返回 false。

示例

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

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)

如果给定 path 的访问权限允许当前用户写入，则返回 true。

另请参见 ispath, isexecutable, isreadable。

iswritable(io) -> Bool

如果指定的 IO 对象不可写，则返回 false。

示例

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)

如果给定 path 的访问权限允许当前用户读取，则返回 true。

另请参见 ispath, isexecutable, iswritable。

isreadable(io) -> Bool

如果指定的 IO 对象不可读，则返回 false。

示例

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)

如果给定的 path 具有可执行权限，则返回 true。

另请参见 ispath，isreadable，iswritable。

isopen(object) -> Bool

确定一个对象 - 例如流或定时器 - 是否尚未关闭。一旦对象关闭，它将永远不会产生新的事件。然而，由于关闭的流可能仍然在其缓冲区中有数据可读，因此使用 eof 来检查是否能够读取数据。使用 FileWatching 包来接收通知，当流可能可写或可读时。

示例

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

返回支持该流或文件的文件描述符。请注意，此函数仅适用于同步的 File 和 IOStream，不适用于任何异步流。

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

重定向一部分流 stdin、stderr、stdout。每个参数必须是 IOStream、TTY、Pipe、套接字或 devnull。

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

重定向部分流 stdin、stderr、stdout，调用 f() 并恢复每个流。

每个流的可能值为：

• nothing 表示该流不应被重定向。
• path::AbstractString 将流重定向到 path 处的文件。
• io 一个 IOStream、TTY、Pipe、套接字或 devnull。

示例

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"

边缘情况

可以将相同的参数传递给 stdout 和 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) # 不支持

此外，stdin 参数不能与 stdout 或 stderr 是相同的描述符。

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # 不支持

redirect_stdout([stream]) -> stream

创建一个管道，所有 C 和 Julia 级别的 stdout 输出将被重定向到该管道。返回一个表示管道两端的流。写入 stdout 的数据现在可以从管道的 rd 端读取。

另见 redirect_stdio。

redirect_stdout(f::Function, stream)

在重定向 stdout 到 stream 的情况下运行函数 f。完成后，stdout 将恢复到之前的设置。

redirect_stderr([stream]) -> stream

类似于 redirect_stdout，但用于 stderr。

另见 redirect_stdio。

redirect_stderr(f::Function, stream)

在重定向 stderr 到 stream 的情况下运行函数 f。完成后，stderr 将恢复到之前的设置。

redirect_stdin([stream]) -> stream

类似于 redirect_stdout，但用于 stdin。请注意，流的方向是相反的。

另见 redirect_stdio。

redirect_stdin(f::Function, stream)

在重定向 stdin 到 stream 的情况下运行函数 f。完成后，stdin 将恢复到其先前的设置。

readchomp(x)

将 x 的全部内容作为字符串读取，并在有的情况下去除一个尾随换行符。等价于 chomp(read(x, String))。

示例

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)

将第一个参数给定的文件或缓冲区的大小调整为正好 n 字节，如果文件或缓冲区被扩展，则用 '\0' 填充之前未分配的空间。

示例

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)

推进流 io，使得下一个读取的字符将是 predicate 返回 false 的第一个剩余字符。如果指定了关键字参数 linecomment，则从该字符开始到下一行的开始之间的所有字符都将被忽略。

示例

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

读取 io 直到流/文件的末尾并计算行数。要指定文件，请将文件名作为第一个参数传递。通过将其他 EOL 标记作为第二个参数传递来支持。即使最后一行非空的 io 不以 EOL 结尾，也会被计入行数，这与 eachline 和 readlines 返回的长度相匹配。

要计算 String 的行数，可以使用 countlines(IOBuffer(str))。

示例

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) # 计数行会移动文件指针
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))

一个 IOBuffer，允许通过追加的方式进行读取和写入。不支持寻址和截断。有关可用构造函数，请参见 IOBuffer。如果提供了 data，则创建一个 PipeBuffer 以在数据向量上操作， optionally 指定一个大小，超出该大小底层的 Array 可能无法增长。

readavailable(stream)

从流中读取可用的缓冲数据。只有在没有数据被缓冲的情况下，才会执行实际的输入/输出。结果是一个 Vector{UInt8}。

IOContext

IOContext 提供了一种在 show 方法之间传递输出配置设置的机制。

简而言之，它是一个不可变字典，是 IO 的子类。它支持标准字典操作，如 getindex，并且也可以用作 I/O 流。

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

创建一个 IOContext，它包装了给定的流，并将指定的 key=>value 对添加到该流的属性中（注意 io 本身可以是一个 IOContext）。

• 使用 (key => value) in io 来查看这个特定的组合是否在属性集中
• 使用 get(io, key, default) 来检索特定键的最新值

以下属性是常用的：

• :compact：布尔值，指定值应该更紧凑地打印，例如，数字应该用更少的数字打印。当打印数组元素时设置此项。:compact 输出不应包含换行符。
• :limit：布尔值，指定容器应该被截断，例如，用 … 替代大多数元素。
• :displaysize：一个 Tuple{Int,Int}，给出用于文本输出的行和列的大小。这可以用来覆盖调用函数的显示大小，但要获取屏幕的大小，请使用 displaysize 函数。
• :typeinfo：一个 Type，表征关于即将显示的对象类型的已打印信息。这在显示同一类型的对象集合时特别有用，以避免冗余的类型信息（例如，[Float16(0)] 可以显示为 "Float16[0.0]" 而不是 "Float16[Float16(0.0)]"：在显示数组元素时，:typeinfo 属性将被设置为 Float16）。
• :color：布尔值，指定是否支持/期望 ANSI 颜色/转义代码。默认情况下，这由 io 是否是兼容终端以及在启动 julia 时的任何 --color 命令行标志决定。

示例

julia> io = IOBuffer();

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

julia> String(take!(io))
"\e[31mstring\e[39m"

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

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

julia> print(IOContext(stdout, :compact => false), 1.12341234)
1.12341234
julia> print(IOContext(stdout, :compact => true), 1.12341234)
1.12341

julia> function f(io::IO)
           if get(io, :short, false)
               print(io, "short")
           else
               print(io, "loooooong")
           end
       end
f (generic function with 1 method)

julia> f(stdout)
loooooong
julia> f(IOContext(stdout, :short => true))
short

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

创建一个 IOContext，它包装一个替代的 IO，但继承 context 的属性。

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

将值 x 的文本表示写入输出流 io。新类型 T 应重载 show(io::IO, x::T)。show 使用的表示通常包括特定于 Julia 的格式和类型信息，并且在可能的情况下应可解析为 Julia 代码。

repr 返回 show 的输出作为字符串。

对于类型 T 的对象，若要获得更详细的人类可读文本输出，请另外定义 show(io::IO, ::MIME"text/plain", ::T)。建议在此类方法中检查 io 的 :compact IOContext 键（通常检查为 get(io, :compact, false)::Bool），因为某些容器通过调用此方法并传递 :compact => true 来显示其元素。

另请参见 print，它写入未修饰的表示。

示例

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

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

打印到流 io，或返回字符串 str，提供值的简要描述。默认返回 string(typeof(x))，例如 Int64。

对于数组，返回大小和类型信息的字符串，例如 10-element Array{Int64,1}。

示例

julia> summary(1)
"Int64"

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

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

将文本的规范（未修饰）表示写入 io（如果未给出 io，则写入默认输出流 stdout）。print 使用的表示包括最小格式，并尽量避免 Julia 特有的细节。

print 会回退到调用 show，因此大多数类型只需定义 show。如果您的类型有单独的“普通”表示，请定义 print。例如，show 用引号显示字符串，而 print 则不使用引号显示字符串。

另请参见 println、string、printstyled。

示例

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

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

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

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

将 xs 打印到 io，后面跟一个换行符（使用 print）。如果未提供 io，则打印到默认输出流 stdout。

另请参见 printstyled 以添加颜色等。

示例

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)

以符号或整数指定的颜色打印 xs，可选地以粗体显示。

关键字 color 可以取以下任意值 :normal, :italic, :default, :bold, :black, :blink, :blue, :cyan, :green, :hidden, :light_black, :light_blue, :light_cyan, :light_green, :light_magenta, :light_red, :light_white, :light_yellow, :magenta, :nothing, :red, :reverse, :underline, :white, 或 :yellow，或一个介于 0 和 255 之间的整数（包括 0 和 255）。请注意，并非所有终端都支持 256 种颜色。

关键字 bold=true、italic=true、underline=true、blink=true 是不言自明的。关键字 reverse=true 以交换前景和背景颜色的方式打印，而 hidden=true 在终端中应不可见，但仍可被复制。这些属性可以以任意组合使用。

另见 print, println, show.

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

调用给定的函数，使用 I/O 流和提供的额外参数。写入此 I/O 流的所有内容将作为字符串返回。context 可以是一个 IOContext，其属性将被使用，也可以是一个指定属性及其值的 Pair，或者是一个指定多个属性及其值的 Pair 元组。sizehint 建议缓冲区的容量（以字节为单位）。

可选的关键字参数 context 可以设置为 :key=>value 对，:key=>value 对的元组，或者是一个 IO 或 IOContext 对象，其属性用于传递给 f 的 I/O 流。可选的 sizehint 是建议的大小（以字节为单位），用于分配写入字符串所用的缓冲区。

示例

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)

显示异常对象 e 的描述性表示。此方法用于在调用 throw 后显示异常。

示例

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)

显示值的表示的每个部分。输出的深度在 maxdepth 处被截断。

示例

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

显示给定表达式的表示的每个部分。等同于 dump(:(expr))。

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

从给定的 I/O 流或文件中读取一行文本（默认为 stdin）。从文件读取时，假定文本编码为 UTF-8。输入中的行以 '\n' 或 "\r\n" 或输入流的结束结束。当 keep 为 false（默认情况下为 false）时，这些尾随换行符在返回之前会从行中删除。当 keep 为 true 时，它们作为行的一部分返回。

返回一个 String。另请参见 copyline，以便在另一个流中就地写入（该流可以是预分配的 IOBuffer）。

另请参见 readuntil，以便读取直到更一般的分隔符。

示例

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", keep=true)
"JuliaLang is a GitHub organization.\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)

从 I/O stream 或文件中读取字符串，直到给定的分隔符。分隔符可以是 UInt8、AbstractChar、字符串或向量。关键字参数 keep 控制分隔符是否包含在结果中。文本假定为 UTF-8 编码。

如果 delim 是 AbstractChar 或字符串，则返回 String，否则返回 Vector{typeof(delim)}。另请参见 copyuntil，以便将内容就地写入另一个流（可以是预分配的 IOBuffer）。

示例

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)

将 I/O 流或文件的所有行作为字符串向量读取。行为等同于使用相同参数重复调用 readline 并将结果行保存为字符串向量。另请参见 eachline，以便在不一次性读取所有行的情况下迭代行。

示例

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)

创建一个可迭代的 EachLine 对象，该对象将从 I/O 流或文件中逐行输出。迭代调用 readline 在流参数上重复执行，并传递 keep，以确定是否保留尾随的行结束符。当使用文件名调用时，文件在迭代开始时打开，并在结束时关闭。如果迭代被中断，文件将在 EachLine 对象被垃圾回收时关闭。

要迭代 String 的每一行，可以使用 eachline(IOBuffer(str))。

可以在 EachLine 对象上使用 Iterators.reverse 以反向顺序读取行（对于支持 seek 的文件、缓冲区和其他 I/O 流），并且可以使用 first 或 last 分别提取初始或最终行。

示例

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)

从 I/O 流 或文件中复制一行文本到 out 流，返回 out。

当从文件中读取时，文本假定为 UTF-8 编码。输入中的行以 '\n' 或 "\r\n" 或输入流的结束符结束。当 keep 为 false（默认情况下为 false）时，这些尾随换行符在返回之前会从行中移除。当 keep 为 true 时，它们作为行的一部分返回。

类似于 readline，它返回一个 String；而 copyline 直接写入 out，而不分配字符串。（这可以用于，例如，将数据读取到预分配的 IOBuffer 中。）

另请参见 copyuntil，用于读取直到更一般的分隔符。

示例

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)

从 I/O stream 或文件中复制字符串，直到给定的分隔符，将其写入 out 流，并返回 out。分隔符可以是 UInt8、AbstractChar、字符串或向量。关键字参数 keep 控制分隔符是否包含在结果中。文本假定为 UTF-8 编码。

类似于 readuntil，它返回一个 String；而 copyuntil 直接写入 out，而不分配字符串。（这可以用于，例如，将数据读取到预分配的 IOBuffer 中。）

示例

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)

返回可以用于渲染输出到此 IO 对象的屏幕的名义大小。如果未提供输入，则读取环境变量 LINES 和 COLUMNS。如果这些未设置，则返回默认大小 (24, 80)。

示例

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

要获取您的 TTY 大小，

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

丰富显示输出设备的抽象超类型。 TextDisplay 是其子类型。

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

使用显示栈中最上层的适用显示来显示 x，通常使用 x 支持的最丰富的多媒体输出，作为后备使用纯文本 stdout 输出。display(d, x) 变体尝试仅在给定的显示 d 上显示 x，如果 d 不能显示此类型的对象，则抛出 MethodError。

一般来说，您不能假设 display 输出会发送到 stdout（与 print(x) 或 show(x) 不同）。例如，display(x) 可能会打开一个单独的窗口显示图像。display(x) 的意思是“以您能为当前输出设备显示 x 的最佳方式。”如果您想要保证发送到 stdout 的类似 REPL 的文本输出，请使用 show(stdout, "text/plain", x)。

还有两个带有 mime 参数的变体（一个 MIME 类型字符串，例如 "image/png"），它们尝试仅使用请求的 MIME 类型显示 x，如果此类型不被显示（s）或 x 支持，则抛出 MethodError。使用这些变体，您还可以通过传递 x::AbstractString（对于具有基于文本存储的 MIME 类型，例如 text/html 或 application/postscript）或 x::Vector{UInt8}（对于二进制 MIME 类型）来提供请求的 MIME 类型的“原始”数据。

要自定义如何显示类型的实例，请重载 show，而不是 display，如手册中关于 自定义美观打印 的部分所述。

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

默认情况下，redisplay 函数简单地调用 display。然而，一些显示后端可能会重写 redisplay 以修改现有的 x 的显示（如果有的话）。使用 redisplay 也是对后端的一个提示，表明 x 可能会被多次重新显示，后端可能会选择推迟显示，直到（例如）下一个交互提示。

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

返回一个布尔值，指示给定的 mime 类型（字符串）是否可以被当前显示堆栈中的任何显示器显示，或者在第二个变体中是否可以被显示器 d 显示。

show(io::IO, mime, x)

display 函数最终调用 show，以便将对象 x 作为给定的 mime 类型写入给定的 I/O 流 io（通常是内存缓冲区），如果可能的话。为了提供用户定义类型 T 的丰富多媒体表示，只需通过以下方式为 T 定义一个新的 show 方法：show(io, ::MIME"mime", x::T) = ...，其中 mime 是一个 MIME 类型字符串，函数体调用 write（或类似的）将 x 的表示写入 io。（请注意，MIME"" 语法仅支持字面字符串；要以更灵活的方式构造 MIME 类型，请使用 MIME{Symbol("")}。）

例如，如果您定义了一个 MyImage 类型并知道如何将其写入 PNG 文件，您可以定义一个函数 show(io, ::MIME"image/png", x::MyImage) = ...，以允许您的图像在任何支持 PNG 的 AbstractDisplay（例如 IJulia）上显示。像往常一样，请确保 import Base.show 以便为内置的 Julia 函数 show 添加新方法。

从技术上讲，MIME"mime" 宏为给定的 mime 字符串定义了一个单例类型，这使我们能够利用 Julia 的调度机制来确定如何显示任何给定类型的对象。

默认的 MIME 类型是 MIME"text/plain"。对于 text/plain 输出，有一个后备定义，它调用带有 2 个参数的 show，因此并不总是需要为该情况添加方法。不过，如果某个类型受益于自定义的人类可读输出，则应定义 show(::IO, ::MIME"text/plain", ::T)。例如，Day 类型使用 1 day 作为 text/plain MIME 类型的输出，而 Day(1) 作为 2 个参数 show 的输出。

示例

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

容器类型通常通过对元素 x 调用 show(io, MIME"text/plain"(), x) 来实现 3 个参数的 show，并在作为第一个参数传递的 IOContext 中设置 :compact => true。

showable(mime, x)

返回一个布尔值，指示对象 x 是否可以作为给定的 mime 类型进行写入。

（默认情况下，这通过检查 typeof(x) 的相应 show 方法的存在来自动确定。一些类型提供自定义的 showable 方法；例如，如果可用的 MIME 格式依赖于 x 的 值。）

示例

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

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

repr(mime, x; context=nothing)

返回一个 AbstractString 或 Vector{UInt8}，包含以请求的 mime 类型表示的 x，如 show(io, mime, x) 所示（如果没有合适的 show 可用，则抛出 MethodError）。对于具有文本表示的 MIME 类型（例如 "text/html" 或 "application/postscript"），返回 AbstractString，而二进制数据则返回 Vector{UInt8}。（函数 istextmime(mime) 返回 Julia 是否将给定的 mime 类型视为文本。）

可选的关键字参数 context 可以设置为 :key=>value 对或一个 IO 或 IOContext 对象，其属性用于传递给 show 的 I/O 流。

作为特例，如果 x 是 AbstractString（对于文本 MIME 类型）或 Vector{UInt8}（对于二进制 MIME 类型），则 repr 函数假定 x 已经是请求的 mime 格式，并简单地返回 x。此特例不适用于 "text/plain" MIME 类型。这对于将原始数据传递给 display(m::MIME, x) 很有用。

特别地，repr("text/plain", x) 通常是为人类消费而设计的 x 的“美观打印”版本。另请参见 repr(x)，以返回一个字符串，对应于 show(x)，可能更接近于 x 的值在 Julia 中的输入方式。

示例

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

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

MIME

表示标准互联网数据格式的类型。“MIME”代表“多用途互联网邮件扩展”，因为该标准最初用于描述电子邮件消息的多媒体附件。

MIME 对象可以作为第二个参数传递给 show，以请求以该格式输出。

示例

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

@MIME_str

一个方便的宏，用于编写 MIME 类型，通常在向 show 添加方法时使用。例如，语法 show(io::IO, ::MIME"text/html", x::MyType) = ... 可用于定义如何写出 MyType 的 HTML 表示。

pushdisplay(d::AbstractDisplay)

将新的显示 d 推送到全局显示后端栈的顶部。调用 display(x) 或 display(mime, x) 将在栈中最上面的兼容后端上显示 x（即，最上面的不会抛出 MethodError 的后端）。

popdisplay()
popdisplay(d::AbstractDisplay)

从显示后端堆栈中弹出最上面的后端，或者在第二种变体中弹出 d 的最上面副本。

TextDisplay(io::IO)

返回一个 TextDisplay <: AbstractDisplay，它将任何对象显示为 text/plain MIME 类型（默认情况下），并将文本表示写入给定的 I/O 流。这就是对象在 Julia REPL 中打印的方式。

istextmime(m::MIME)

确定一个 MIME 类型是否为文本数据。MIME 类型被假定为二进制数据，除非是已知为文本数据（可能是 Unicode）的一组类型。

示例

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

32位字节顺序标记指示主机的本机字节顺序。小端机器将包含值 0x04030201。大端机器将包含值 0x01020304。