I/O and Network

General I/O

Core.IO — Type
IO

入出力型の抽象スーパータイプ。

source
Base.stdout — Constant
stdout::IO

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

source
Base.stderr — Constant
stderr::IO

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

source
Base.stdin — Constant
stdin::IO

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

source
Base.read — Method
read(filename::AbstractString)

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

read(filename::AbstractString, String)

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

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

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

source
Base.write — Method
write(filename::AbstractString, content)

content の正規バイナリ表現をファイルに書き込みます。ファイルが存在しない場合は新規作成し、存在する場合は上書きします。

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

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

open(command, args...; kwargs...)と似ていますが、結果のプロセスストリームに対してf(stream)を呼び出した後、入力ストリームを閉じてプロセスの完了を待ちます。成功した場合は、fが返す値を返します。プロセスが失敗した場合、または標準出力への出力を試みた場合は、エラーをスローします。

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

command の実行を非同期で開始し、process::IO オブジェクトを返します。read が true の場合、プロセスからの読み取り元はプロセスの標準出力となり、stdio でプロセスの標準入力ストリームを任意で指定できます。write が true の場合、書き込み先はプロセスの標準入力となり、stdio でプロセスの標準出力ストリームを任意で指定できます。プロセスの標準エラーストリームは、現在のグローバルな stderr に接続されます。

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

commandを非同期で実行します。open(command, stdio; read, write)と同様ですが、読み取りフラグと書き込みフラグをキーワード引数ではなくモード文字列で指定します。指定できるモード文字列は次のとおりです。

モード説明キーワード
r読み取りなし
w書き込みwrite = true
r+読み取り、書き込みread = true, write = true
w+読み取り、書き込みread = true, write = true
source
open(fd::OS_HANDLE)::IO

生のファイルディスクリプタを受け取り、Julia 対応の IO 型でラップして、その fd ハンドルの所有権を取得します。元のハンドルの所有権を引き継がないようにするには、open(Libc.dup(fd)) を呼び出してください。

Warning

システム内の別の部分がすでに所有しているハンドルに対して、この関数を呼び出さないでください。

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

5つのブール値の代わりに文字列でモードを指定する、mode の別の構文です。値は fopen(3) または Perl の open に対応し、次のブール値の組み合わせを設定するのと同等です。

モード説明キーワード
r読み取りなし
w書き込み、作成、切り詰めwrite = true
a書き込み、作成、追記append = true
r+読み取り、書き込みread = true, write = true
w+読み取り、書き込み、作成、切り詰めtruncate = true, read = true
a+読み取り、書き込み、作成、追記append = true, read = true

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

Examples

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")
Julia 1.5

lock 引数は Julia 1.5 以降で利用できます。

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

5つの真偽値キーワード引数で指定したモードでファイルを開きます。

キーワード説明デフォルト
read読み取り用に開く!write
write書き込み用に開くtruncate | append
create存在しない場合は作成!read & write | truncate | append
truncateサイズをゼロに切り詰める!read & write
appendファイル末尾にシークfalse

キーワードを指定しない場合、デフォルトではファイルを読み取り専用で開きます。開いたファイルにアクセスするためのストリームを返します。

lockキーワード引数は、マルチスレッド環境で安全にアクセスできるよう、操作をロックするかどうかを制御します。

Julia 1.5

lock引数はJulia 1.5以降で使用できます。

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

open(args...; kwargs...)の結果に関数fを適用し、完了後に生成されたファイル記述子を閉じてください。

Examples

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

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

julia> rm("myfile.txt")
source
Base.IOStream — Type
IOStream

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

source
Base.IOBuffer — Type
IOBuffer(string::String)

指定された文字列の基になるデータに対する読み取り専用のIOBufferを作成します。

Examples

julia> io = IOBuffer("Haho");

julia> takestring!(io)
"Haho"

julia> takestring!(io)
"Haho"
source
IOBuffer([data::AbstractVector{UInt8}]; keywords...)::IOBuffer

メモリ上に I/O ストリームを作成します。既存の配列を使用することもできます。

次のキーワード引数を省略可能な形で指定できます。

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

data を指定しない場合、バッファーはデフォルトで読み書き可能になります。

`write=true` を指定して `data` を `IOBuffer` のスクラッチ領域として渡すと、予期しない動作が起こることがあります

