I/O and Network

stdout::IO

標準出力ストリームを参照するグローバル変数です。

stderr::IO

標準エラーストリームを参照するグローバル変数です。

stdin::IO

標準入力ストリームを参照するグローバル変数です。

read(filename::AbstractString)

ファイルの全内容を Vector{UInt8} として読み込みます。

read(filename::AbstractString, String)

ファイルの全内容を文字列として読み込みます。

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

ファイルを開いてその内容を読み込みます。args は read に渡されます：これは open(io->read(io, args...), filename) と同等です。

write(filename::AbstractString, content)

contentの標準的なバイナリ表現をファイルに書き込みます。ファイルがまだ存在しない場合は作成され、存在する場合は上書きされます。

ファイルに書き込まれたバイト数を返します。

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

関数 f を open(args...; kwargs...) の結果に適用し、完了後に結果のファイルディスクリプタを閉じます。

例

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

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

julia> rm("myfile.txt")

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

ファイルを5つのブールキーワード引数で指定されたモードで開きます：

キーワードが渡されない場合のデフォルトは、ファイルを読み取り専用で開くことです。開かれたファイルにアクセスするためのストリームを返します。

lockキーワード引数は、操作が安全なマルチスレッドアクセスのためにロックされるかどうかを制御します。

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

文字列ベースのモード指定子を使用する代替構文で、5つのブール値の代わりに使用されます。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

OSファイルディスクリプタをラップするバッファ付きIOストリーム。主にopenによって返されるファイルを表すために使用されます。

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

メモリ内のI/Oストリームを作成します。これは、既存の配列で操作することもできます。

オプションのキーワード引数を取ることができます：

• read, write, append: 操作をバッファに制限します。詳細はopenを参照してください。
• truncate: バッファサイズをゼロ長に切り詰めます。
• maxsize: バッファが成長できないサイズを指定します。
• sizehint: バッファの容量を提案します（dataはsizehint!(data, size)を実装する必要があります）。

dataが指定されていない場合、バッファはデフォルトで読み取り可能かつ書き込み可能です。

例

julia> io = IOBuffer();

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

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

julia> io = IOBuffer(b"JuliaLang is a GitHub organization.")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=35, maxsize=Inf, ptr=1, mark=-1)

julia> read(io, String)
"JuliaLang is a GitHub organization."

julia> write(io, "This isn't writable.")
ERROR: ArgumentError: ensureroom failed, IOBuffer is not writeable

julia> io = IOBuffer(UInt8[], read=true, write=true, maxsize=34)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=34, ptr=1, mark=-1)

julia> write(io, "JuliaLang is a GitHub organization.")
34

julia> String(take!(io))
"JuliaLang is a GitHub organization"

julia> length(read(IOBuffer(b"data", read=true, truncate=false)))
4

julia> length(read(IOBuffer(b"data", read=true, truncate=true)))
0

IOBuffer(string::String)

与えられた文字列の基になるデータ上に読み取り専用の IOBuffer を作成します。

例

julia> io = IOBuffer("Haho");

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

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

take!(b::IOBuffer)

IOBufferの内容を配列として取得します。その後、IOBufferは初期状態にリセットされます。

例

julia> io = IOBuffer();

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

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

Pipe()

未初期化の Pipe オブジェクトを構築します。これは、複数のプロセス間の IO 通信に特に便利です。

パイプの適切な端は、オブジェクトがプロセス生成に使用されると自動的に初期化されます。これは、プロセスパイプライン内で参照を簡単に取得するのに役立ちます。例えば：

julia> err = Pipe()

# この後、`err` は初期化され、`foo` の
# stderr を `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)

pipeを初期化し、inエンドポイントをoutエンドポイントにリンクします。キーワード引数reader_supports_async/writer_supports_asyncは、WindowsのOVERLAPPEDおよびPOSIXシステムのO_NONBLOCKに対応します。外部プログラム（例えば、runで実行されたコマンドの出力）によって使用されない限り、trueであるべきです。

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

整数ファイルディスクリプタからIOStreamオブジェクトを作成します。ownがtrueの場合、このオブジェクトを閉じると基になるディスクリプタも閉じられます。デフォルトでは、IOStreamはガーベジコレクションされると閉じられます。nameを使用すると、ディスクリプタを名前付きファイルに関連付けることができます。

flush(stream)

