Engee 文档

I/O和网络

通用I/O

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...），文件名）'。

write(filename::AbstractString, content)

将"内容"的规范二进制表示形式写入将创建的文件，如果该文件尚不存在，或以其他方式复盖该文件。

返回写入文件的字节数。

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

将函数`f’应用于结果'open(args...;夸格斯。..)`并在完成后关闭结果文件的句柄。

例子

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’参数确定是否会阻止操作以进行安全的多线程访问。

兼容性：Julia1.5

'Lock’参数首先在Julia1.5中实现。

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

一种替代的开头语法，它使用基于字符串操作的模式描述符而不是五个逻辑参数。 'Mode’值对应于`fopen(3)`或Perl`open`中的值，相当于配置以下逻辑组:

模式 资料描述 命名参数

'r`

阅读

非也。

'w`

阅读、创作、裁剪

'写=真`

a

阅读，创造

'append=true`

'r+`

阅读，写作

'读=真，写=真`

'w+`

阅读，写作，创作，裁剪

'truncate=true,read=true`

a+

阅读、写作、创作、加入

"append=true,read=true`

命名的’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")
兼容性：Julia1.5

'Lock’参数首先在Julia1.5中实现。

 
open(fd::OS_HANDLE) -> IO

将原始文件描述符封装在启用Julia的I/O类型中，并获得文件设备描述符的所有权。 Calls’open(Libc.dup(fd))`来防止源描述符的所有权转移。

不要为已由系统的另一部分拥有的句柄调用此函数。

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

在异步模式下执行’命令'。 类似于’open(command,stdio;read,write)`，不同之处在于使用模式字符串而不是命名参数设置读写标志。 以下模式行是可能的:

模式 资料描述 命名参数

'r`

阅读

非也。

'w`

记录

'写=真`

'r+`

阅读，写作

'读=真，写=真`

'w+`

阅读，写作

'读=真，写=真`

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

开始在异步模式下执行’command’并返回’process::IO`对象。 如果’read’设置为true，则从进程的标准输出接收正在读取的进程数据，并且进程的标准输入流另外设置为’stdio'。 如果’write’设置为true，则正在写入的数据被发送到进程的标准输入，并且进程的标准输出流被另外设置为’stdio'。 进程的标准错误流连接到当前全局’stderr'。

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

同样’open(command,args...;夸格斯。..），但导致产生的进程流的`f（stream），然后关闭输入流并等待进程完成。 如果成功，则返回’f’返回的值。 如果进程失败或尝试在stdout中打印数据，则会发生错误。

IOStream

一个缓冲的I/O流，其中封装了OS文件描述符。 在大多数情况下，它用于表示返回的文件 '打开`。

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

在内存中创建一个I/O流，该流可以另外对现有数组执行操作。

可选的命名参数可能是必需的。:

  • 'read','write','append`:限制缓冲区操作;有关更多信息，请参阅’open'。

  • 'truncate'：将缓冲区大小截断为零长度。

  • 'maxsize'：设置缓冲区不能增加的大小。

  • sizehint：建议缓冲区容量（data`应该实现’sizehint！(数据，大小))。

如果省略了’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()

创建未初始化的管道对象（pipeline），特别是用于多个进程之间的I/O操作。

如果在进程生成时使用对象，则管道的相应末端将自动初始化。 这对于在流程管道中轻松获取引用非常有用，例如:

julia> err = Pipe()

# После этого `err` будет инициализирован и можно будет прочитать поток stderr
# `foo` из конвейера `err` или передать `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)

初始化’管道`并将`in`端点绑定到’out’端点。 命名参数’reader_supports_async’和’writer_supports_async`对应于Windows上的`OVERLAPPED’和POSIX系统上的`O_NONBLOCK'。 它们必须具有值"true"，除非它们被外部程序使用（例如，通过输出使用 '运行'）。

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

创建对象 'IOStream'基于整数文件描述符。 如果’own’具有值’true'，则在关闭此对象时，基描述符也会关闭。 默认情况下，"IOStream"在执行垃圾回收时关闭。 "名称"允许您将描述符与命名文件相关联。

flush(stream)

捕获给定流中所有先前缓冲的写操作。

close(stream)

关闭I/O流。 首先，它运行 '冲洗'。

closewrite(stream)

停止记录全双工I/O流的一半。 首先，它运行 '冲洗'。 通知另一方不再将数据写入基本文件。 某些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)