IOBuffer に対して write を呼び出した後は、data への以前の参照は無効になったものと考えるのが最善です。実質的に、take! が呼び出されるまで、IOBuffer がこのデータを「所有」します。data を間接的に変更すると、IOBuffer が前提とする抽象化が損なわれ、未定義の動作につながる可能性があります。write=true の場合、IOBuffer は任意のオフセットにデータを格納し、ほかのオフセットには任意の値を残すことがあります。maxsize > length(data) の場合、IOBuffer はデータ全体を再割り当てすることがあります。その結果は、array への既存のバインディングから見える場合もあれば、見えない場合もあります。

Examples

julia> io = IOBuffer();

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

julia> takestring!(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> takestring!(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
source
Base.take! — Method
take!(b::IOBuffer)

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

Examples

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."
source
Base.Pipe — Type
Pipe()

複数のプロセス間での IO 通信などに使う、未初期化の Pipe オブジェクトを構築します。

プロセスの起動時にこのオブジェクトを使用すると、パイプの適切な端が自動的に初期化されます。たとえば、プロセスパイプライン内で参照を簡単に取得するのに便利です。

julia> err = Pipe()

# After this `err` will be initialized and you may read `foo`'s
# stderr from the `err` pipe, or pass `err` to other pipelines.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# Now destroy the write half of the pipe, so that the read half will get EOF
julia> closewrite(err)

julia> read(err, String)
"stderr messages"

Base.link_pipe! も参照してください。

source
Base.link_pipe! — Function
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にしてください。

source
Base.fdio — Function
fdio([name::AbstractString, ]fd::Integer[, own::Bool=false])::IOStream

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

source
Base.flush — Function
flush(io::IO)

現在バッファにある書き込みをすべて、指定された io にコミットします。デフォルト実装は flush(::IO) = nothing なので、汎用 IO コードから呼び出すことができます。

source
Base.close — Function
close(io::IO)

ioを閉じます。まずflushを実行します。

IOを閉じると、その基盤となるリソース(OSハンドル、ネットワーク接続など)が破棄されることを示します。閉じたIOは状態が未定義であり、読み書きしてはいけません。閉じたIOに対して読み書きを試みた場合、実装によっては例外が発生したり、通常どおり動作し続けたり、0バイトの読み書きが行われたりすることがあります。ただし、閉じたIOの読み書きによって未定義動作が発生しないよう、実装側で保証する必要があります。

関連項目: isopen

source
Base.closewrite — Function
closewrite(stream)

全二重 I/O ストリームの書き込み側をシャットダウンします。まず flush を実行します。基盤となるファイルにはこれ以上データを書き込まないことを、相手側に通知します。この操作は、すべての IO 型でサポートされているわけではありません。

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

Examples

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"
source
Base.write — Function
write(io::IO, x)

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

書き込まれる値のエンディアンは、ホストシステムのエンディアンに依存します。プラットフォーム間で結果を一貫させるには、書き込み時または読み込み時に、htolやltohなどを使って固定エンディアンに変換してください。

同じwrite呼び出しで複数の値を書き込めます。つまり、次の例は同じ結果になります。

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

Examples

一貫性のあるシリアライズ:

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

write呼び出しの統合:

julia> io = IOBuffer();

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

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

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

julia> takestring!(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))
source
Base.read — Function
read(command::Cmd, String)

command を実行し、結果を String として返してください。

source
read(command::Cmd)

commandを実行し、結果をバイト配列として返してください。

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

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

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

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

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

source
read(filename::AbstractString)

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

read(filename::AbstractString, String)

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

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

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

source
read(io::IO, T)

ioから、T型の値を1つ、標準的なバイナリ表現で読み込みます。

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

read(io::IO, String)

io全体を、Stringとして読み込みます(readchompも参照)。

Examples

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"
source
Base.read! — Function
read!(stream::IO, array::AbstractArray)
read!(filename::AbstractString, array::AbstractArray)

I/Oストリームまたはファイルからバイナリデータを読み込み、arrayを埋めます。

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

stream から最大 nb バイトを b に読み込み、読み取ったバイト数を返します。必要に応じて(つまり、nb が length(b) より大きく、十分なバイト数を読み取れた場合)、b のサイズは拡張されますが、縮小されることはありません。

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

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

stream から最大 nb バイトを b に読み込み、読み取ったバイト数を返します。必要に応じて(つまり、nb が length(b) より大きく、十分なバイトを読み取れる場合)、b のサイズは拡張されますが、縮小されることはありません。

source
Base.unsafe_read — Function
unsafe_read(io::IO, ref, nbytes::UInt)

IOストリームオブジェクトからnbytesをコピーし、ref(ポインターに変換済み)に格納します。

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

source
Base.unsafe_write — Function
unsafe_write(io::IO, ref, nbytes::UInt)

ref(ポインターに変換したもの)から nbytes をコピーし、IO オブジェクトに格納します。

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

source
Base.readeach — Function
readeach(io::IO, T)

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

関連項目: skipchars、eachline、readuntil。

Julia 1.6

readeachにはJulia 1.6以降が必要です。

Examples

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.
source
Base.peek — Function
peek(stream[, T=UInt8])

ストリームの現在位置を進めずに、ストリームから値を読み取り、型 T の値として返します。関連項目: startswith(stream, char_or_string)。

Examples

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)
Julia 1.5

