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

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

julia> rm("myfile.txt")

ソースコード

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

五つのキーワード引数で指定されるモードでファイルを開きます:

キーワード引数	説明	デフォルト値
`read`	読み込みのために開く	`!write`
`write`	書き込みのために開く	`truncate \| append`
`create`	ファイルが存在しなければ作成する	`!read & write \| truncate \| append`
`truncate`	サイズをゼロに切り捨てる	`!read & write`
`append`	末尾にシークする	`false`

キーワード引数が一つも指定されないときのデフォルトは読み込み専用でファイルを開く処理です。開かれたファイルにアクセスするためのストリームを返します。

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

Julia 1.5

キーワード引数 lock は Julia 1.5 以降でサポートされます。

ソースコード

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

五つの真偽値ではなく文字列でオプションを指定するバージョンの open です。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 は安全なマルチスレッドアクセスのためにファイル操作をロックするかどうかを制御します。

例

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 以降でサポートされます。

ソースコード

open(fd::OS_HANDLE) -> IO

生のファイル記述子を受け取り、それを Julia が認識できる IO 型にラップしたものを返します。そのときハンドル fd の所有権は Julia に移ります。元のハンドルの所有権を手放したくない場合には open(Libc.dup(fd)) を使ってください。

警告

システムの他の部分が所有しているハンドルに対してこのメソッドを呼び出してはいけません。