将值的规范二进制表示形式写入指定的输入/输出流或文件。 返回写入流的字节数。 另请参阅功能说明 `print'，它写入文本表示（以依赖于`io’的编码）。

记录值中的字节顺序取决于主机系统中的字节顺序。 在写入或读取的过程中，它执行到或从固定字节顺序的转换（例如，使用 'htol'和 'ltoh')以便结果跨平台一致。

您可以通过一次"写入"调用来写入多个值，这意味着以下值是等价的:

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(读(f,Int64)))
       结束
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`完全读取为’字符串'（另请参阅 '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...），文件名）'。

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)

执行’命令’并将结果输出返回为字节数组。

read(command::Cmd, String)

执行"命令"并将结果输出返回为"字符串"。

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

通过填写"数组"从I/O流或文件中读取二进制数据。

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

从`stream`到`b`读取不超过`nb’字节，返回读取的字节数。 `B’的大小在必要时增加（也就是说，如果`nb`大于`length(b)`并且已经计数了足够数量的字节），但它从不减少。

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

从`stream`到`b`读取不超过`nb’字节，返回读取的字节数。 `B’的大小在必要时增加（也就是说，如果`nb`大于`length(b)`并且已经计数了足够数量的字节），但它从不减少。

如果’all`设置为’true'（默认情况下），则此函数将在尝试读取所有请求的字节时永久阻塞，直到发生错误或到达文件末尾。 如果’all’设置为’false`，则不会执行超过一个`read’调用，并且返回的数据量将取决于设备。 请注意，某些流类型可能不支持"all"参数。

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

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

在子类型’T<:IO`中，建议重新定义以下方法签名以提供更有效的实现：`unsafe(s::T,p::Ptr{UInt8}，n::UInt)'。

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

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

在子类型’T<:IO`中，建议重新定义以下方法签名以提供更有效的实现：`unsafe(s::T,p::Ptr{UInt8}，n::UInt)'。

readeach(io::IO, T)

返回输出的可迭代对象 '读(io,T’。

另请参阅说明 'skipchars', "每行"及 'readuntil'。

兼容性：Julia1.6

Readeach需要1.6或更高的Julia版本。

例子

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)
兼容性：Julia1.5

接受类型的方法需要Julia版本为1.5或更高版本。

 
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)

在流`s`的当前位置添加一个地标。 返回带有标签的位置。

另请参阅说明 'unmark', '重置'和 'ismarked`。

unmark(s::IO)

从"s"流中删除标签。 如果流已被标记，则返回`true`，否则返回’false'。

另请参阅说明 '标记', '重置'和 'ismarked`。

reset(s::IO)

将流`s’重置到先前标记的位置，然后删除标签。 返回先前标记的位置。 如果未标记流，则返回错误。

另请参阅说明 '标记', 'unmark'和 'ismarked`。

ismarked(s::IO)

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

另请参阅说明 '标记', 'unmark'和 '重置'。

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"。

此权限可能会在用户调用`open`之前更改，因此建议单独调用’open`并在失败的情况下处理错误，而不是首先调用`iswritable'。

目前，此函数不正确地轮询Windows文件系统ACL，因此它可能会返回不正确的结果。
兼容性：Julia1.11

此功能要求Julia的版本不低于1.11。

另请参阅说明 'ispath', 'isexecutable'和 '可读`。

iswritable(io) -> Bool

如果不支持写入指定的I/O对象，则返回"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"。

此权限可能会在用户调用`open`之前更改，因此建议单独调用’open`并在失败的情况下处理错误，而不是首先调用`isreadable'。

目前，此函数不正确地轮询Windows文件系统ACL，因此它可能会返回不正确的结果。
兼容性：Julia1.11

此功能需要Julia至少1.11的版本。

另请参阅说明 'ispath`, 'isexecutable`和 'iswritable`。

isreadable(io) -> Bool

如果不支持从指定的I/O对象读取，则返回"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)

如果指定的"路径"具有可执行文件权限，则返回"true"。

此权限可能会在用户执行`path’之前更改，因此建议执行文件并在失败的情况下处理错误，而不是首先调用’isexecutable'。

在Julia1.6之前，Windows文件系统ACL查询错误，因此对任何文件都返回值"true"。 自Julia1.6以来，该函数正确检测文件是否标记为可执行文件。

另请参阅说明 'ispath`, "可读"及 '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`, 管道，插座或’devnull'。

兼容性：Julia1.7