型を受け取るメソッドは、Julia 1.5 以降で利用できます。

source
Base.position — Function
position(l::Lexer)

現在の位置を返します。

source
position(s)

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

Examples

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
source
Base.seek — Function
seek(s, pos)

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

Examples

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)
source
Base.seekstart — Function
seekstart(s)

ストリームを先頭までシークします。

Examples

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)
source
Base.seekend — Function
seekend(s)

ストリームを末尾までシークします。

source
Base.skip — Function
skip(s, offset)

現在位置を基準にストリームをシークします。

Examples

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)
source
Base.mark — Function
mark(s::IO)

ストリーム s の現在位置にマークを追加します。マークした位置を返します。

関連項目: unmark、reset、ismarked。

source
Base.unmark — Function
unmark(s::IO)

ストリーム s からマークを削除します。ストリームにマークが付いていた場合は true を、そうでない場合は false を返します。

mark、reset、ismarked も参照してください。

source
Base.reset — Method
reset(s::IO)

ストリーム s を、以前にマークした位置に戻し、そのマークを削除します。以前にマークした位置を返します。ストリームにマークが付いていない場合はエラーをスローします。

関連項目: mark、unmark、ismarked。

source
Base.ismarked — Function
ismarked(s::IO)

ストリーム s がマークされている場合は、true を返します。

mark、unmark、reset も参照してください。

source
Base.eof — Function
eof(stream)::Bool

I/Oストリームがファイル終端に達しているかどうかを調べます。ストリームのデータがまだ尽きていない場合、この関数は必要に応じて追加データが届くまでブロックし、その後falseを返します。したがって、eofがfalseを返した後は、常に安全に1バイト読み取れます。接続のリモート側が閉じられていても、バッファにデータが残っている限り、eofはfalseを返します。

Examples

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true
source
Base.isreadonly — Function
isreadonly(io)::Bool

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

Examples

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false
source
Base.iswritable — Function
iswritable(io)::Bool

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

Examples

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")
source
iswritable(path::String)

指定されたpathへのアクセス権限で現在のユーザーによる書き込みが許可されている場合、trueを返します。

Note

ユーザーがopenを呼び出す前に、この権限が変更される可能性があります。そのため、まずiswritableを呼び出すのではなく、openだけを呼び出し、失敗した場合はエラーを処理することをお勧めします。

Note

現在、この関数はWindows上のファイルシステムACLを正しく照会できないため、誤った結果を返すことがあります。

Julia 1.11

この関数を使用するには、Julia 1.11以降が必要です。

関連項目: ispath、isexecutable、isreadable。

source
Base.isreadable — Function
isreadable(io)::Bool

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

Examples

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")
source
isreadable(path::String)

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

Note

ユーザーがopenを呼び出す前に、この権限が変更される可能性があります。そのため、まずisreadableを呼び出すよりも、openだけを呼び出し、失敗した場合はエラーを処理することを推奨します。

Note

現在、この関数はWindows上のファイルシステムACLを正しく調べられないため、誤った結果を返すことがあります。

Julia 1.11

この関数を使用するには、Julia 1.11以降が必要です。

関連項目:ispath、isexecutable、iswritable。

source
Base.isexecutable — Function
isexecutable(path::String)

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

Note