ソースコード

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`

ソースコード

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

command の実行を非同期に開始し、process::IO オブジェクトを返します。read が true なら新しいプロセスの標準出力に書き込まれたデータを process オブジェクトから読み込めるようになり、省略可能引数 stdio は新しいプロセスの標準入力ストリームとなります。write が true なら process オブジェクトを通して新しいプロセスの標準入力に書き込めるようになり、省略可能引数 stdio は新しいプロセスの標準出力ストリームとなります。プロセスの標準エラーストリームは現在のグローバル変数 stderr に接続されます。

ソースコード

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

open(command, args...; kwargs...) と同じ処理を行い、返り値のストリームに対して f を適用し、関数が返ったら入力ストリームを閉じてプロセスの完了を待ちます。f が返す値を返します。

ソースコード

`Base.IOStream` ── 型

IOStream

OS のファイル記述子をラップするバッファされた IO ストリームです。主に open が返すファイルの表現として使われます。

ソースコード

`Base.IOBuffer` ── 型

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

インメモリの IO ストリームを作成します。既存の配列を使うこともできます。

省略可能なキーワード引数は次の通りです:

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)

指定された文字列 string から読み込み専用の IOBuffer を作成します。

例

julia> io = IOBuffer("Haho");

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

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

ソースコード

`Base.take!` ── メソッド

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."

ソースコード

`Base.fdio` ── 関数

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

整数のファイル記述子から IOStream オブジェクトを作成します。own が true なら、返り値のオブジェクトを閉じたときに内部のファイル記述子も閉じられます。デフォルトで IOStream はガベージコレクトされるときに閉じられます。name を使うとファイル記述子 fd に名前の付いたファイルを関連付けることができます。

ソースコード

`Base.flush` ── 関数

flush(stream)

与えられたストリームが現在バッファしている書き込みを全てコミットさせます。

ソースコード

`Base.close` ── 関数

close(stream)

IO ストリームを閉じます。閉じる前に flush が行われます。

ソースコード

`Base.write` ── 関数

write(io::IO, x)
write(filename::AbstractString, x)

値の正準バイナリ表現を指定された IO ストリームもしくはファイルに書き込みます。ストリームに書き込まれたデータのバイト数を返します。テキスト表現を書き込む場合は print を使ってください (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))

ソースコード

`Base.read` ── 関数

read(io::IO, T)

型 T の値を io から一つ読みます。値は正準バイナリ表現として読み込まれます。

Julia はエンディアンの変換を行わないことに注意してください。エンディアンの変換には ntoh または ltoh が利用できます。

read(io::IO, String)

io からデータを全て読み、String として返します。

例

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, args...)

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

read(filename::AbstractString, String)

ファイルのデータを全て読み、文字列として返します。

ソースコード

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

s から最大で nb バイトを読み、結果を読んだバイト数と等しい長さの Vector{UInt8} として返します。

ソースコード

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

s から最大で nb バイトを読み、結果を読んだバイト数と等しい長さの Vector{UInt8} として返します。

all が true (デフォルト値) だと、この関数は要求されたバイト数を読むまで (もしくはエラーまたは EOF が発生するまで) 何度も読み込みを行い、その間ブロックします。all が false なら read は一度だけ呼ばれ、返るデータの量はデバイス依存となります。なお全てのストリーム型が all オプションをサポートするわけではありません。

ソースコード

read(command::Cmd)

command を実行し、出力をバイト列として返します。

ソースコード

read(command::Cmd, String)

command を実行し、出力を String として返します。

ソースコード

`Base.read!` ── 関数

read!(stream::IO, array::AbstractArray)
read!(filename::AbstractString, array::AbstractArray)

IO ストリームあるいはファイルからバイナリデータを読み、array に保存します。

ソースコード

`Base.readbytes!` ── 関数

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)

ソースコード

`Base.unsafe_read` ── 関数

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

ストリームオブジェクト IO から ref (をポインタに変換した場所) へ nbytes バイトのデータをコピーします。

部分型 T <: IO では unsafe_read(s::T, p::Ptr{UInt8}, n::UInt) というシグネチャを持つメソッドをオーバーライドして高速な実装を提供することが推奨されます。

ソースコード

`Base.unsafe_write` ── 関数

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

ref (をポインタに変換した場所) からストリームオブジェクト IO へ nbytes バイトのデータをコピーします。

部分型 T <: IO では unsafe_write(s::T, p::Ptr{UInt8}, n::UInt) というシグネチャを持つメソッドをオーバーライドして高速な実装を提供することが推奨されます。

ソースコード

`Base.peek` ── 関数

peek(stream[, T=UInt8])

ストリームから T 型の値を一つ読んで返します。ただしそのときストリームの現在位置を動かしません。

例

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

peek の引数 T は Julia 1.5 以降でサポートされます。

ソースコード

`Base.position` ── 関数

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

ソースコード

`Base.seek` ── 関数

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)

ソースコード

`Base.seekstart` ── 関数

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)

ソースコード

`Base.seekend` ── 関数

seekend(s)

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

ソースコード

`Base.skip` ── 関数

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)

ソースコード

`Base.mark` ── 関数

mark(s)

ストリーム s の現在位置に印を付けます。印を付けた位置が返ります。

unmark, reset, ismarked も参照してください。

ソースコード

`Base.unmark` ── 関数

unmark(s)

ストリーム s から印を取り除きます。ストリームに印があったなら true を返し、そうでなければ false を返します。

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

ソースコード

`Base.reset` ── 関数

reset(s)

ストリーム s の現在位置を最後に印を付けた位置に戻し、その印を取り除きます。最後に付けた印の位置 (新しい現在位置) を返します。

mark, unmark, ismarked も参照してください。

ソースコード

`Base.ismarked` ── 関数

ismarked(s)

ストリーム s に印が付いているなら true を返します。

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

ソースコード

`Base.eof` ── 関数

eof(stream) -> Bool

IO ストリームがファイル終端 (EOF) を指すかどうかを判定します。ストリームを使い切っていないなら、データが利用可能になるのを必要なら待った上で false を返します。そのため、eof が false 返したときはストリームから一バイトを安全に読み込むことができます。stream の内部バッファにデータが残っている限り、たとえその時点で接続のリモート終端が閉じられていたとしても、eof は false を返します。

ソースコード

`Base.isreadonly` ── 関数

isreadonly(io) -> Bool

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

例

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

ソースコード

`Base.iswritable` ── 関数

iswritable(io) -> Bool

IO オブジェクトが書き込み可能 (であることが判定できる) なら true を返します。

例

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

ソースコード

`Base.isreadable` ── 関数

isreadable(io) -> Bool

IO オブジェクトが読み込み可能 (であることが判定できる) なら true を返します。

例

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

ソースコード

`Base.isopen` ── 関数

isopen(object) -> Bool

ストリームやタイマーのようなオブジェクトが閉じられていないかどうかを判定します。一度閉じられたオブジェクトは二度と新しいイベントを生成しません。ただし閉じられたストリームのバッファに読み込めるデータが残っている可能性があるので、データが読み込めるかどうかの判定には eof を使うべきです。ストリームが書き込みあるいは読み込み可能になった (可能性がある) ときに通知を受け取るには FileWatching パッケージを使ってください。

例

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

ソースコード

`Base.fd` ── 関数

fd(stream)

ストリームあるいはファイルのファイル記述子を返します。この関数は同期的な File および IOStream にだけ適用でき、非同期的なストリームには適用できないことに注意してください。

ソースコード

`Base.redirect_stdout` ── 関数

redirect_stdout([stream]) -> (rd, wr)

パイプを作成し、C および Julia レベルで行われる stdout への出力が全てそこにリダイレクトされるようにします。返り値はパイプの両端を示すタプル (rd, wr) です。stdout へ書き込んだデータは rd から読み込めるようになります。wr は古い stdout オブジェクトが別の場所でキャッシュされていて更新が必要な場合に利用します。

省略可能引数 stream を渡して呼び出すと、stream を返します。

情報