Ввод/вывод и сеть

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

Открывает файл в режиме, заданном пятью булевыми ключевыми аргументами:

По умолчанию, если не указаны ключевые аргументы, файлы открываются только для чтения. Возвращает поток для доступа к открытому файлу.

Ключевой аргумент 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

Возьмите сырой дескриптор файла, оберните его в тип IO, знакомый Julia, и примите на себя управление дескриптором 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

Буферизованный поток ввода/вывода, обертывающий дескриптор файла ОС. В основном используется для представления файлов, возвращаемых open.

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

Создаёт поток ввода/вывода в памяти, который может по желанию работать с предварительно существующим массивом.

Он может принимать необязательные ключевые аргументы:

• 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 без инициализации, особенно для обмена данными ввода-вывода между несколькими процессами.

Соответствующий конец трубы будет автоматически инициализирован, если объект используется при запуске процесса. Это может быть полезно для лёгкого получения ссылок в цепочках процессов, например:

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

link_pipe!(pipe; reader_supports_async=false, writer_supports_async=false)

Инициализировать pipe и связать конец in с концом out. Ключевые аргументы reader_supports_async/writer_supports_async соответствуют OVERLAPPED в Windows и O_NONBLOCK в системах POSIX. Они должны быть true за исключением случаев, когда они будут использоваться внешней программой (например, выводом команды, выполненной с помощью run).

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

Создать объект IOStream из целочисленного дескриптора файла. Если own равно true, закрытие этого объекта закроет подлежащий дескриптор. По умолчанию объект IOStream закрывается при сборке мусора. name позволяет связать дескриптор с именованным файлом.

flush(stream)

Зафиксировать все буферизованные операции записи в данный поток.

close(stream)

Закрыть поток ввода-вывода. Сначала выполняется flush.

closewrite(stream)

Завершить запись в полнодуплексный поток ввода-вывода. Сначала выполняется flush. Сообщается другому концу, что больше данных не будет записано в подлежащий файл. Эта функция не поддерживается всеми типами потоков.

Если реализовано, closewrite вызывает последующие read или eof вызовы, которые блокировались, для того чтобы вместо этого генерировать EOF или возвращать true соответственно. Если поток уже закрыт, это действие идемпотентно.

Примеры

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)

Записать каноническое двоичное представление значения в заданный поток ввода-вывода или файл. Вернуть количество записанных байтов в поток. См. также 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)

Прочитать одно значение типа T из io, в каноническом двоичном представлении.

Обратите внимание, что 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))

Прочитать не более nb байтов из s, вернув массив прочитанных байтов.

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

Прочитать не более nb байтов из s, вернув массив прочитанных байтов.

Если 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)

Прочитать двоичные данные из потока ввода-вывода или файла, заполнив array.

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

Прочитать не более nb байтов из stream в b, вернув количество прочитанных байтов. Размер b увеличится при необходимости (т.е. если nb больше length(b) и достаточно байтов прочитано), но никогда не уменьшится.

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

Прочитать не более nb байтов из stream в 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)

Возвращает true если поток s помечен.

См. также mark, unmark, reset.

eof(stream) -> Bool

Проверяет, находится ли поток ввода-вывода в конце файла. Если поток еще не исчерпан, эта функция будет блокироваться, ожидая дополнительных данных при необходимости, и затем возвращать 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(path::String)

Возвращает true если разрешения доступа для данного path разрешают запись текущим пользователем.

См. также ispath, isexecutable, isreadable.

iswritable(io) -> Bool

Возвращает false если указанный объект IO не является записываемым.

Примеры

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)

Возвращает true если разрешения доступа для данного path разрешают чтение текущим пользователем.

См. также ispath, isexecutable, iswritable.

isreadable(io) -> Bool

Возвращает false если указанный объект IO не является читаемым.

Примеры

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)

Возвращает true, если заданный path имеет разрешения на выполнение.

См. также 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

Однако передача двух разных дескрипторов одного и того же файла не поддерживается.

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 до конца потока/файла и посчитайте количество строк. Для указания файла передайте имя файла в качестве первого аргумента. Маркеры 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) # 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::AbstractVector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))

An IOBuffer позволяющий чтение и выполнение записей путём добавления. Поиск и обрезка не поддерживаются. См. IOBuffer для доступных конструкторов. Если data задано, создаёт PipeBuffer для работы с вектором данных, необязательно указав размер, за пределами которого базовый Array может не увеличиваться.