ユーザーがpathを実行する前に、この権限が変更される可能性があります。そのため、先にisexecutableを呼び出すよりも、ファイルを実行し、失敗した場合はエラーを処理することを推奨します。

Note

Julia 1.6より前のバージョンでは、Windows上のファイルシステムACLを正しく調べられなかったため、どのファイルに対してもtrueを返していました。Julia 1.6以降では、ファイルに実行可能属性が設定されているかどうかを正しく判定します。

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

source
Base.isopen — Function
isopen(object)::Bool

IOやタイマーなどのオブジェクトがまだ開いており、したがってアクティブな状態かどうかを判定します。

関連項目: close

Examples

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false
source
Base.fd — Function
fd(x)::RawFD

ストリーム、ファイル、またはソケットの基になるファイルディスクリプターを返します。

RawFD オブジェクトは、ccall インターフェースを介して、他の言語に直接渡すことができます。

Julia 1.12

Julia 1.12 より前のバージョンでは、この関数は Int ではなく RawFD を返していました。すべての Julia バージョンで RawFD を生成するには、RawFD(fd(x)) を使用できます。

Julia 1.12

ソケットのファイルディスクリプターの取得は、Julia 1.12 以降でサポートされています。

Warning

返されたファイルディスクリプターを、所有権を引き継ぐ別のシステム(C ライブラリなど)に渡す前に、Libc.dup() を使って複製してください。そうしないと、Julia オブジェクト x と別のシステムの両方がファイルディスクリプターを閉じようとして、エラーが発生する可能性があります。

Warning

ソケットのファイルディスクリプターは非同期(POSIX では O_NONBLOCK、Windows では OVERLAPPED)であるため、通常のファイルディスクリプターとは異なる動作をする場合があります。

source
Base.redirect_stdio — Function
redirect_stdio(f; stdin=nothing, stderr=nothing, stdout=nothing)

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

各ストリームに指定できる値は次のとおりです。

  • nothing:ストリームをリダイレクトしません。
  • path::AbstractString:ストリームをファイル path にリダイレクトします。
  • io:IOStream、TTY、Pipe、ソケット、または devnull。

Examples

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"

Edge cases

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) # not supported

また、stdin 引数には、stdout または stderr と同じディスクリプターを指定できません。

julia> io = open(...)

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

redirect_stdio には Julia 1.7 以降が必要です。

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

ストリーム stdin、stderr、stdout の一部をリダイレクトします。各引数には、IOStream、TTY、Pipe、ソケット、または devnull を指定する必要があります。

Julia 1.7

redirect_stdio は Julia 1.7 以降で必要です。

source
Base.redirect_stdout — Function
redirect_stdout([stream]) -> stream

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

Note

stream は、IOStream、TTY、Pipe、ソケット、devnull など、互換性のあるオブジェクトでなければなりません。

redirect_stdio も参照してください。

source
Base.redirect_stdout — Method
redirect_stdout(f::Function, stream)

f 関数を実行する際、stdout を stream にリダイレクトします。実行が完了すると、stdout は元の設定に戻ります。

source
Base.redirect_stderr — Method
redirect_stderr(f::Function, stream)

f関数を実行する際、stderrをstreamにリダイレクトします。実行が完了すると、stderrは以前の設定に戻ります。

source
Base.redirect_stdin — Function
redirect_stdin([stream]) -> stream

redirect_stdoutと似ていますが、stdin向けです。ストリームの方向が逆であることに注意してください。

Note

streamは、IOStream、TTY、Pipe、ソケット、devnullなど、互換性のあるオブジェクトでなければなりません。

redirect_stdioも参照してください。

source
Base.redirect_stdin — Method
redirect_stdin(f::Function, stream)

stdin を stream にリダイレクトしながら、関数 f を実行します。完了すると、stdin は元の設定に戻ります。

source
Base.readchomp — Function
readchomp(x)

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

Examples

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");
source
Base.truncate — Function
truncate(file, n)

第1引数で指定されたファイルまたはバッファのサイズを、正確にnバイトに変更します。ファイルまたはバッファを拡張する場合、未割り当て領域は'\0'で埋められます。

Examples

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> takestring!(io)
"JuliaLang is a "

julia> io = IOBuffer();

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

julia> truncate(io, 40);

julia> takestring!(io)
"JuliaLang is a GitHub organization.\0\0\0\0\0"
source
Base.skipchars — Function
skipchars(predicate, io::IO; linecomment=nothing)

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

