Engee 文档

输入/输出功能

Julia中的输入/输出函数提供了处理文件、数据流和其他数据源/接收器的能力（有关更多信息，请参阅 I/O和网络). 对于导入到文件浏览器中的文件，可以应用以下功能:

发现,发现

打开-打开文件或数据流。

Details

功能 打开 它提供了方便和安全的工作与文件，因为在调用的上下文中使用该文件后 打开 文件会自动关闭，这有助于避免资源泄漏或与隐式打开文件相关的其他问题。

函数应用函数 f 到结果 打开(args...;夸格斯。..) 并在完成后关闭结果文件的句柄。

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

文件描述符是一个抽象概念，用于表示程序中打开的文件。 它是一个数据结构，包含有关文件的信息，例如其路径，访问模式（读，写等）。）、文件中的当前位置和其他属性。 例子：:

write("my_file.txt", "Hello world!"); # 正在创建一个文件my_file。txt包含文本Hello world！

open(io->read(io, String), "my_file.txt")
"Hello world!" # 打开my_file。txt进行读取，并立即将其内容读取成字符串

rm("my_file.txt") # 删除my_file。txt后其内容已被读取并输出

功能 io→读取（io，字符串），它接受输入/输出（io）对象并将其内容读取到字符串中。 之后，文件的内容"my_file。txt"作为结果输出，最终得到字符串。 "你好世界！".

以五个逻辑命名参数指定的模式打开文件:

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

关键字

描述

默认情况下

read
write
create
truncate
append

开放阅读
开放录音
如果不存在则创建
裁剪到零尺寸
执行搜索到最后

!write
truncate | append
!read & write | truncate | append
!read & write
false

默认情况下，如果没有传输关键字，文件将是只读的。 流返回访问打开的文件。 命名参数 锁,锁 确定是否会阻止操作以进行安全的多线程访问。

一种替代的开头语法，它使用基于字符串操作的模式描述符而不是五个逻辑参数。 模式值对应于从 福朋(3) 或 Perl开放 和 等同于设置以下逻辑组:

模式

描述

关键字

r
w
r+
w+
a+

阅读
阅读，创建，裁剪
读取、创建、追加
读取、写入密码：q[<br>] 读，写，创建，裁剪
读取、写入、创建、追加

非也。 write = true
append = true
read = true, write = true
truncate = true, read = true
append = true, read = tru

例子:

io = open("my_file.txt", "w"); # 打开my_file。txt写入（写入）

write(io, "Hello world!"); # 写字符串Hello world！ 到上一行打开写入的文件

close(io); # 关闭my_file。txt，释放资源，完成写操作

io = open("my_file.txt", "r"); # 打开my_file。txt用于读取（read），返回一个输入/输出对象（io）

read(io, String) # 读取my_file文件的内容。txt作为字符串
"Hello world!" # 操作的结果

write(io, "This file is read only") # 由于文件是只读打开的（在上一行），因此不允许此写入操作，并且会生成ArgumentError错误。
ERROR: ArgumentError: write failed, IOStream is not writeable
[...]

close(io) # 关闭文件my_file。txt后写尝试释放资源

io = open("myfile.txt", "a"); # 打开my_file。txt添加（追加），这将允许写入数据到文件的末尾，而不删除或复盖其内容

write(io, "This stream is not read only") # 将行"This stream is not read only"写入文件my_file的末尾。txt，因为文件是在追加模式（"a"）下打开的。 Write函数返回写入的字节数(28)
28 # 操作的结果

close(io)# 关闭my_file。txt执行完所有写操作后释放资源

rm("my_file.txt")# 删除文件my_file。txt脧脗脭脴

详细了解该功能的所有功能 打开 阅读 I/O和网络.

isopen的-确定对象（线程或计时器）是否已经关闭。

Details

对象关闭后，它将不再能够创建新事件。 但是，鉴于封闭流仍然可以包含要在缓冲区中读取的数据，您应该使用eof来检查数据是否可以读取。 如果支持写入流或从流读取流，请使用FileWatching包接收通知。 函数输出 真的 如果对象是打开的并且 错误 如果对象已关闭。

io = open("my_file.txt", "w+"); # 打开文件my_file。"w+"模式下的txt（写入和读取）

isopen(io) # 检查与io i/O对象关联的文件是否打开(my_file.txt)
true # 操作的结果

close(io) # 关闭与io i/O对象关联的文件。 关闭后，文件不再可用于写入或读取。

isopen(io) # 关闭文件后（之前的操作），该命令返回false，因为该文件不再打开。
false # 操作的结果