指定されたストリームに現在バッファリングされているすべての書き込みをコミットします。

close(stream)

I/Oストリームを閉じます。最初にflushを実行します。

closewrite(stream)

フルデュプレックスI/Oストリームの書き込み半分をシャットダウンします。最初にflushを実行します。基盤となるファイルにデータがこれ以上書き込まれないことを他の端に通知します。これはすべてのIOタイプでサポートされているわけではありません。

実装されている場合、closewriteは、ブロックするはずの後続のreadまたはeof呼び出しが、代わりにEOFをスローするか、真を返すようにします。ストリームがすでに閉じている場合、これは冪等です。

例

julia> io = Base.BufferStream(); # これは決してブロックしないので、同じタスクで読み書きできます

julia> write(io, "request");

julia> # ここで`read(io)`を呼び出すと永遠にブロックされます

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

指定されたI/Oストリームまたはファイルに値の標準的なバイナリ表現を書き込みます。ストリームに書き込まれたバイト数を返します。テキスト表現を書き込むには、printを参照してください（エンコーディングはioに依存する場合があります）。

書き込まれる値のエンディアンはホストシステムのエンディアンに依存します。プラットフォーム間で一貫した結果を得るために、書き込み/読み込み時に固定エンディアンに変換してください（例：htolおよびltohを使用）。

同じwrite呼び出しで複数の値を書くことができます。すなわち、以下は同等です：

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

例

一貫したシリアル化：

julia> fname = tempname(); # ランダムな一時ファイル名

julia> open(fname,"w") do f
           # 64ビット整数をリトルエンディアンバイト順で書き込むことを確認
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # ホストバイト順とホスト整数型に戻す
           Int(ltoh(read(f,Int64)))
       end
42

書き込み呼び出しのマージ：

julia> io = IOBuffer();

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

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

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

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

writeメソッドを持たないユーザー定義のプレーンデータ型は、Refでラップすることで書き込むことができます：

julia> struct MyStruct; x::Float64; end

julia> io = IOBuffer()
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=Inf, ptr=1, mark=-1)

julia> write(io, Ref(MyStruct(42.0)))
8

julia> seekstart(io); read!(io, Ref(MyStruct(NaN)))
Base.RefValue{MyStruct}(MyStruct(42.0))

read(io::IO, T)

io から型 T の単一の値を、標準的なバイナリ表現で読み取ります。

Julia はエンディアンを自動的に変換しないことに注意してください。この目的のために ntoh または ltoh を使用してください。

read(io::IO, String)

io の全体を String として読み取ります（readchomp も参照）。

例

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

julia> read(io, Char)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

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

julia> read(io, String)
"JuliaLang is a GitHub organization"

read(filename::AbstractString)

ファイルの全内容を Vector{UInt8} として読み込みます。

read(filename::AbstractString, String)

ファイルの全内容を文字列として読み込みます。

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

ファイルを開いてその内容を読み込みます。args は read に渡されます：これは open(io->read(io, args...), filename) と同等です。

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

sから最大nbバイトを読み取り、読み取ったバイトのVector{UInt8}を返します。

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

sから最大nbバイトを読み取り、読み取ったバイトのVector{UInt8}を返します。

allがtrue（デフォルト）である場合、この関数はエラーまたはファイルの終わりが発生するまで、要求されたすべてのバイトを読み取るために繰り返しブロックします。allがfalseの場合、最大で1回の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))

ストリームから最大 nb バイトを b に読み込み、読み込まれたバイト数を返します。必要に応じて b のサイズは増加します（つまり、nb が length(b) より大きく、十分なバイトが読み込まれた場合）、ただし減少することはありません。

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

ストリームから最大 nb バイトを b に読み込み、読み取ったバイト数を返します。必要に応じて b のサイズが増加します（つまり、nb が length(b) より大きく、十分なバイトが読み取れた場合）が、減少することはありません。

all が true の場合（デフォルト）、この関数はエラーまたはファイルの終わりが発生するまで、要求されたすべてのバイトを読み取るために繰り返しブロックします。all が false の場合、最大で1回の read 呼び出しが行われ、返されるデータの量はデバイスに依存します。すべてのストリームタイプが all オプションをサポートしているわけではないことに注意してください。

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

IO ストリームオブジェクトから ref に nbytes をコピーします（ポインタに変換されます）。