Examples

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"
source
Base.countlines — Function
countlines(io::IO; eol::AbstractChar = '\n')
countlines(filename::AbstractString; eol::AbstractChar = '\n')

io をストリームまたはファイルの末尾まで読み込み、行数を数えます。ファイルを指定するには、ファイル名を第1引数として渡します。'\n' 以外の行末(EOL)マーカーも、第2引数として渡すことで使用できます。io の最後の空でない行は、EOL で終わっていなくても数えられるため、eachline および readlines が返す長さと一致します。

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

Examples

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")
source
Base.PipeBuffer — Function
PipeBuffer(data::AbstractVector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))

読み取りが可能で、書き込みは追記によって行うIOBufferです。シークと切り詰めには対応していません。利用可能なコンストラクターについては、IOBufferを参照してください。dataが指定されている場合、データベクトルを操作するためのPipeBufferを作成します。必要に応じて、基になるArrayの拡張上限サイズも指定できます。

source
Base.readavailable — Function
readavailable(stream)

ストリームから、バッファーに格納されているデータを読み取ります。データがすでにバッファーに格納されている場合、実際の I/O は行われません。戻り値は Vector{UInt8} です。

Warning

返されるデータ量は実装に依存します。たとえば、内部で選択されるバッファーサイズによって異なる場合があります。通常は、read などの別の関数を使用してください。

source
Base.IOContext — Type
IOContext

IOContextは、showメソッド間で出力設定を受け渡すための仕組みです。

簡単に言うと、IOのサブクラスである不変の辞書です。getindexなどの標準的な辞書操作をサポートし、I/Oストリームとしても使用できます。

source
Base.IOContext — Method
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[Float16(0.0)]」ではなく「Float16[0.0]」と表示できます。配列の要素を表示する間、:typeinfoプロパティにはFloat16が設定されます)。
  • :color: ANSIカラー/エスケープコードがサポートされている、または想定されているかを指定するブール値です。デフォルトでは、ioが互換性のある端末かどうか、およびjuliaの起動時に指定された--colorコマンドラインフラグに基づいて決まります。

Examples

julia> io = IOBuffer();

julia> printstyled(IOContext(io, :color => true), "string", color=:red)

julia> takestring!(io)
"\e[31mstring\e[39m"

julia> printstyled(io, "string", color=:red)

julia> takestring!(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
source
Base.IOContext — Method
IOContext(io::IO, context::IOContext)

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

Note

ラップするioで明示的に設定しない限り、ioのdisplaysizeは継承されません。これは、デフォルトではdisplaysizeがIOオブジェクト自体のプロパティではなく、遅延的に推定されるためです。IOオブジェクトの存続中に、ターミナルウィンドウのサイズが変わる可能性があるからです。

source

Text I/O

Base.show — 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) も定義してください。このようなメソッドでは、io の :compact IOContext キー(多くの場合 get(io, :compact, false)::Bool として確認されます)を調べることを推奨します。一部のコンテナは、このメソッドを :compact => true とともに呼び出して要素を表示するためです。

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

Examples

julia> show("Hello World!")
"Hello World!"
julia> print("Hello World!")
Hello World!
source
Base.summary — Function
summary(io::IO, x)
str = summary(x)

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

配列の場合は、サイズと型の情報を含む文字列を返します。例:10-element Vector{Int64} または 9×4×5 Array{Float64, 3}。

Examples

julia> summary(1)
"Int64"

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

io(または、ioが指定されていない場合はデフォルトの出力ストリームであるstdout)に、装飾のない標準的なテキスト表現を書き込みます。printで使われる表現は、書式を最小限に抑え、Julia固有の詳細を避けるようにしています。

printは、xs内の各引数xに対して、2引数版のshow(io, x)を呼び出す処理にフォールバックします。そのため、ほとんどの型ではshowを定義するだけで十分です。型に独立した「プレーン」表現がある場合は、printを定義してください。たとえば、showは文字列を引用符付きで表示し、printは引用符なしで表示します。

関連項目:println、string、printstyled。

Examples

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

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

julia> takestring!(io)
"Hello World!"
source
Base.println — Function
println([io::IO], xs...)

print を使って xs を io に出力し、その後に改行します。io が指定されていない場合は、デフォルトの出力ストリーム stdout に出力します。

