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

stdout::IO

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

stderr::IO

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

stdin::IO

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

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

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

Примеры

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

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

A IOBuffer that allows reading and performs writes by appending. Seeking and truncating are not supported. See IOBuffer for the available constructors. If data is given, creates a PipeBuffer to operate on a data vector, optionally specifying a size beyond which the underlying Array may not be grown.

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: A Tuple{Int,Int} определяющий размер в строках и столбцах для использования в текстовом выводе. Это можно использовать для переопределения размера отображения для вызываемых функций, но для получения размера экрана используйте функцию displaysize.
• :typeinfo: A 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 (часто проверяется как 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, 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 ложно (по умолчанию), эти символы новой строки удаляются из строки перед возвратом. Когда keep истинно, они возвращаются как часть строки.

Примеры

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)

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

Примеры

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

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-совместимом AbstractDisplay (например, 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.

Примеры

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 недоступен). Возвращается AbstractString для 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 (по умолчанию), записывая текстовое представление в указанный поток ввода-вывода. (Вот как объекты выводятся в интерактивной оболочке Julia.)

istextmime(m::MIME)

Определяет, является ли MIME-тип текстовыми данными. MIME-типы по умолчанию считаются двоичными данными, за исключением набора типов, известных как текстовые данные (возможно, Unicode).

Примеры

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

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

Возвращает количество байтов, доступных для чтения, прежде чем чтение из этого потока или буфера заблокируется.

Примеры

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.