对于功能 io=open("my_file.txt"，"w+"）:

  • 如果文件不存在，它将被创建。

  • 如果文件已经存在，其内容将被删除。

功能 打开 它还返回一个输入/输出对象。 (io)，其与打开的文件相关联。

关闭

接近/接近-关闭输入/输出流。

Details

首先，它运行 冲水,冲水 （输入/输出的强制复位）。

close(io)

关闭所有-关闭图形用户界面的所有打开的窗口。

Details

如果您需要确保在终止程序之前关闭所有文件，这很有用。

closeall()

[医]近距离阅读-仅关闭与输入/输出对象关联的文件中的读取流。

Details

如果文件已打开以进行读取和写入，则写入流保持打开状态。 它用于关闭只读流，并可选择继续写入文件。

closeread(io)

[医]近缘-停止记录全双工I/O流的一半。

Details

运作 冲水,冲水 先执行。 通知另一方不再将数据写入基本文件。 某些I/O类型可能不支持此操作。

例子:

io = Base.BufferStream(); # 将创建一个新的缓冲输入/输出流。 在这种情况下，锁永远不会执行，因此读取和写入操作可用于相同的作业。

write(io, "request"); # 请求字符串写入缓冲的io流

# 在这里调用`read(io)`时，应用永久锁。

closewrite(io); # Io写流被关闭，不会接受任何写操作，而读流保持打开状态。

read(io, String) # 正在从io执行读取操作

记录

写-将规范二进制值文件的表示形式写入指定的输入/输出流或文件。

Details

返回写入流的字节数。 记录值中的字节顺序取决于主机系统中的字节顺序。

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

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

例子：:

# 一致的序列化

fname = tempname(); # 任意临时文件名

open(fname,"w") do f
             # 确保以直接字节顺序格式写入64位整数值。
             write(f,htol(Int64(42)))
         end
8

julia>open(fname,"r")do f
             # 执行到基本字节顺序和基本整数类型的反向转换
             Int（ltoh（读（f，Int64）））
         结束
42

# 结合写操作调用:

io=IOBuffer（）;

write(io,"JuliaLang是一个GitHub组织。"，"它有许多成员。")
56

弦（拿！(io))
"JuliaLang是一个GitHub组织。 它有许多成员。"

write(io,"有时是那些成员")+write(io,"写文档。")
44

弦（拿！(io))
"有时这些成员会编写文档。"

# 没有write方法的用户自定义核心数据类型可以写，特别是封装在Ref中

struct MyStruct;x::Float64;结束

io=IOBuffer（）
IOBuffer(data=UInt8[...]，readable=true，writable=true，seekable=true，append=false，size=0，maxsize=Inf，ptr=1，mark=-1）

写（io，Ref（MyStruct（42.0）））
8

seekstart(io);阅读！（io，Ref（MyStruct（NaN）））
基地。重新价值{MyStruct}(MyStruct(42.0))

冲水,冲水-强制将输入/输出流中的所有缓冲数据写入基本设备（例如，写入磁盘）。

Details

功能 冲水,冲水 确保已写入流的所有数据（例如，使用 写），但可以暂时存储在内存中的缓冲区中，将物理写入最终目标（文件，套接字等）。). 在需要确保保存数据的操作之前使用（例如，在关闭文件之前或其他程序开始读取此文件之前）。

io = open("log.txt", "w")
write(io, "重要信息1\n")
write(io, "重要信息2\n")

# 数据可能仍然在内存中的缓冲区中，而不是在文件中。
# 调用flush可确保将它们写入磁盘。
flush(io)

# 现在你可以肯定，"日志。txt"包含最新数据。
read("log.txt", String)
"重要信息1\重要信息2\n"

close(io)
rm("log.txt")
功能 接近/接近 自动呼叫 冲水,冲水 在关闭流之前。

iswritable缧-检查是否支持写入指定对象。

Details

申报表 错误 如果不支持写入指定的I/O对象。

例子:

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

open("my_file.txt", "r") do io
    iswritable(io)
end
false

rm("my_file.txt")

阅读

讀！-读取文件的内容。

Details

默认情况下 讀！ 以二进制模式读取文件:

read("sample1.json")

# 结论
65-element Vector{UInt8}:
 0x7b
 0x0a
 0x20
 0x20
 0x20
    ⋮

为了避免表示为字节数组，建议使用表示参数。 例如，函数 讀！ 它可以采用几个参数，包括将文件内容转换为（使用String）的数据类型:

read("sample1.json", String) # 读取sample1文件的内容。json并将其作为字符串返回