サブタイプ T<:IO は、より効率的な実装を提供するために、次のメソッドシグネチャをオーバーライドすることを推奨します: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

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

ref（ポインタに変換された）からnbytesをIOオブジェクトにコピーします。

サブタイプT<:IOは、より効率的な実装を提供するために、次のメソッドシグネチャをオーバーライドすることを推奨します: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

read(io, T) を返す反復可能なオブジェクトを返します。

他にも skipchars、eachline、readuntil があります。

例

julia> io = IOBuffer("JuliaLang is a GitHub organization.\n It has many members.\n");

julia> for c in readeach(io, Char)
           c == '\n' && break
           print(c)
       end
JuliaLang is a GitHub organization.

peek(stream[, T=UInt8])

ストリームから現在の位置を進めることなく、型 T の値を読み取って返します。詳細は startswith(stream, char_or_string) を参照してください。

例

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

position(l::Lexer)

現在の位置を返します。

位置

ストリームの現在の位置を取得します。

例

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

julia> seek(io, 5);

julia> position(io)
5

julia> skip(io, 10);

julia> position(io)
15

julia> seekend(io);

julia> position(io)
35

seek(s, pos)

ストリームを指定された位置にシークします。

例

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

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (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 を返した後に1バイトを読み取ることは常に安全です。eof は、リモート接続の端が閉じられていても、バッファリングされたデータがまだ利用可能な限り false を返します。

例

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

ストリームが読み取り専用かどうかを判断します。

例

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

与えられた path のアクセス権が現在のユーザーによる書き込みを許可している場合は true を返します。

関連情報として ispath、isexecutable、isreadable を参照してください。

iswritable(io) -> Bool

指定された IO オブジェクトが書き込み可能でない場合は false を返します。

例

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

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

isreadable(path::String)

指定された path のアクセス権が現在のユーザーによる読み取りを許可している場合は true を返します。

関連情報として ispath、isexecutable、iswritable を参照してください。

isreadable(io) -> Bool

指定されたIOオブジェクトが読み取り可能でない場合はfalseを返します。

例

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")

isexecutable(path::String)

指定された path に実行権限がある場合は true を返します。

他にも ispath、isreadable、iswritable を参照してください。

isopen(object) -> Bool

オブジェクト（ストリームやタイマーなど）がまだ閉じられていないかどうかを判断します。オブジェクトが閉じられると、新しいイベントは決して生成されません。ただし、閉じられたストリームにはバッファに読み取るデータが残っている可能性があるため、データを読み取る能力を確認するにはeofを使用してください。ストリームが書き込み可能または読み取り可能になると通知を受けるには、FileWatchingパッケージを使用してください。

例

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

ストリームまたはファイルをバックアップするファイルディスクリプタを返します。この関数は、非同期ストリームではなく、同期的な File と IOStream のみに適用されることに注意してください。

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

stdin、stderr、stdoutのサブセットのストリームをリダイレクトします。各引数はIOStream、TTY、Pipe、ソケット、またはdevnullでなければなりません。

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

stdin、stderr、stdout のストリームの一部をリダイレクトし、f() を呼び出して各ストリームを復元します。

各ストリームの可能な値は次のとおりです：

• nothing はストリームをリダイレクトしないことを示します。
• path::AbstractString はストリームを path のファイルにリダイレクトします。
• io は IOStream、TTY、Pipe、ソケット、または devnull です。

例

julia> redirect_stdio(stdout="stdout.txt", stderr="stderr.txt") do
           print("hello stdout")
           print(stderr, "hello stderr")
       end

julia> read("stdout.txt", String)
"hello stdout"

julia> read("stderr.txt", String)
"hello stderr"

エッジケース

stdout と stderr に同じ引数を渡すことが可能です：

julia> redirect_stdio(stdout="log.txt", stderr="log.txt", stdin=devnull) do
    ...
end

ただし、同じファイルの2つの異なるディスクリプタを渡すことはサポートされていません。

julia> io1 = open("same/path", "w")

julia> io2 = open("same/path", "w")

julia> redirect_stdio(f, stdout=io1, stderr=io2) # サポートされていません

また、stdin 引数は stdout または stderr と同じディスクリプタであってはなりません。

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # サポートされていません

redirect_stdout([stream]) -> stream

すべてのCおよびJuliaレベルのstdout出力がリダイレクトされるパイプを作成します。パイプの端を表すストリームを返します。stdoutに書き込まれたデータは、パイプのrd端から読み取ることができます。

関連情報としてredirect_stdioも参照してください。

redirect_stdout(f::Function, stream)

関数 f を実行しながら stdout を stream にリダイレクトします。完了後、stdout は以前の設定に戻されます。

redirect_stderr([stream]) -> stream

stderrのためのredirect_stdoutのように。

他にredirect_stdioも参照してください。

redirect_stderr(f::Function, stream)

関数 f を実行し、stderr を stream にリダイレクトします。完了後、stderr は以前の設定に戻されます。

redirect_stdin([stream]) -> stream

stdoutと同様ですが、stdin用です。ストリームの方向が逆になっていることに注意してください。

他にredirect_stdioも参照してください。

redirect_stdin(f::Function, stream)

関数 f を実行しながら stdin を stream にリダイレクトします。完了後、stdin は以前の設定に復元されます。

readchomp(x)

xの全体を文字列として読み込み、もしあれば末尾の改行を1つ削除します。chomp(read(x, String))と同等です。

例

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readchomp("my_file.txt")
"JuliaLang is a GitHub organization.\nIt has many members."

julia> rm("my_file.txt");

truncate(file, n)

最初の引数で指定されたファイルまたはバッファのサイズを正確に n バイトに変更し、ファイルまたはバッファが拡張される場合は、以前に未割り当てのスペースを '\0' で埋めます。

例

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.")
35

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

julia> String(take!(io))
"JuliaLang is a "

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.");

julia> truncate(io, 40);

julia> String(take!(io))
"JuliaLang is a GitHub organization.\0\0\0\0\0"

skipchars(predicate, io::IO; linecomment=nothing)

ストリーム io を進めて、次に読み取る文字が predicate が false を返す最初の残りの文字になるようにします。キーワード引数 linecomment が指定されている場合、その文字から次の行の開始までのすべての文字は無視されます。

例

julia> buf = IOBuffer("    text")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=1, mark=-1)