redirect_stdio需要Julia至少1.7的版本。

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

重定向流的子集’stdin'，'stderr`，'stdout'，调用’f（）'并恢复每个线程。

每个流的可能值:

  • 'nothing'，表示流不应该被重定向。

  • 'path::AbstractString’将流重定向到`path`中的文件。

  • 'io’和’IOStream'’TTY`, 管道，插座或’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"

朱莉娅>阅读（"stderr。txt"，字符串）
"你好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) # не поддерживается
兼容性：Julia1.7

redirect_stdio需要Julia至少1.7的版本。

 
redirect_stdout([stream]) -> stream

创建一个传输通道，将所有输出重定向到该传输通道。 `stdout'c级和朱莉娅。 返回表示传输信道末端的流。 数据写入 'stdout'，不能从`rd`传输信道的末端读取。

'stream’必须是兼容的对象，例如’IOStream'，'TTY`, 管道，插座或’devnull'。

另请参阅说明 'redirect_stdio'。

redirect_stdout(f::Function, stream)

重定向时执行’f’函数 stdout在’stream’中。 完成后，将恢复原始参数。 'stdout'。

redirect_stderr([stream]) -> stream

同样地 'redirect_stdout'，但对于 'stderr'。

'stream’必须是兼容的对象，例如’IOStream'，'TTY`, 管道，插座或’devnull'。

另请参阅说明 'redirect_stdio'。

redirect_stderr(f::Function, stream)

重定向时执行’f’函数 stderr在’流'。 完成后，将恢复原始参数。 'stderr'。

redirect_stdin([stream]) -> stream

同样地 'redirect_stdout'，但对于 'stdin'。 注意，流动方向是相反的。

'stream’必须是兼容的对象，例如’IOStream'，'TTY`, 管道，插座或’devnull'。

另请参阅说明 'redirect_stdio'。

redirect_stdin(f::Function, stream)

重定向时执行’f’函数 stdin在’stream'。 完成后，将恢复原始参数。 '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是一个GitHub组织。")
35

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

茱莉亚>字符串（拿！(io))
"朱丽朗是一个"

julia>io=IOBuffer（）;

julia>write(io,"JuliaLang是一个GitHub组织。");

julia>截断(io,40);

茱莉亚>字符串（拿！(io))
"JuliaLang是一个GitHub组织。\0\0\0\0\0"
skipchars(predicate, io::IO; linecomment=nothing)

将`io’流向前移动，以便下一个要读取的字符是其余字符中的第一个，对此，'predict’返回`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"到流或文件的末尾，并计算行数。 要指定文件，请将文件名作为第一个参数传递。 除此以外的行尾标记 Undefined control sequence \n ，通过将它们作为第二个参数传递来支持。 'Io’中的最后一个非空行被考虑在内，即使它没有以行尾标记结束，匹配返回值的长度。 "每行"及 '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'，用于对数据向量执行操作，另外指定不能增加基数组的大小。

readavailable(stream)

从流中读取可用的缓冲数据。 仅当数据尚未缓冲时才执行实际I/O。 结果是一个'向量{UInt8}`.

返回的数据量将取决于实现;例如，它可能取决于内部缓冲区大小选择。 通常应该使用其他函数来代替，例如 '读'。

 
IOContext

'IOContext’提供了一种在方法之间传递输出配置参数的机制 '显示'。

换句话说，它是一个不可变的字典，它是`IO’的子类。 它支持标准的字典操作，如 'getindex'，并且也可以用作I/O流。

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

创建一个`iocontext`，其中此流被封装，并在此流的属性中添加指定的对`key=>value`（请注意，`io`可以是`iocontext'）。

  • 在io+`中使用'+(key⇒value)来检查此特定组合是否包含在属性集中。;

  • 使用’get(io,key,default)`获取特定键的最新值。

以下属性最常用:

  • ':compact'：一个布尔值，表示值应该更紧凑地输出，例如，数字应该使用更少的数字输出。 显示数组元素时进行配置。 输出`:compact’不应包含换行符。

  • ':limit':一个布尔值，指示容器应该被修剪，例如，显示'。..'而不是大多数元素。

  • ':displaysize`:元组元组{Int,Int}`，它指定用于文本输出的行和列的大小。 它可以用来重新定义被调用函数的显示大小，但应该使用`displaysize`函数来获取屏幕大小。

  • :typeinfo':'Type'，它表征已经显示的与所显示对象的类型相关的信息。 这在显示相同类型的对象集合时特别有用，避免了冗余的类型信息（例如，[Float16(0)]可以显示为Float16[0.0]，而不是显示为Float16[Float16(0.0)]：在显示:typeinfo`属性的数组元

  • :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)