# 提款
"{\n    \"fruit\": \"Apple\",\n    \"size\": \"Large\",\n    \"color\": \"Red\"\n}"

您可以从文件中读取第一个字符，并使用Char参数以Char格式（字符类型）返回它。:

read("sample1.json", Char)

# 结论
'{': ASCII/Unicode U+007B (category Ps: Punctuation, open)

此功能 读取（file_name::IOStream，number_of_bytes::Integer） 执行读取不超过 数字_of_bytes 来自流的字节 文件名 并返回一个数组 向量资料{ UInt8 }，包含几个字节。 要从文件接收流，您需要打开它进行读取。 例如:

open("sample1.json", "r") # 打开文件进行读取

# 读取结果的输出
IOStream(<file sample1.json>)

read("sample1.json", 10) # 从文件中读取前10个字节

# 结论
10-element Vector{UInt8}:
 0x7b
 0x0a
 0x20
 0x20
 0x20
 0x20
 0x22
 0x66
 0x72
 0x75
流是数据的抽象，它是一个字节序列。 序列可以从源和源中读取或写入。 例如，文本文件，网络连接，内存等。 流也可用于从源（输入）读取数据或向其写入数据（输出）。 使用方法:

  • 冲水,冲水 -捕获当前在此流中的缓冲区中的所有条目。

  • 关闭(流) -关闭输入/输出流。 表演/表演 冲水,冲水 首先。

  • closewrite(蒸汽) -禁用全双工流的一半记录。 表演/表演 冲水,冲水 首先。 没有更多的数据将被写入到基本文件。 这并不是所有I/O类型都支持的。

您可以使用该函数执行cmd命令 讀！. 例如，让我们创建一个命令 日期 （显示当前日期和时间）:

# 创建输出当前日期和时间的命令
cmd = `date`

read(cmd) # 将结果输出为字节数组

read(cmd, String) # 将结果输出为字符串
# 结论
"Thu Mar 28 07:44:58 UTC 2024\n"

读吧！-从输入/输出流或文件中读取二进制数据，填写数据矩阵。

Details

功能 读吧！ 它用于将数据从输入/输出流或文件读取到预先分配的缓冲区或数组中。 它通常用于使用来自外部源的数据有效地填充数组，而无需创建额外的临时数组。 要从文件接收流，您需要打开它进行读取。 例如:

open("sample1.json", "r") # 打开文件进行读取

my_array = zeros(UInt8, 5) # 创建一个由5个uint8类型元素组成的数组，其中填充了零
# 结论
5-element Vector{UInt8}:
 0x00
 0x00
 0x00
 0x00
 0x00

read!("sample1.json", my_array) # 从sample1中读取数据。json并用它们填充my_array数组
# 结论
5-element Vector{UInt8}:
 0x7b
 0x0a
 0x20
 0x20
 0x20

可读性-从流中读取可用的缓冲数据。

Details

如果流中有尚未读取的数据，函数将返回此数据。 仅当数据尚未缓冲时才执行实际I/O。 如果缓冲区中没有数据，则函数返回空字节数组。

返回的数据量将取决于实现，例如，它可以取决于内部缓冲区大小选择。 相反，您通常应该使用其他功能，例如 讀！. 
IOS=open("sample1.json", "r") # 以读取模式打开文件并将其写入IOS I/O缓冲区的内容

readavailable(IOS) # 从I/O缓冲区读取可用数据并返回

瑞德比提斯！-从stream到b读取不超过nb字节，返回要读取的字节数。

Details

功能 瑞德比提斯！ 阅读不超过 n 流中的字节并将其写入数据阵列。 如果 n 如果未指定，则读取等于数组长度的字节数。 然后它返回读取的字节数。 如果流中的可用字节少于请求，则仅读取可用字节数。

IOS=open("sample1.json", "r") # 以读取模式打开文件并将其写入IOS I/O缓冲区的内容。

buffer = Vector{UInt8}(undef, 5) # 将创建一个长度为5个元素的uint8类型的空缓冲区数组

readbytes!(IOS, buffer) # 从IOS流中读取5个字节并将它们保存到缓冲区数组中

# 结论
5 # 结果，输出一个数字，该数字指示成功读取的字节数。 由于数组由5个元素组成，因此完全成功读取。

阅读,阅读-将整个文件作为一行读取，并删除末尾的一个换行符（如果有的话）。

Details

功能 阅读,阅读 相当于 chomp(读(x,字符串)).

write("my_file.txt", "欢迎来到恩吉。\n");

