I/O和网络
通用I/O
# '基。阅读'-Method
read(filename::AbstractString)
将文件的全部内容读取为'Vector{UInt8}`.
read(filename::AbstractString, String)
以字符串的形式读取文件的全部内容。
read(filename::AbstractString, args...)
打开文件并读取其内容。 'args’传递给’read':这相当于'open(io->read(io,args...),文件名)'。
# '基。写`-Method
write(filename::AbstractString, content)
将"内容"的规范二进制表示形式写入将创建的文件,如果该文件尚不存在,或以其他方式复盖该文件。
返回写入文件的字节数。
# '基。打开'-Function
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` |
阅读、创作、裁剪 |
'写=真` |
|
阅读,创造 |
'append=true` |
'r+` |
阅读,写作 |
'读=真,写=真` |
'w+` |
阅读,写作,创作,裁剪 |
'truncate=true,read=true` |
|
阅读、写作、创作、加入 |
"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中打印数据,则会发生错误。
# '基。IOBuffer'-Type
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"
# '基。拿!`-Method</no-翻译>
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."
# '基。管道'-Type</no-翻译>
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!`.
# '基。fdio'-Function
fdio([name::AbstractString, ]fd::Integer[, own::Bool=false]) -> IOStream
创建对象 'IOStream'基于整数文件描述符。 如果’own’具有值’true',则在关闭此对象时,基描述符也会关闭。 默认情况下,"IOStream"在执行垃圾回收时关闭。 "名称"允许您将描述符与命名文件相关联。
# '基。closewrite'-Function
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"
# '基。写`-Function
write(io::IO, x)
将值的规范二进制表示形式写入指定的输入/输出流或文件。 返回写入流的字节数。 另请参阅功能说明 `print',它写入文本表示(以依赖于`io’的编码)。
您可以通过一次"写入"调用来写入多个值,这意味着以下值是等价的:
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))
# '基。阅读'-Function
read(io::IO, T)
从规范二进制表示中的"io"中读取"T"类型的单个值。
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)
执行"命令"并将结果输出返回为"字符串"。
# '基。读吧!`-Function</no-翻译>
read!(stream::IO, array::AbstractArray)
read!(filename::AbstractString, array::AbstractArray)
通过填写"数组"从I/O流或文件中读取二进制数据。
# '基。瑞德比提斯!`-Function</no-翻译>
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'-Function
unsafe_read(io::IO, ref, nbytes::UInt)
将`nbytes`从`IO`流的对象复制到’ref'(转换为指针)。
在子类型’T<:IO`中,建议重新定义以下方法签名以提供更有效的实现:`unsafe(s::T,p::Ptr{UInt8},n::UInt)'。
# '基。unsafe_write'-Function
unsafe_write(io::IO, ref, nbytes::UInt)
将`ref`中的`nbytes'(转换为指针)复制到`IO`对象。
在子类型’T<:IO`中,建议重新定义以下方法签名以提供更有效的实现:`unsafe(s::T,p::Ptr{UInt8},n::UInt)'。
# '基。readeach'-Function
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'-Function
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或更高版本。 |
# '基。位置'-Function
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
# '基。求'-Function
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'-Function
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)
# '基。跳过'-Function
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)
# '基。unmark'-Function
unmark(s::IO)
从"s"流中删除标签。 如果流已被标记,则返回`true`,否则返回’false'。
另请参阅说明 '标记', '重置'和 'ismarked`。
# '基。重置'-Method</no-翻译>
reset(s::IO)
将流`s’重置到先前标记的位置,然后删除标签。 返回先前标记的位置。 如果未标记流,则返回错误。
另请参阅说明 '标记', 'unmark'和 'ismarked`。
# '基。eof'-Function
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'-Function
isreadonly(io) -> Bool
确定流是否具有"只读"属性。
例子
julia> io = IOBuffer("JuliaLang is a GitHub organization");
julia> isreadonly(io)
true
julia> io = IOBuffer();
julia> isreadonly(io)
false
# '基。iswritable`-Function
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`-Function
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`-Function
isexecutable(path::String)
如果指定的"路径"具有可执行文件权限,则返回"true"。
此权限可能会在用户执行`path’之前更改,因此建议执行文件并在失败的情况下处理错误,而不是首先调用’isexecutable'。 |
在Julia1.6之前,Windows文件系统ACL查询错误,因此对任何文件都返回值"true"。 自Julia1.6以来,该函数正确检测文件是否标记为可执行文件。 |
另请参阅说明 'ispath`, "可读"及 'iswritable`。
# '基。redirect_stdio'-Function
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`-Function
redirect_stdout([stream]) -> stream
'stream’必须是兼容的对象,例如’IOStream','TTY`, |
另请参阅说明 'redirect_stdio'。
# '基。redirect_stderr'-Function
redirect_stderr([stream]) -> stream
同样地 'redirect_stdout',但对于 'stderr'。
'stream’必须是兼容的对象,例如’IOStream','TTY`, |
另请参阅说明 'redirect_stdio'。
# '基。redirect_stdin'-Function
redirect_stdin([stream]) -> stream
同样地 'redirect_stdout',但对于 'stdin'。 注意,流动方向是相反的。
'stream’必须是兼容的对象,例如’IOStream','TTY`, |
另请参阅说明 'redirect_stdio'。
# '基。readchomp'-Function
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");
# '基。截断`-Function
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'-Function
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'-Function
countlines(io::IO; eol::AbstractChar = '\n')
countlines(filename::AbstractString; eol::AbstractChar = '\n')
读取"io"到流或文件的末尾,并计算行数。 要指定文件,请将文件名作为第一个参数传递。 除此以外的行尾标记 ,通过将它们作为第二个参数传递来支持。 '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'-Function
PipeBuffer(data::AbstractVector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))
一个对象 'IOBuffer',它允许通过加入读取和写入。 不支持搜索和裁剪。 厘米。 'IOBuffer',它描述了可用的构造函数。 如果指定了’data’参数,则会创建一个`PipeBuffer',用于对数据向量执行操作,另外指定不能增加基数组的大小。
# '基。IOContext'-Type
IOContext
'IOContext’提供了一种在方法之间传递输出配置参数的机制 '显示'。
换句话说,它是一个不可变的字典,它是`IO’的子类。 它支持标准的字典操作,如 'getindex',并且也可以用作I/O流。
# '基。IOContext'-Method
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'-Method
IOContext(io::IO, context::IOContext)
创建一个’IOContext',它封装了替代’IO`,但继承了`context’的属性。
文本输入/输出
# '基。显示'-Method
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!
# '基。打印'-Function
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'-Function
println([io::IO], xs...)
另请参阅功能说明 'printstyled',它添加了颜色等。
例子
julia> println("Hello, world")
Hello, world
julia> io = IOBuffer();
julia> println(io, "Hello", ',', " world.")
julia> String(take!(io))
"Hello, world.\n"
# '基。printstyled'-Function
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’输出在终端中应该是不可见的,但仍然可以复制。 这些性质可以任意组合使用。
并非所有终端都支持斜体输出。 一些终端将斜体解释为寻址或闪烁。 |
兼容性:Julia1.7
除了"颜色"和"粗体"之外,命名参数在Julia1.7中被添加。 |
兼容性:Julia1.10
在Julia1.10中添加了斜体输出支持。 |
# '基。sprint'-Function
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'-Function
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
# '基。转储'-Function
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}
# '基。readline'-Function
readline(io::IO=stdin; keep::Bool=false)
readline(filename::AbstractString; keep::Bool=false)
从给定的输入/输出流或文件中读取一行文本(默认为’stdin'`。 从文件读取时,假定文本使用UTF-8编码。 输入端的行与 或者`"\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'-Function
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'-Function
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")
# '基。每行'-Function
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`。 |
# '基。copyyline'—Function
copyline(out::IO, io::IO=stdin; keep::Bool=false)
copyline(out::IO, filename::AbstractString; keep::Bool=false)
将一行文本从I/O流或文件复制到out流,返回’out'。
从文件读取时,假定文本使用UTF-8编码。 输入端的行与 或者`"\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'-Function
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'-Function
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笔记本)。
# '基。多媒体。显示'-Function
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 可定制的结构打印输出。
# '基。多媒体。可显示`-Function
displayable(mime) -> Bool
displayable(d::AbstractDisplay, mime) -> Bool
返回一个布尔值,指示当前堆栈上的任何显示是否支持这种类型的"mime"(字符串)的显示,或者特别是第二个变体中的"d"显示。
# '基。显示'-Method
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',作为第一个参数传递。
# '基。repr'-Method</no-翻译>
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"
如上所述,您还可以定义新的显示后端。 例如,可以在窗口中显示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'-Function
pushdisplay(d::AbstractDisplay)
在显示和后端全局堆栈的顶部传递新映射`d'。 当调用`display(x)`或`display(mime,x)'时``x’显示在堆栈中最顶层的兼容后端(即不输出的最顶层后端 'MethodError')。
# '基。多媒体。popdisplay`-Function
popdisplay()
popdisplay(d::AbstractDisplay)
从显示和后端堆栈中删除最顶层的后端,或者在第二个选项中删除`d’的最顶层副本。
# '基。多媒体。TextDisplay'—Type
TextDisplay(io::IO)
返回’TextDisplay<:AbstractDisplay`,其中所有对象都显示为mime类型text/plain(默认情况下),文本表示形式写入指定的输入/输出流。 (这就是Julia的REPL中对象的输出方式。)
# '基。多媒体。istextmime'-Function
istextmime(m::MIME)
确定MIME类型是否为文本数据。 假设MIME类型是二进制数据,但一组明显与文本数据(可能是Unicode)相关的类型除外。
例子
julia> istextmime(MIME("text/plain"))
true
julia> istextmime(MIME("image/png"))
false