I/O 和網路

stdout::IO

指向標準輸出串流的全局變數。

stderr::IO

指向標準錯誤串流的全局變數。

stdin::IO

指向標準輸入串流的全局變數。

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

open 的替代語法，其中使用基於字串的模式指定符，而非五個布林值。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 為 true，則從處理程序讀取的內容來自處理程序的標準輸出，且 stdio 可選擇指定處理程序的標準輸入串流。如果 write 為 true，則寫入的內容會傳送到處理程序的標準輸入，且 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."

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。通知另一端不再將資料寫入底層檔案。並非所有 IO 類型都支援此功能。

範例

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

julia> write(io, "request");

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

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

將值的標準二進制表示寫入指定的 I/O 串流或檔案。傳回寫入串流的位元組數。另請參閱 print 以寫入文字表示（編碼可能取決於 io）。

寫入值的位元序取決於主機系統的位元序。在寫入/讀取時轉換為/從固定位元序（例如使用 htol 和 ltoh）以取得在不同平台上都一致的結果。

您可以使用相同的 write 呼叫寫入多個值。例如，下列範例是等效的

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

範例

一致序列化

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

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

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

合併寫入呼叫

julia> io = IOBuffer();

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

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

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

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

沒有 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)

將 nbytes 從 ref（轉換為指標）複製到 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)

傳回目前位置。

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、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(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(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")

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、socket 或 devnull。

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

重新導向 stdin、stderr、stdout 串流的子集，呼叫 f()，然後還原每個串流。

每個串流的可能值為

• nothing 表示不應重新導向串流。
• path::AbstractString 將串流重新導向至 path 的檔案。
• io 為 IOStream、TTY、Pipe、socket 或 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) # not supported

此外，stdin 參數不能與 stdout 或 stderr 為同一個描述子。

julia> io = open(...)

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

redirect_stdout([stream]) -> stream

建立一個管線，所有 C 和 Julia 層級的 stdout 輸出都將重新導向到該管線。傳回一個代表管線端的串流。寫入 stdout 的資料現在可以從管線的 rd 端讀取。

另請參閱 redirect_stdio。

redirect_stdout(f::Function, stream)

執行函式 f，同時將 stdout 重新導向到 stream。完成後，stdout 會還原為先前的設定。

redirect_stderr([stream]) -> stream

與 redirect_stdout 類似，但適用於 stderr。

另請參閱 redirect_stdio。

redirect_stderr(f::Function, stream)

執行函式 f，同時將 stderr 重新導向到 stream。完成後，stderr 會還原為先前的設定。

redirect_stdin([stream]) -> stream

與 redirect_stdout 類似，但適用於 stdin。請注意，串流的方向相反。

另請參閱 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 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 直到串流/檔案結束，並計算行數。若要指定檔案，請將檔案名稱傳遞為第一個引數。除了 '\n' 之外的 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) # counting lines moves the file pointer
true

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

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

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

julia> countlines("my_file.txt")
1

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

julia> rm("my_file.txt")

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

一個 IOBuffer，允許讀取並透過附加來執行寫入。不支援尋找和截斷。有關可用的建構函式，請參閱 IOBuffer。如果提供 data，則會建立一個 PipeBuffer 來操作資料向量，並可選擇指定一個大小，超過此大小後，底層 Array 便無法擴充。

readavailable(stream)

從串流中讀取可用的緩衝資料。只有當資料尚未緩衝時，才會執行實際的 I/O。結果為 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（或預設輸出串流 stdout，如果未提供 io）一個正規的（未裝飾的）文字表示。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...)

使用 print 將 xs 印出到 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 應在終端機中不可見，但仍可複製。這些屬性可以任意組合使用。

另請參閱 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 時，它們會作為行的一部分傳回。

範例

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、字串或向量。關鍵字引數 keep 控制分隔符號是否包含在結果中。假設文字編碼為 UTF-8。

範例

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");

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，如果顯示器或 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

傳回布林值，指出目前顯示堆疊中的任何顯示器，或第二個變體中顯示器 d 是否可以顯示指定的 mime 類型（字串）。

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

容器類型通常透過呼叫 show(io, MIME"text/plain"(), x) 來實作 3 個參數的 show，其中元素 x 設定 :compact => true，並將 IOContext 傳遞為第一個參數。

showable(mime, x)

傳回一個布林值，表示物件 x 是否可以寫入為指定的 mime 類型。

（預設情況下，這是由對應的 show 方法的存在自動決定的，用於 typeof(x)。有些類型提供自訂的 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}，其中包含 x 在請求的 mime 類型中的表示，由 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) 的字串，這可能更接近在 Julia 中輸入 x 值的方式。

範例

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)

將值的小端序轉換為 Host 使用的端序。

htol(x)

將值從 Host 使用的端序轉換為小端序。

ENDIAN_BOM

32 位元組序標記表示主機機器的原生位元組序。小端序機器將包含值 0x04030201。大端序機器將包含值 0x01020304。