readchomp("my_file.txt"）

# 结论
是"欢迎来到Engee。"

雷迪尔-返回目录(dir)或当前工作目录（如果未指定）中的名称。

Details

功能 雷迪尔 它用于读取目录的内容。 它返回一个字符串数组，每个字符串表示指定目录中的文件或子目录的名称。

默认情况下 雷迪尔 对返回的名称列表进行排序。 要跳过对名称进行排序并按照它们在文件系统中列出的顺序获取它们，可以使用 readdir（dir，sort=false）.

cd("/user") # 转到用户开始目录

readdir() # 返回当前目录中所有文件的名称（当前为"/user"）
7-element Vector{String}:
 ".git"
 ".packages"
 ".project"
 "11.ngscript"
 "engee_commands.csv"
 "my_file.txt"
 "sample1.json"

readdir(join=true) # 将返回的名称与当前目录相结合
7-element Vector{String}:
 "/user/.git"
 "/user/.packages"
 "/user/.project"
 "/user/11.ngscript"
 "/user/engee_commands.csv"
 "/user/my_file.txt"
 "/user/sample1.json"

readdir("my_dir") # 返回my_dir目录中所有文件的名称
7-element Vector{String}:
 "RTFM-HISTORY.txt"
 "delay.html"
 "difference.pdf"
 "difference.xml"
 "littleendian.svg"
 "markdown_test.md"
 "mat.mat"

readdir("my_dir", join=true) # 将返回的名称与所选目录（my_dir）相结合
7-element Vector{String}:
 "my_dir/RTFM-HISTORY.txt"
 "my_dir/delay.html"
 "my_dir/difference.pdf"
 "my_dir/difference.xml"
 "my_dir/littleendian.svg"
 "my_dir/markdown_test.md"
 "my_dir/mat.mat"

读,读-返回一个可迭代的对象，产生read(io,T)。

Details

功能 读,读 它用于遍历文件或流的内容，为每行或部分数据执行指定的操作。 它接受一个读流作为输入和一个将应用于每一行或每一段数据的参数。

io = IOBuffer("欢迎来到恩吉。\n函数要删除的文本。\n") # 将创建输入/输出缓冲区

for c in readeach(io, Char) # 从流中迭代字符直到达到\n，然后完成迭代。
             c == '\n' && break
             print(c)
         end

# 结论
欢迎来到恩吉。

读线-从给定的输入/输出流或文件中读取一行文本。

Details

从文件读取时，假定文本使用UTF-8编码。 字符串在输入端与'\n’或"\r\n"或在输入流的末尾。 也可以使用参数 保持. 如果 保持 这很重要 错误 （默认情况下），这些尾随换行符在返回之前从字符串中删除。 如果 保持 这很重要 真的 它们作为字符串的一部分返回。

write("my_file.txt", "欢迎来到恩吉。\Ntext要被函数删除。\n");

readline("my_file.txt")
"欢迎来到恩吉。"

readline("my_file.txt", keep=true)
"欢迎来到恩吉。\n"

rm("my_file.txt") # 删除文件my_file。txt脧脗脭脴

print("Enter your name: ")

your_name = readline() # 打开用户名输入窗口。
# 输入名称，例如Engee_User
"Engee_User"

阅读线-将输入/输出流或文件中的所有行读取为矢量或字符串值。

Details

行为类似于读取结果的可重复保存 读线 使用相同的参数并将生成的字符串保存为向量或字符串值。

write("my_file.txt", "欢迎来到恩吉。不会被函数删除的\Ntext。\n");

readlines("my_file.txt")
# 结论
2-element Vector{String}:
 "欢迎来到恩吉。"
 "函数不会删除的文本。"

readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "欢迎来到恩吉。\n"
 "函数不会删除的文本。\n"

rm("my_file.txt") # 删除文件my_file。txt脧脗脭脴

阅读,阅读-从输入/输出流或文件中读取一行（最多为指定的分隔符字符）。

Details

分隔符可以是UInt8、AbstractChar、字符串或向量。 命名参数 保持 确定分隔符符号是否包含在结果中。 假定文本使用UTF-8编码。

write("my_file.txt", "欢迎来到恩吉。\Ntext要被函数删除。\n")

readuntil("my_file.txt", 'L')

readuntil("my_file.txt", '.', keep = true)
  "欢迎来到恩吉。"

rm("my_file.txt")

有关*Engee*中的其他文件管理功能的详细信息，请参阅 软件控制建模.

有用的连结

  1. 数据导入

  2. 使用Julia软件包

  3. 文件格式