readavailable(stream)

Считывает доступные буферизованные данные из потока. Фактическое чтение ввода-вывода выполняется только если данные ещё не буферизованы. Результат — Vector{UInt8}.

IOContext

IOContext предоставляет механизм для передачи параметров конфигурации вывода между методами show.

Короче говоря, это неизменяемый словарь, который является подклассом IO. Он поддерживает стандартные операции со словарями, такие как getindex, и также может использоваться как поток ввода-вывода.

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 цветовые коды/escape-последовательности. По умолчанию это определяется тем, является ли io совместимым терминалом, и любой --color флагом командной строки при запуске julia.

Примеры

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). Проверка ключа :compact IOContext (часто проверяемого как get(io, :compact, false)::Bool) io в таких методах рекомендуется, поскольку некоторые контейнеры отображают свои элементы, вызывая этот метод с :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)

Вызовите заданную функцию с потоком ввода/вывода и предоставленными дополнительными аргументами. Всё, что было записано в этот поток ввода/вывода, возвращается в виде строки. context может быть IOContext, чьи свойства будут использованы, Pair, задающий свойство и его значение, или кортеж из Pair, задающих несколько свойств и их значений. sizehint предполагает ёмкость буфера (в байтах).

Необязательный ключевой аргумент context может быть установлен в пару :key=>value, кортеж из :key=>value пар или объект IO или IOContext, чьи атрибуты используются для потока ввода/вывода, переданного в f. Необязательный 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)

Прочитать одну строку текста из указанного потока ввода/вывода или файла (по умолчанию 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)

Прочитать строку из потока ввода/вывода stream или файла до указанного разделителя. Разделитель может быть UInt8, AbstractChar, строкой или вектором. Ключевой аргумент keep управляет тем, включен ли разделитель в результат. Текст предполагается закодированным в UTF-8.

Возвращает String если delim является AbstractChar или строкой, в противном случае возвращает Vector{typeof(delim)}. Также см. copyuntil для записи непосредственно в другой поток (который может быть предварительно выделенному IOBuffer).

Примеры

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)

Прочитать все строки из потока ввода/вывода или файла как вектор строк. Поведение эквивалентно сохранению результата чтения 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 объект, который будет возвращать каждую строку из потока ввода/вывода или файла. Итерация вызывает readline на аргументе потока многократно с прошедшими keep, определяя, сохраняются ли символы конца строки. При вызове с именем файла файл открывается один раз в начале итерации и закрывается в конце. Если итерация прервана, файл будет закрыт, когда объект EachLine будет удалён сборщиком мусора.

Чтобы перебрать каждую строку String, можно использовать eachline(IOBuffer(str)).

Iterators.reverse можно использовать с объектом EachLine для чтения строк в обратном порядке (для файлов, буферов и других потоков ввода/вывода, поддерживающих seek), и 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)

Скопировать одну строку текста из потока ввода/вывода stream или файла в поток out ввода/вывода, вернув out.

При чтении из файла предполагается, что текст закодирован в UTF-8. Строки ввода заканчиваются '\n' или "\r\n" или концом потока ввода. Когда keep равно false (как по умолчанию), эти символы конца строки удаляются из строки перед возвратом. Когда keep равно true, они возвращаются как часть строки.

Аналогично readline, который возвращает String; в отличие от этого, copyline пишет непосредственно в out, без выделения строки. (Это можно использовать, например, для чтения данных в предварительно выделенном IOBuffer.)

См. также copyuntil для чтения до более общих разделителей.

Примеры

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)

Скопировать строку из потока ввода-вывода stream или файла до заданного разделителя в поток out, возвращая out. Разделитель может быть символом, AbstractChar, строкой или вектором. Ключевое слово keep управляет тем, включается ли разделитель в результат. Текст предполагается закодированным в UTF-8.

Аналогично readuntil, которое возвращает String; в отличие от этого, 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)

Чтобы получить размер вашего терминала,

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) пытается отобразить x на данном дисплее d только, выбрасывая MethodError, если d не может отображать объекты этого типа.

В общем случае нельзя предполагать, что вывод display идёт в stdout (в отличие от print(x) или show(x)). Например, display(x) может открыть отдельное окно с изображением. display(x) означает "отобразить x наилучшим образом для текущего устройства вывода". Если вам нужен вывод текста в стиле REPL, гарантированно направленный в stdout, используйте show(stdout, "text/plain", x) вместо этого.