色などを追加するには、printstyled も参照してください。

Examples

julia> println("Hello, world")
Hello, world

julia> io = IOBuffer();

julia> println(io, "Hello", ',', " world.")

julia> takestring!(io)
"Hello, world.\n"
source
Base.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は端末上では表示されませんが、コピーすることはできます。これらの属性は任意に組み合わせて使用できます。

関連項目:print、println、show。

Note

すべての端末が斜体表示に対応しているわけではありません。斜体を反転表示または点滅表示として解釈する端末もあります。

Julia 1.7

colorとboldを除くキーワードは、Julia 1.7で追加されました。

Julia 1.10

斜体表示への対応はJulia 1.10で追加されました。

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

指定した関数を、I/Oストリームと追加の引数を渡して呼び出します。このI/Oストリームに書き込まれた内容は、文字列として返されます。

省略可能なキーワード引数 context には、:key=>value のペア、:key=>value のペアのタプル、または IO や IOContext オブジェクトを指定できます。これらの属性は、f に渡されるI/Oストリームに使用されます。省略可能な sizehint は、文字列の書き込みに使うバッファに割り当てるサイズ(バイト単位)の目安です。

Julia 1.7

キーワード context にタプルを渡すには、Julia 1.7以降が必要です。

Examples

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]"
source
Base.showerror — Function
showerror(io, e)

例外オブジェクト e の説明的な表現を表示します。このメソッドは、throw の呼び出し後に例外を表示するために使用されます。

Examples

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
source
Base.dump — Function
dump(x; maxdepth=8)

値の表現をすべて表示します。出力の深さは maxdepth で打ち切られます。

Examples

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}
source
Base.readline — Function
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 を返します。別のストリーム(事前に確保された IOBuffer など)にその場で書き込む場合は、copyline も参照してください。

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

Examples

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"
source
Base.readuntil — Function
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を参照してください。

Examples

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")
source
Base.readlines — Function
readlines(io::IO=stdin; keep::Bool=false)
readlines(filename::AbstractString; keep::Bool=false)

I/Oストリームまたはファイルのすべての行を、文字列のベクトルとして読み込みます。同じ引数でreadlineを繰り返し呼び出し、その結果を文字列のベクトルとして保存するのと同等の動作です。すべての行を一度に読み込まずに反復処理する方法については、eachlineも参照してください。

Examples

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")
source
Base.eachline — Function
eachline(io::IO=stdin; keep::Bool=false)
eachline(filename::AbstractString; keep::Bool=false)

I/Oストリームまたはファイルから各行を返す、反復可能なEachLineオブジェクトを作成します。反復中は、ストリーム引数に対してreadlineを繰り返し呼び出し、末尾の改行文字を保持するかどうかを指定するkeepを渡します。ファイル名を指定した場合、反復の開始時にファイルを一度だけ開き、終了時に閉じます。反復が中断された場合、ファイルはEachLineオブジェクトがガベージコレクションされる際に閉じられます。

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

EachLineオブジェクトに対してIterators.reverseを使用すると、行を逆順に読み取れます(ファイル、バッファー、およびseekをサポートするその他のI/Oストリームが対象です)。また、先頭または末尾の行を取り出すには、それぞれfirstまたはlastを使用できます。

Examples

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

eachlineイテレーターでIterators.reverseまたはlastを使用するには、Julia 1.8が必要です。

source
Base.copyline — Function
copyline(out::IO, io::IO=stdin; keep::Bool=false)
copyline(out::IO, filename::AbstractString; keep::Bool=false)

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

ファイルから読み取る場合、テキストはUTF-8でエンコードされているものとします。入力行は、'\n'、"\r\n"、または入力ストリームの終端で区切られます。keepがfalse(デフォルト)の場合、返す前に行末の改行文字を取り除きます。keepがtrueの場合、改行文字も行の一部として返します。

readlineと似ています。こちらはStringを返します。一方、copylineは文字列を割り当てずに、outへ直接書き込みます。(たとえば、事前に割り当てたIOBufferにデータを読み込む場合に利用できます。)

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

Examples

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

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

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

julia> rm("my_file.txt")
Julia 1.11

copylineがJulia 1.11で導入されました。

