I/O и сеть

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)

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

Примеры

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)

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

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

Тип по умолчанию — 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)

Возвращает строку или байтовый массив, содержащий представление 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 является строкой (для текстовых MIME-типов) или байтовым массивом (для бинарных 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" расшифровывается как "Multipurpose Internet Mail Extensions", так как стандарт изначально использовался для описания приложений мультимедиа к электронным письмам.

Объект типа 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

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.