茱莉亚>字符串（拿！(io))
"字符串"
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)。 建议在这些方法中检查:compact`键。 IOContext（经常检查为`io`流的`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元素数组{Int64,1}`.

例子

julia> summary(1)
"Int64"

julia> summary(zeros(2))
"2-element Vector{Float64}"
print([io::IO], xs...)

将规范（未修饰）文本表示形式写入"io"（或默认输出流 'stdout'，如果没有指定’io`）。 'Print’使用的表示包含最少的格式，并试图排除特定于Julia的细节。

'print’返回到’show’调用，所以大多数类型应该只定义’show'。 如果您的类型包含单独的"常规"表示，请定义`print`。 例如，'show`显示带引号的字符串，`print'-不带引号。

另请参阅说明 'println`, '字符串'和 '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'（使用 print)in’io’后跟一个换行符。 如果未指定`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范围内的整数。 请注意，并非所有终端都支持256种颜色。

命名参数’bold=true`，italic=true，`underline=true`和’blink=true’是不言自明的。 命名参数’reverse=true’执行前景色和背景色替换的输出，并且使用’hidden=true’输出在终端中应该是不可见的，但仍然可以复制。 这些性质可以任意组合使用。

另请参阅说明 '打印', `println'和 '显示'。

并非所有终端都支持斜体输出。 一些终端将斜体解释为寻址或闪烁。
兼容性：Julia1.7

除了"颜色"和"粗体"之外，命名参数在Julia1.7中被添加。
兼容性：Julia1.10

在Julia1.10中添加了斜体输出支持。

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

使用I/O流和提供的其他参数调用此函数。 写入此I/O流的所有数据均以字符串形式返回。 "上下文"可以是一个对象 'IOContext'，其属性将由定义属性及其值的`Pair`对象使用，或由定义多个属性及其值的`Pair`对象元组使用。 'Sizehint’指定首选缓冲区容量（以字节为单位）。

可选的命名参数’context’可以分配对`:key=>value'，对元组':key=>value'或对象’IO’或 'IOContext'，其属性用于传递给`f’的I/O流。 可选的`sizehint’参数指定为用于写入字符串的缓冲区分配的首选大小（以字节为单位）。

兼容性：Julia1.7

要在命名的"上下文"参数中传递元组，需要至少1.7的Julia版本。

例子

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’的描述性表示。 此方法用于在调用后显示异常。 '扔'。

例子

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)

从给定的输入/输出流或文件中读取一行文本（默认为’stdin'`。 从文件读取时，假定文本使用UTF-8编码。 输入端的行与 Undefined control sequence \n 或者`"\r\n"'或者在输入流的末尾。 如果’keep’设置为false（默认情况下），则在返回字符串之前会从字符串中删除这些尾随换行符。 如果’keep’设置为true，则它们作为字符串的一部分返回。

返回一个’字符串'。 另请参阅功能说明 `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流或文件中读取字符串到指定的分隔符。 分隔符可以是’UInt8'，'AbstractChar'，string或vector。 命名的’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’参数的stream参数，它决定是否保存行尾的最后字符。 当使用字符串名称调用时，文件在迭代开始时打开一次，并在完成后关闭。 如果迭代中断，当垃圾回收器删除’EachLine’对象时，文件将被关闭。

要遍历’String`中的每个字符串，可以使用`eachline(IOBuffer(str))'。

'迭代器。reverse'可用于’EachLine’对象以相反顺序读取行（对于支持的文件，缓冲区和其他I/O流 'seek')，并且还可以使用 '第一`或 '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");
兼容性：Julia1.8

在Julia1.8中，您必须使用`迭代器。用`eachline`迭代器反转`或`last`。

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

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