source
Base.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、文字列、またはベクトルを指定できます。キーワード引数keepは、区切り文字を結果に含めるかどうかを制御します。テキストはUTF-8でエンコードされているものとします。

readuntilと似ていますが、こちらはStringを返します。一方、copyuntilは文字列を割り当てずにoutへ直接書き込みます。(たとえば、事前に割り当てたIOBufferにデータを読み込む場合に利用できます。)

Examples

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

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

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

julia> rm("my_file.txt")
Julia 1.11

copyuntilはJulia 1.11で導入されました。

source
Base.displaysize — Function
displaysize([io::IO]) -> (lines, columns)

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

Examples

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

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

julia> displaysize(stdout)
(34, 147)
source

Multimedia I/O

テキスト出力を print が行い、ユーザー定義型が show をオーバーロードすることでテキスト表現を指定できるのと同様に、Julia には、画像、書式付きテキスト、さらには音声や動画などのリッチなマルチメディア出力を行うための標準化された仕組みがあります。この仕組みは次の3つの要素から成ります。

  • Julia オブジェクト x を、プレーンテキストにフォールバックしつつ、利用可能な中で最もリッチな形式で表示するよう要求する関数 display(x)。
  • show をオーバーロードすると、ユーザー定義型について、標準 MIME タイプをキーとする任意のマルチメディア表現を指定できます。
  • マルチメディア対応の表示バックエンドは、汎用の AbstractDisplay 型をサブクラス化して登録し、pushdisplay を使って表示バックエンドのスタックに追加できます。

Julia の基本ランタイムが提供するのはプレーンテキスト表示のみですが、外部モジュールを読み込むか、グラフィカルな Julia 環境(IPython ベースの IJulia ノートブックなど)を使うことで、よりリッチな表示を利用できます。

Base.Multimedia.display — Function
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を表示する」という意味です。REPLのようなテキスト出力を確実にstdoutへ出力したい場合は、代わりに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タイプの「生」データを指定することもできます。

ある型のインスタンスの表示方法をカスタマイズするには、displayではなくshowをオーバーロードしてください。詳しくは、マニュアルのcustom pretty-printingの節を参照してください。

source
Base.Multimedia.redisplay — Function
redisplay(x)
redisplay(d::AbstractDisplay, x)
redisplay(mime, x)
redisplay(d::AbstractDisplay, mime, x)

デフォルトでは、redisplay 関数は単に display を呼び出します。ただし、一部の表示バックエンドでは、redisplay をオーバーライドして、既存の x の表示(存在する場合)を変更することがあります。また、redisplay を使うと、x が何度も再表示される可能性があることをバックエンドに示せます。そのため、バックエンドは(たとえば)次の対話プロンプトが表示されるまで、表示を保留することがあります。

source
Base.Multimedia.displayable — Function
displayable(mime)::Bool
displayable(d::AbstractDisplay, mime)::Bool

指定されたmime型(文字列)が、現在のディスプレイスタック内のいずれかのディスプレイで表示可能かどうかを示すブール値を返します。2つ目の形式では、dディスプレイで表示可能かどうかを示します。

source
Base.show — Method
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 など)で画像を表示できるようになります。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) を使用します。

Examples

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

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

source
Base.Multimedia.showable — Function
showable(mime, x)

オブジェクト x を、指定された型 mime として書き出せるかどうかを示すブール値を返します。

(デフォルトでは、typeof(x) に対応する show メソッドが存在するかどうかによって自動的に判定されます。一部の型では、独自の showable メソッドが用意されています。たとえば、利用可能な MIME 形式が x の 値 に依存する場合です。)

Examples

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

julia> showable("image/png", rand(5))
false
source
Base.repr — Method
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) 関数は、指定された mime 型を Julia がテキストとして扱うかどうかを返します。)

省略可能なキーワード引数 context には、:key=>value ペア、または IO や IOContext オブジェクトを指定できます。これらの属性は、show に渡される I/O ストリームに使用されます。

特例として、x が(テキスト MIME 型の場合)AbstractString、または(バイナリ MIME 型の場合)Vector{UInt8} であれば、repr 関数は x が要求された mime 形式で既に表現されているとみなし、そのまま x を返します。この特例は "text/plain" MIME 型には適用されません。これは、生データを display(m::MIME, x) に渡す場合に便利です。