julia> skipchars(isspace, buf)
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=5, mark=-1)

julia> String(readavailable(buf))
"text"

countlines(io::IO; eol::AbstractChar = '\n')
countlines(filename::AbstractString; eol::AbstractChar = '\n')

ioをストリーム/ファイルの終わりまで読み取り、行数をカウントします。ファイルを指定するには、最初の引数としてファイル名を渡します。EOLマーカーは、第二引数として渡すことで'\n'以外のものもサポートされています。ioの最後の非空行は、EOLで終わっていなくてもカウントされ、eachlineおよびreadlinesによって返される長さと一致します。

Stringの行数をカウントするには、countlines(IOBuffer(str))を使用できます。

例

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

julia> countlines(io)
1

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

julia> countlines(io)
1

julia> eof(io) # 行をカウントするとファイルポインタが移動します
true

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

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

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

julia> countlines("my_file.txt")
1

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

julia> rm("my_file.txt")

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

IOBufferを使用して、読み取りを行い、追加することで書き込みを行うことができるバッファです。シークやトランケートはサポートされていません。利用可能なコンストラクタについてはIOBufferを参照してください。dataが指定されている場合、データベクター上で操作するためのPipeBufferを作成し、基盤となるArrayが成長できないサイズをオプションで指定します。

readavailable(stream)

ストリームから利用可能なバッファデータを読み取ります。実際のI/Oは、すでにデータがバッファリングされていない場合にのみ実行されます。結果は Vector{UInt8} です。

IOContext

IOContextは、showメソッド間で出力設定を渡すためのメカニズムを提供します。

要するに、これはIOのサブクラスである不変の辞書です。標準の辞書操作（getindexなど）をサポートしており、I/Oストリームとしても使用できます。

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

指定されたストリームをラップし、そのストリームのプロパティに指定された key=>value ペアを追加する IOContext を作成します（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)

contextのプロパティを継承しつつ、別のIOをラップするIOContextを作成します。

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

値 x のテキスト表現を出力ストリーム io に書き込みます。新しい型 T は show(io::IO, x::T) をオーバーロードする必要があります。show によって使用される表現は一般的にJulia特有のフォーマットと型情報を含み、可能な限り解析可能なJuliaコードであるべきです。

repr は show の出力を文字列として返します。