从文件读取时，假定文本使用UTF-8编码。 输入端的行与 Undefined control sequence \n 或者`"\r\n"'或者在输入流的末尾。 如果’keep’设置为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'，string或vector。 命名的’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"对象的标称屏幕大小。 如果没有提供输入数据，则读取环境变量"行"和"列"。 如果未设置这些变量，则返回默认大小`(24,80)`。

例子

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

要获得TTY尺寸,

julia> displaysize(stdout)
(34, 147)

多媒体I/O

就像文本输出是使用 'print'，并且自定义类型可以通过重载来指定它们的文本表示 `show'，Julia提供了一种标准化机制，用于显示各种多媒体数据（如图像，格式化文本，甚至音频和视频），由三部分组成。

  • 功能 `display(x)'请求Julia`x’对象的最广泛的可用多媒体显示（带有纯文本备份）。

  • 超负荷负荷 'show'允许您指定用户定义类型的任意多媒体表示（参考标准MIME类型）。

  • 可以通过子类化通用类型来注册启用多媒体的显示后端。 'AbstractDisplay'并将它们放置在显示后端堆栈中，使用 'pushdisplay'。

基本的Julia运行时仅提供纯文本的显示，但对于更广泛的显示功能，您可以加载外部模块或使用Julia图形环境（例如，基于IPython的IJulia笔记本）。

AbstractDisplay

具有格式化输出的设备的抽象超类型。 'TextDisplay'是它的子类型。

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

使用显示堆栈中最顶层适用的显示显示"x"，通常使用"x"的最大可能支持的多媒体输出，以及纯文本输出 'stdout'作为备份选项。 'Display(d,x)'选项试图通过发出仅在此`d`显示器上显示`x 'MethodError'，如果’d’不支持这种类型的对象的显示。

一般来说，不应该假设’display’的输出转到’stdout'（不像 '打印(x)或 '显示（x’）。 例如，'display(x)'可以打开带有图像的单独窗口。 'display(x)'表示"以最大质量显示当前输出设备的`x`"。 如果您需要REPL类型的文本输出，它保证会转到"stdout，则应该使用 'show(stdout,"text/plain",x’。

此外，还有两个带有`mime`参数的选项（MIME类型字符串，例如`"image/png"`）尝试仅使用请求的MIME类型显示`x`，如果显示器或`x`不支持这种类型，则发出`MethodError`。 使用这些选项，您还可以通过传递`x::AbstractString'（对于具有文本存储的MIME类型，如text/html或application/postscript）或`x::Vector来提供所请求MIME类型的"原始"数据{UInt8}'（对于二进制MIME类型）。

要配置类型实例的显示，请重载 'show`而不是手册部分所述的’display 可定制的结构打印输出。

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

默认情况下，"重新显示"函数只需调用 '显示'。 但是，某些显示后端可能会复盖"重新显示"以更改现有的"x"显示（如果有的话）。 使用’redisplay’还告诉后端’x’可以多次显示，后端可以延迟显示，直到（例如）以下交互式命令提示符不会显示。

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

返回一个布尔值，指示当前堆栈上的任何显示是否支持这种类型的"mime"（字符串）的显示，或者特别是第二个变体中的"d"显示。

show(io::IO, mime, x)

功能 display'最终调用’show`将对象`x`作为给定的`mime’类型写入给定的io输入/输出流（通常是内存缓冲区），如果可能的话。 要提供用户定义类型`T`的扩展多媒体表示，您只需使用+show(io,::MIME"mime",x::T)=为`T`定义一个新的`show`方法。..+'其中’mime’是一个MIME类型的字符串，函数在函数体中被调用 'write'（或类似）将`x`的这种表示写入`io'。 （请注意，"MIME"表示法只支持文字字符串；要更灵活地构造"MIME"类型，请使用"MIME"{Symbol("")}`.)

例如，如果定义了类型’myImage`并且知道它是如何写入PNG文件的，则可以定义函数`show(io,::MIME"image/png",x::myImage)=。..'以允许在"AbstractDisplay"中显示具有PNG支持的图像（例如，IJulia）。 像往常一样，您需要使用’导入基础。show’为内置的Julia’show’函数添加新方法。

严格地说，宏’MIME"mime"`为给定的字符串`mime’定义了单个类型，允许您在确定任何给定类型的对象如何显示时使用Julia的调度机制。

默认的MIME类型是’MIME"text/plain"`。 对于’text`plain’的输出有一个备份定义，它使用两个参数调用`show`，因此并不总是需要为这种情况添加方法。 如果类型使用可配置的人类可读输出，请定义’show(::IO,::MIME"text/plain",::T)`。 例如，类型’Day`使用`1day`作为MIME类型’text/plain’的输出，而’Day(1)`作为带有两个参数的`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)来实现带有三个参数的`show'，其中+:compact⇒true+'设置为 `IOContext'，作为第一个参数传递。