特に、repr("text/plain", x) は通常、人が読みやすいように整形された x です。Julia で x の値を入力する際の表記により近い文字列を返すには、repr(x) も参照してください。これは、show(x) に対応する文字列を返します。

Examples

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

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

標準的なインターネットデータ形式を表す型です。「MIME」は「Multipurpose Internet Mail Extensions」の略で、この標準はもともと、メールメッセージに添付するマルチメディアファイルを記述するために使われていました。

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

Examples

julia> show(stdout, MIME("text/plain"), "hi")
"hi"
source
Base.Multimedia.@MIME_str — Macro
@MIME_str

MIME型の書き込みに使う便利なマクロです。通常はshowにメソッドを追加する際に使用します。たとえば、show(io::IO, ::MIME"text/html", x::MyType) = ...という構文を使って、MyTypeのHTML表現を書き出す方法を定義できます。

source

前述のとおり、新しい表示バックエンドを定義することもできます。たとえば、PNG 画像をウィンドウに表示できるモジュールは、その機能を Julia に登録できます。これにより、PNG 表現を持つ型に対して display(x) を呼び出すと、そのモジュールのウィンドウに画像が自動的に表示されます。

新しい表示バックエンドを定義するには、まず抽象クラス AbstractDisplay のサブタイプ D を作成します。次に、D 上で表示できる各 MIME タイプ(文字列 mime)について、その MIME タイプとして x を表示する関数 display(d::D, ::MIME"mime", x) = ... を定義します。通常は show(io, mime, x) または repr(io, mime, x) を呼び出します。x をその MIME タイプとして表示できない場合は、MethodError をスローする必要があります。show または repr を呼び出せば、これは自動的に行われます。

最後に、D がサポートする mime 型を showable(mime, x) に問い合わせ、その中から「最適な」ものを表示する関数 display(d::D, x) を定義します。x に対応する MIME タイプが見つからない場合は、MethodError をスローする必要があります。同様に、一部のサブタイプでは redisplay(d::D, ...) をオーバーライドすることもできます。(繰り返しますが、display に新しいメソッドを追加するには、import Base.display する必要があります。)これらの関数の戻り値は実装に委ねられます(場合によっては、何らかの表示「ハンドル」を返すと便利なためです)。D の表示関数は直接呼び出すこともできますが、次のように新しい表示を表示バックエンドのスタックに追加すれば、display(x) から自動的に呼び出すこともできます。

Base.Multimedia.pushdisplay — Function
pushdisplay(d::AbstractDisplay)

新しいディスプレイ d を、グローバルなディスプレイバックエンドスタックの最上位に追加します。display(x) または display(mime, x) を呼び出すと、スタック内で最上位にある互換性のあるバックエンド(つまり、MethodError をスローしない最上位のバックエンド)に x が表示されます。

source
Base.Multimedia.popdisplay — Function
popdisplay()
popdisplay(d::AbstractDisplay)

ディスプレイバックエンドのスタックから最上位のバックエンドを取り出します。2つ目の形式では、d の最上位のコピーを取り出します。

source
Base.Multimedia.TextDisplay — Type
TextDisplay(io::IO)

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

source
Base.Multimedia.istextmime — Function
istextmime(m::MIME)

MIMEタイプがテキストデータかどうかを判定します。MIMEタイプは、テキストデータ(Unicodeの場合もあります)として知られている一部のタイプを除き、バイナリデータであるとみなされます。

Examples

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

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

Network I/O

Base.bytesavailable — Function
bytesavailable(io)

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

Examples

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

julia> bytesavailable(io)
34
source
Base.ntoh — Function
ntoh(x)

値のエンディアンを、ネットワークバイトオーダー(ビッグエンディアン)からホストのバイトオーダーに変換します。

source
Base.hton — Function
hton(x)

値のエンディアンを、ホストのバイトオーダーからネットワークバイトオーダー(ビッグエンディアン)に変換します。

source
Base.ltoh — Function
ltoh(x)

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

source
Base.htol — Function
htol(x)

値のエンディアンを、ホストのエンディアンからリトルエンディアンに変換します。

source
Base.ENDIAN_BOM — Constant
ENDIAN_BOM

32ビットのバイトオーダーマークは、ホストマシンのネイティブなバイト順を示します。リトルエンディアンのマシンでは値 0x04030201 が格納されます。ビッグエンディアンのマシンでは値 0x01020304 が格納されます。

source