型 T のオブジェクトに対してより詳細な人間可読のテキスト出力を提供するには、show(io::IO, ::MIME"text/plain", ::T) を追加で定義します。これらのメソッドでは、io の :compact IOContext キー（通常は get(io, :compact, false)::Bool としてチェックされる）を確認することが推奨されます。なぜなら、一部のコンテナはこのメソッドを :compact => true で呼び出して要素を表示するからです。

また、装飾のない表現を書き込む print も参照してください。

例

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

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

ストリーム io に出力するか、値の簡単な説明を与える文字列 str を返します。デフォルトでは string(typeof(x)) を返します。例えば、Int64 のように。

配列の場合、サイズと型情報の文字列を返します。例えば、10-element Array{Int64,1} のように。

例

julia> summary(1)
"Int64"

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

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

io に書き込みます（io が指定されていない場合はデフォルトの出力ストリーム stdout に書き込みます）。print で使用される表現は、最小限のフォーマットを含み、Julia 特有の詳細を避けるようにしています。

print は show を呼び出すことにフォールバックするため、ほとんどの型は単に show を定義すればよいです。あなたの型に別の「プレーン」表現がある場合は print を定義してください。たとえば、show は文字列を引用符付きで表示し、print は引用符なしで表示します。

println、string、printstyled も参照してください。

例

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

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

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

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

xsをioに出力し、その後に改行を追加します。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ペアのタプル、またはfに渡されるI/Oストリームに使用される属性を持つIOまたはIOContextオブジェクトに設定できます。オプションの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ストリームまたはファイルから1行のテキストを読み取ります（デフォルトはstdin）。ファイルから読み取る場合、テキストはUTF-8でエンコードされていると仮定されます。入力の行は'\n'または"\r\n"または入力ストリームの終わりで終了します。keepがfalse（デフォルトではそうです）の場合、これらの末尾の改行文字は返される前に行から削除されます。keepがtrueの場合、それらは行の一部として返されます。

Stringを返します。別のストリームにインプレースで書き込むには、copylineも参照してください（これは事前に割り当てられたIOBufferである可能性があります）。

より一般的な区切り文字まで読み取るには、readuntilも参照してください。

例

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readline("my_file.txt")
"JuliaLang is a GitHub organization."

julia> readline("my_file.txt", keep=true)
"JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt")

julia> print("Enter your name: ")
Enter your name:

julia> your_name = readline()
Logan
"Logan"

readuntil(stream::IO, delim; keep::Bool = false)
readuntil(filename::AbstractString, delim; keep::Bool = false)

I/O stream またはファイルから、指定された区切り文字までの文字列を読み取ります。区切り文字は UInt8、AbstractChar、文字列、またはベクターであることができます。キーワード引数 keep は、区切り文字が結果に含まれるかどうかを制御します。テキストは UTF-8 でエンコードされていると仮定されます。

delim が AbstractChar または文字列の場合は String を返し、それ以外の場合は Vector{typeof(delim)} を返します。代わりに別のストリーム（事前に割り当てられた IOBuffer である可能性があります）にインプレースで書き込むには、copyuntil も参照してください。

例

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)

I/O ストリームまたはファイルから各行を生成する iterable EachLine オブジェクトを作成します。反復処理は、ストリーム引数に対して readline を繰り返し呼び出し、keep を渡して、末尾の改行文字が保持されるかどうかを決定します。ファイル名で呼び出された場合、反復処理の最初にファイルが一度開かれ、最後に閉じられます。反復処理が中断された場合、EachLine オブジェクトがガーベジコレクションされるときにファイルは閉じられます。

String の各行を反復処理するには、eachline(IOBuffer(str)) を使用できます。

Iterators.reverse は EachLine オブジェクトに対して使用でき、逆順で行を読み取ることができます（ファイル、バッファ、および seek をサポートする他の I/O ストリームの場合）、また first または last を使用して、それぞれ最初または最後の行を抽出できます。

例

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\n It has many members.\n");

julia> for line in eachline("my_file.txt")
           print(line)
       end
JuliaLang is a GitHub organization. It has many members.

julia> rm("my_file.txt");

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

I/O `stream` またはファイルから `out` ストリームにテキストの1行をコピーし、`out` を返します。

ファイルから読み取る場合、テキストはUTF-8でエンコードされていると仮定されます。入力の行は `'\n'` または `"\r\n"` または入力ストリームの終わりで終了します。`keep` が false の場合（デフォルトではそうです）、これらの末尾の改行文字は返される前に行から削除されます。`keep` が true の場合、それらは行の一部として返されます。