Также существуют два варианта с аргументом mime (строка типа MIME, например, "image/png"), которые пытаются отобразить x только с использованием запрошенного типа MIME, выбрасывая MethodError, если этот тип не поддерживается ни дисплеем(ами), ни x. В этих вариантах можно также предоставить "сырые" данные в запрошенном типе MIME, передав x::AbstractString (для MIME-типов с текстовым хранением, таких как text/html или application/postscript) или x::Vector{UInt8} (для двоичных 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

Возвращает логическое значение, указывающее, может ли данный тип mime (строка) отображаться любым из дисплеев в текущем стеке отображения или конкретно дисплеем d во втором варианте.

show(io::IO, mime, x)

Функции display в конечном счёте вызывают show для записи объекта x как заданного типа mime в заданный поток ввода-вывода io (обычно буфер памяти), если это возможно. Для предоставления богатого мультимедийного представления пользовательского типа T, достаточно определить новый метод show для T, с помощью: 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 который вызывает show с двумя аргументами, поэтому всегда необязательно добавлять метод для этого случая. Если тип извлекает выгоду из пользовательского удобочитаемого вывода, show(::IO, ::MIME"text/plain", ::T) должен быть определён. Например, тип Day использует 1 day в качестве вывода для типа MIME text/plain, и 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

Типы контейнеров обычно реализуют 3-аргументную функцию show вызывая show(io, MIME"text/plain"(), x) для элементов 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) (выбрасывая MethodError, если нет подходящего show). Для MIME-типов с текстовыми представлениями (таких как "text/html" или "application/postscript") возвращается AbstractString, а двоичные данные возвращаются как Vector{UInt8}. (Функция istextmime(mime) возвращает, рассматривает ли Julia данный тип mime как текст.)

Необязательный ключевой аргумент context может быть установлен в :key=>value пару или IO или объект IOContext, атрибуты которого используются для потока ввода/вывода, переданного в show.

В качестве специального случая, если x является AbstractString (для текстовых MIME-типов) или Vector{UInt8} (для двоичных MIME-типов), функция repr предполагает, что x уже в запрошенном формате mime и просто возвращает x. Этот специальный случай не относится к MIME-типу "text/plain". Это полезно для передачи необработанных данных в display(m::MIME, x).

В частности, repr("text/plain", x) обычно является "красиво отформатированной" версией x, предназначенной для восприятия человеком. Также см. repr(x) для возврата строки, соответствующей show(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" расшифровывается как "Многоцелевые расширения электронной почты интернета", поскольку стандарт изначально использовался для описания мультимедийных вложений в сообщения электронной почты.

Объект MIME может быть передан как второй аргумент к show для запроса вывода в этом формате.

Примеры

julia> show(stdout, MIME("text/plain"), "hi")
"hi"

@MIME_str

Удобный макрос для записи типов MIME, обычно используемый при добавлении методов к show. Например, синтаксис show(io::IO, ::MIME"text/html", x::MyType) = ... можно использовать для определения способа записи HTML-представления MyType.

pushdisplay(d::AbstractDisplay)

Добавляет новое отображение d в глобальный стек бэкэндов отображения. Вызов display(x) или display(mime, x) отобразит x на совместимом бэкэнде наверху стека (т.е., на бэкэнде, который не генерирует исключение MethodError).

popdisplay()
popdisplay(d::AbstractDisplay)

Извлекает верхний бэкэнд из стека бэкэндов отображения или верхнюю копию d во втором варианте.

TextDisplay(io::IO)

Возвращает TextDisplay <: AbstractDisplay, который отображает любой объект как MIME-тип text/plain (по умолчанию), записывая текстовое представление в заданный поток ввода/вывода. (Это то, как объекты печатаются в REPL Julia.)

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)

Преобразует порядок байтов значения из сетевого порядка байтов (big-endian) в порядок, используемый хостом.

hton(x)

Преобразует порядок байтов значения из порядка, используемого хостом, в сетевой порядок байтов (big-endian).

ltoh(x)

Преобразует порядок байтов значения из little-endian в порядок, используемый хостом.

htol(x)

Преобразует порядок байтов значения из порядка, используемого хостом, в little-endian.

ENDIAN_BOM

32-битный маркер порядка байтов указывает на порядок байтов на целевой машине. Машины little-endian содержат значение 0x04030201. Машины big-endian содержат значение 0x01020304.