showable(mime, x)

返回一个布尔值，指示对象`x`是否可以写成给定的`mime`类型。

（默认情况下，这是由相应方法的存在自动确定的 show为`typeof(x)'。 某些类型提供自定义的’showable’方法，例如，如果可用的MIME格式取决于`x’的_value_。)

例子

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

julia> showable("image/png", rand(5))
false
repr(mime, x; context=nothing)

返回一个`AbstractString`或'Vector'对象{UInt8}'，其中包含`x`在请求的`mime`类型中的表示，根据 'show(io,mime,x)'(如果适当的’show’方法不可用，则发出 'MethodError')。 对于具有文本表示形式的MIME类型（例如`"text/html"或`"application/postscript"`），返回`AbstractString`，二进制数据返回为'Vector{UInt8}`. （'Istextmime（mime）`函数返回一个值，无论Julia是否将这种类型的`mime’处理为文本。)

可选的命名参数"上下文"可以分配对":key=>value"或"IO"对象或 IOContext，其属性用于传递给’show’的I/O流。

在某些情况下，如果’x’是’AbstractString'（对于MIME文本类型）或'Vector{UInt8}'（对于二进制MIME类型），'repr’函数假设’x’已经具有请求的`mime`格式，并且简单地返回’x'。 这不适用于MIME类型`"text/plain"`。 此方法用于将原始数据传输到’display(m::MIME,x)'。

特别地，'repr("text/plain",x)通常是为`x`设计的用于人类消费的"程序代码的结构打印输出"的版本。 另请参阅方法的描述 `repr(x)'，它返回一个对应于 'show(x)，这可能更接近Julia中输入`x’值的方式。

例子

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

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

表示标准web数据格式的类型。 MIME代表多用途Internet邮件扩展，因为该标准最初用于描述电子邮件中的多媒体附件。 `MIME’对象可以作为第二个参数传递给 `show'请求以这种格式输出。

例子

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

编写类型的辅助宏 'MIME'，常用于将方法添加到 '显示'。 例如，语法为'show(io::IO,::MIME"text/html",x::MyType)=。..'可用于确定如何编写`MyType’的HTML表示形式。

如上所述，您还可以定义新的显示后端。 例如，可以在窗口中显示PNG图像的模块可以在Julia中注册此功能，以便在调用时 'display(x)'对于带有PNG表示的类型，图像将自动显示在模块窗口中。

要定义新的显示后端，必须首先创建抽象类的子类型’D'。 'AbstractDisplay'。 然后，对于可以在`D`中显示的每个MIME类型（字符串`mime`），定义函数'display(d::D,::MIME"mime",x)=。..，将’x’显示为此MIME类型，通常通过调用 'show(io,mime,x’或 'repr(io,mime,x’。 如果’x`不能显示为此MIME类型，则应发生错误。 'MethodError'。 当调用’show’或’repr’时，会自动发生这种情况。 最后，应定义函数`display(d::D,x)'，其请求 `showable(mime,x)关于`D`支持的`mime’类型，并输出最好的类型。 如果没有为"x"找到支持的MIME类型，则应发生"MethodError"错误。 同样，某些子类型可能会复盖 'redisplay(d::D,。..). （再次，要添加新的显示方法’display），您需要’import Base。显示'。）这些函数的返回值取决于实现（因为在某些情况下，返回某种类型的"描述符"可能很有用）。 然后可以直接调用`D`的映射函数，但也可以从 `display(x)'，只需使用适当的函数将新的显示发送到显示后端堆栈即可。

pushdisplay(d::AbstractDisplay)

在显示和后端全局堆栈的顶部传递新映射`d'。 当调用`display(x)`或`display(mime,x)'时``x’显示在堆栈中最顶层的兼容后端（即不输出的最顶层后端 'MethodError')。

popdisplay()
popdisplay(d::AbstractDisplay)

从显示和后端堆栈中删除最顶层的后端，或者在第二个选项中删除`d’的最顶层副本。

TextDisplay(io::IO)

返回’TextDisplay<:AbstractDisplay`，其中所有对象都显示为mime类型text/plain（默认情况下），文本表示形式写入指定的输入/输出流。 （这就是Julia的REPL中对象的输出方式。)

istextmime(m::MIME)

确定MIME类型是否为文本数据。 假设MIME类型是二进制数据，但一组明显与文本数据（可能是Unicode）相关的类型除外。

例子

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

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

网络I/O

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