[`readline`](@ref) に似ていますが、`String` を返すのに対し、`copyline` は文字列を割り当てることなく直接 `out` に書き込みます。（これは、例えば、事前に割り当てられた [`IOBuffer`](@ref) にデータを読み込むために使用できます。）

より一般的な区切り文字まで読み取るための [`copyuntil`](@ref) も参照してください。

# 例

jldoctest julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyline(IOBuffer(), "my_file.txt"))) "JuliaLang is a GitHub organization."

julia> String(take!(copyline(IOBuffer(), "my_file.txt", keep=true))) "JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt") ```

copyuntil(out::IO, stream::IO, delim; keep::Bool = false)
copyuntil(out::IO, filename::AbstractString, delim; keep::Bool = false)

I/O stream またはファイルから、指定された区切り文字までの文字列を out ストリームにコピーし、out を返します。区切り文字は UInt8、AbstractChar、文字列、またはベクターであることができます。キーワード引数 keep は、結果に区切り文字が含まれるかどうかを制御します。テキストは UTF-8 でエンコードされていると仮定されます。

readuntil に似ていますが、copyuntil は文字列を割り当てることなく、直接 out に書き込みます。（これは、例えば、事前に割り当てられた IOBuffer にデータを読み込むために使用できます。）

例

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", 'L')))
"Julia"

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", '.', keep = true)))
"JuliaLang is a GitHub organization."

julia> rm("my_file.txt")

displaysize([io::IO]) -> (lines, columns)

この IO オブジェクトに出力をレンダリングするために使用できる画面の名目サイズを返します。入力が提供されていない場合、環境変数 LINES と COLUMNS が読み取られます。それらが設定されていない場合、デフォルトサイズ (24, 80) が返されます。

例

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

TTYサイズを取得するには、

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

リッチな表示出力デバイスのための抽象スーパタイプです。 TextDisplay はこれのサブタイプです。

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

xを表示スタックの最上位の適用可能な表示を使用して表示します。通常、xに対してサポートされている最もリッチなマルチメディア出力を使用し、プレーンテキストstdout出力をフォールバックとして使用します。display(d, x)のバリアントは、指定された表示dのみにxを表示しようとし、dがこのタイプのオブジェクトを表示できない場合はMethodErrorをスローします。

一般に、displayの出力がstdoutに送られるとは限りません（print(x)やshow(x)とは異なります）。たとえば、display(x)は画像を表示するために別のウィンドウを開くことがあります。display(x)は「現在の出力デバイスに対してできる限り最良の方法でxを表示する」という意味です。stdoutに確実に送られるREPLのようなテキスト出力が必要な場合は、代わりにshow(stdout, "text/plain", x)を使用してください。

mime引数（"image/png"のようなMIMEタイプの文字列）を持つ2つのバリアントもあり、要求されたMIMEタイプのみを使用してxを表示しようとし、このタイプが表示またはxによってサポートされていない場合はMethodErrorをスローします。これらのバリアントでは、x::AbstractString（text/htmlやapplication/postscriptなどのテキストベースのストレージを持つMIMEタイプの場合）またはx::Vector{UInt8}（バイナリMIMEタイプの場合）を渡すことで、要求されたMIMEタイプの「生」データを提供することもできます。

タイプのインスタンスがどのように表示されるかをカスタマイズするには、showをオーバーロードし、displayではなく、カスタムプリティプリンティングに関するマニュアルのセクションで説明されているようにしてください。

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

デフォルトでは、redisplay 関数は単に display を呼び出します。しかし、一部の表示バックエンドは、既存の x の表示を変更するために redisplay をオーバーライドする場合があります（もしあれば）。redisplay を使用することは、バックエンドに対して x が何度も再表示される可能性があることを示すヒントでもあり、バックエンドは（例えば）次の対話型プロンプトまで表示を遅延させることを選択するかもしれません。

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

与えられた mime タイプ（文字列）が、現在の表示スタック内のいずれかの表示によって表示可能か、または第二のバリアントで表示 d によって特に表示可能かを示すブール値を返します。

show(io::IO, mime, x)

display 関数は最終的に show を呼び出して、オブジェクト x を指定された mime タイプで指定された I/O ストリーム io（通常はメモリバッファ）に書き込みます。ユーザー定義型 T のリッチなマルチメディア表現を提供するためには、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) = ... という関数を定義して、あなたの画像が PNG 対応の任意の AbstractDisplay（IJulia など）で表示されるようにすることができます。通常通り、組み込みの Julia 関数 show に新しいメソッドを追加するために import Base.show を忘れずに行ってください。

技術的には、MIME"mime" マクロは指定された mime 文字列のためのシングルトン型を定義し、任意の型のオブジェクトを表示する方法を決定する際に Julia のディスパッチメカニズムを利用できるようにします。

デフォルトの MIME タイプは MIME"text/plain" です。text/plain 出力のためのフォールバック定義があり、2 引数で show を呼び出すため、その場合のメソッドを追加する必要は常にありません。ただし、型がカスタムの人間可読出力から利益を得る場合、show(::IO, ::MIME"text/plain", ::T) を定義するべきです。例えば、Day 型は text/plain MIME タイプの出力として 1 day を使用し、2 引数の show の出力として Day(1) を使用します。

例

julia> struct Day
           n::Int
       end

julia> Base.show(io::IO, ::MIME"text/plain", d::Day) = print(io, d.n, " day")

julia> Day(1)
1 day

コンテナ型は一般的に、要素 x に対して show(io, MIME"text/plain"(), x) を呼び出すことで 3 引数の show を実装し、最初の引数として渡される IOContext で :compact => true が設定されます。

showable(mime, x)

オブジェクト x が指定された mime タイプとして書き込むことができるかどうかを示すブール値を返します。

（デフォルトでは、これは typeof(x) に対する対応する show メソッドの存在によって自動的に決定されます。一部の型はカスタム showable メソッドを提供します。たとえば、利用可能なMIMEフォーマットが x の値に依存する場合です。）

例

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

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

repr(mime, x; context=nothing)

要求された mime タイプでの x の表現を含む AbstractString または Vector{UInt8} を返します。これは 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 の「整形された」バージョンです。代わりに show(x) に対応する文字列を返す repr(x) も参照してください。これは x の値が Julia にどのように入力されるかに近いかもしれません。

例

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

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

MIME

標準的なインターネットデータ形式を表す型です。"MIME"は"Multipurpose Internet Mail Extensions"の略で、標準は元々電子メールメッセージへのマルチメディア添付ファイルを説明するために使用されていました。

MIMEオブジェクトは、showに対して2番目の引数として渡すことで、その形式での出力を要求できます。

例

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) を呼び出すと、スタック内の最上位の互換性のあるバックエンド（すなわち、MethodError をスローしない最上位のバックエンド）で x が表示されます。

popdisplay()
popdisplay(d::AbstractDisplay)

ディスプレイバックエンドスタックから最上位のバックエンドをポップするか、2番目のバリアントでの d の最上位のコピーをポップします。

TextDisplay(io::IO)

TextDisplay <: AbstractDisplay を返します。これは、任意のオブジェクトをテキスト/plain MIME タイプ（デフォルト）として表示し、テキスト表現を指定された I/O ストリームに書き込みます。（これは、Julia REPL でオブジェクトが印刷される方法です。）

istextmime(m::MIME)

MIMEタイプがテキストデータであるかどうかを判断します。MIMEタイプは、テキストデータとして知られている一部のタイプを除いて、バイナリデータであると見なされます（おそらくUnicode）。

例

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

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

bytesavailable(io)

このストリームまたはバッファからの読み取りがブロックされる前に、読み取りのために利用可能なバイト数を返します。

例

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

julia> bytesavailable(io)
34

ntoh(x)

ネットワークバイトオーダー（ビッグエンディアン）からホストが使用するエンディアンに値のエンディアンを変換します。

hton(x)

ホストが使用するエンディアンからネットワークバイトオーダー（ビッグエンディアン）に値のエンディアンを変換します。

ltoh(x)

値のエンディアンをリトルエンディアンからホストで使用されるものに変換します。

htol(x)

ホストで使用されるエンディアンからリトルエンディアンに値のエンディアンを変換します。

ENDIAN_BOM

32ビットバイトオーダーマークは、ホストマシンのネイティブバイトオーダーを示します。リトルエンディアンマシンは値 0x04030201 を含みます。ビッグエンディアンマシンは値 0x01020304 を含みます。