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

stdout::IO

Глобальная переменная, ссылающаяся на стандартный поток вывода.

stderr::IO

Глобальная переменная, ссылающаяся на стандартный поток ошибок.

stdin::IO

Глобальная переменная, ссылающаяся на стандартный поток ввода.

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

Применяет функцию f к результату open(args...; kwargs...) и закрывает получившийся дескриптор файла по завершении.

Примеры

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

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

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

Ключевой аргумент 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 истинно, то чтение из процесса происходит из стандартного вывода процесса, а stdio необязательно указывает поток стандартного ввода процесса. Если write истинно, то запись идёт в стандартный ввод процесса, а stdio необязательно указывает поток стандартного вывода процесса. Поток стандартных ошибок процесса подключён к текущему глобальному потоку stderr.

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

Аналогично open(command, args...; kwargs...), но вызывает f(stream) на результирующем потоке процесса, затем закрывает поток ввода и ждёт завершения процесса. Возвращает значение, возвращённое f при успехе. Выбрасывает ошибку, если процесс завершился неудачно или процесс пытается вывести что-либо в стандартный вывод.

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

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

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

flush(stream)

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

close(stream)

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

closewrite(stream)

Завершить запись в поток двунаправленного ввода-вывода. Сначала выполняется flush. Уведомляет другую сторону, что больше данных записываться не будет.

Примеры

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)
write(filename::AbstractString, 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, args...)

Открыть файл и прочитать его содержимое. args передается в read: это эквивалентно open(io->read(io, args...), filename).

read(filename::AbstractString, String)

Прочитать всё содержимое файла как строку.

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

Прочитать не более nb байт из s, возвращая Vector{UInt8} прочитанных байтов.

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

Прочитать не более nb байт из s, возвращая Vector{UInt8} прочитанных байтов.

Если all равно true (по умолчанию), эта функция будет блокироваться, повторяя попытки чтения всех запрошенных байтов, пока не произойдет ошибка или конец файла. Если all равно false, выполняется не более одного вызова read, и количество возвращаемых данных зависит от устройства. Обратите внимание, что не все типы потоков поддерживают опцию all.

read(command::Cmd)

Выполнить command и вернуть результирующий вывод в виде массива байтов.

read(command::Cmd, String)

Выполнить command и вернуть результирующий вывод как String.

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

Прочитать двоичные данные из потока ввода-вывода или файла, заполнив 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 из потока без изменения текущей позиции в потоке.

Примеры

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(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, пока буферизированные данные ещё доступны, даже если удалённый конец соединения закрыт.

isreadonly(io) -> Bool

Определить, является ли поток только для чтения.

Примеры

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(io) -> Bool

Вернуть 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(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")

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 suppored

Также аргумент 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> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end;

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

Прочитать 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

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

Буфер 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-цвета/экранирующие коды. По умолчанию это определяется тем, является ли 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 потока 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, underline::Bool=false, blink::Bool=false, reverse::Bool=false, hidden::Bool=false, color::Union{Symbol,Int}=:normal)

Вывести xs в указанный цвет (в виде символа или целого числа), необязательно полужирным шрифтом.

Ключевое слово color может принимать любые значения :normal, :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, 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, они возвращаются как часть строки.

Примеры

julia> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end
57

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)

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

Примеры

julia> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end
57

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> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\nIt has many members.\n");
       end
57

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> open("my_file.txt", "w") do io
           write(io, "JuliaLang is a GitHub organization.\n It has many members.\n");
       end;

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

julia> rm("my_file.txt");

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

Возвращает номинальный размер экрана, который может быть использован для отображения вывода в этот IO объект. Если вход не указан, считываются переменные среды LINES и COLUMNS. Если они не заданы, возвращается размер по умолчанию (24, 80).

Примеры

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

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

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

Абстрактный супертип для устройств вывода богатого отображения. TextDisplay является подтипом этого.

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

Отображение x используя самое верхнее применимое отображение в стеке отображений, обычно с использованием наиболее богатого поддерживаемого мультимедийного вывода для x, с простым текстовым выводом в stdout в качестве резервного варианта. Вариант display(d, x) пытается отобразить 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 (таком как IJulia). Как обычно, убедитесь, что вы import Base.show для добавления новых методов к встроенной функции Julia show.

Технически, макрос MIME"mime" определяет тип-синглетон для заданной строки mime, что позволяет нам использовать механизмы диспетчеризации Julia для определения того, как отобразить объекты заданного типа.

По умолчанию тип MIME - MIME"text/plain". Существует резервный метод для вывода text/plain, который вызывает show с 2 аргументами, поэтому не всегда необходимо добавлять метод для этого случая. Если тип выигрывает от настраиваемого вывода человекочитаемого формата, то show(::IO, ::MIME"text/plain", ::T) следует определить. Например, тип Day использует 1 day в качестве вывода для типа MIME text/plain, и Day(1) в качестве вывода для 2-аргументной функции show.

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