I/O и сеть

stdout

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

stderr

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

stdin

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

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

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

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

IOStream

Буферизованный поток IO, обертывающий дескриптор файла ОС. В основном используется для представления файлов, возвращаемых функцией 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.

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

Объединение вызовов write:

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)

Добавить метку в текущей позиции потока s. Вернуть помеченную позицию.

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

unmark(s)

Удалить метку из потока s. Вернуть true, если поток был помечен, false в противном случае.

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

reset(s)

Сбросить поток s до ранее помеченной позиции и удалить метку. Вернуть ранее помеченную позицию. Выбросить ошибку, если поток не помечен.

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

ismarked(s)

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

Вернуть true, если указанный объект 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

Вернуть true, если указанный объект 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_stdout([stream]) -> (rd, wr)

Создать канал, в который будет перенаправлен весь вывод уровня C и Julia stdout. Возвращает кортеж (rd, wr), представляющий концы канала. Данные, записанные в stdout, теперь могут быть прочитаны с конца rd канала. Конец wr возвращается для удобства, если старый объект stdout был кэширован пользователем и должен быть заменён в другом месте.

Если вызывается с необязательным аргументом stream, возвращает stream сам.

redirect_stdout(f::Function, stream)

Выполнить функцию f с перенаправлением stdout на stream. После завершения stdout восстанавливается к предыдущему значению.

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

Как redirect_stdout, но для stderr.

redirect_stderr(f::Function, stream)

Выполнить функцию f с перенаправлением stderr на stream. После завершения stderr восстанавливается к предыдущему значению.

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

Как redirect_stdout, но для stdin. Обратите внимание, что порядок возвращаемого кортежа всё ещё (rd, wr), т.е. данные, подлежащие чтению из stdin, могут быть записаны в wr.

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.

Примеры

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> countlines(io, eol = '.')
0

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 у 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 отображает строки без кавычек.

string возвращает вывод print в виде строки.

Примеры

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 не указан, выводит в stdout.

Примеры

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, 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_yellow, :magenta, :nothing, :red, :reverse, :underline, :white, или :yellow, или целое число от 0 до 255 включительно. Обратите внимание, что не все терминалы поддерживают 256 цветов. Если ключевое слово bold задано как true, результат будет выведен полужирным шрифтом.

sprint(f::Function, args...; context=nothing, sizehint=0)

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

Необязательный ключевой аргумент context может быть установлен в :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::AbstractString
       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> 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")

readuntil(stream::IO, delim; keep::Bool = false)
readuntil(filename::AbstractString, delim; keep::Bool = false)

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

Примеры

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 из памяти.

Примеры

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) в качестве вывода функции show с 2 аргументами.

Типы контейнеров, как правило, реализуют show с 3 аргументами, вызывая 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("img/png", rand(5))
false

repr(mime, x; context=nothing)

Возвращает AbstractString или Vector{UInt8}, содержащие представление x в запрошенном формате mime , записанном в show(io, mime, x) (выбрасывает MethodError, если соответствующий метод show недоступен). Для типов MIME с текстовыми представлениями (например, "text/html" или "application/postscript") возвращается AbstractString, а двоичные данные возвращаются как Vector{UInt8}. (Функция istextmime(mime) возвращает, рассматривает ли Julia данный тип mime как текст.)

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

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

В частности, repr("text/plain", x) — это, как правило, "красиво отформатированная" версия x, предназначенная для человеческого потребления. См. также repr(x), чтобы вместо этого вернуть строку, соответствующую show(x), которая может быть ближе к тому, как значение x было бы введено в Julia.

Примеры

julia> A = [1 2; 3 4];

julia> repr("text/plain", A)
"2×2 Matrix{Int64}:\n 1  2\n 3  4"

MIME

Тип, представляющий стандартный формат данных Интернет. "MIME" означает "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 (по умолчанию), записывая текстовое представление в указанный поток ввода/вывода. (Так объекты выводятся в REPL Julia.)

istextmime(m::MIME)

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

Примеры

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

julia> istextmime(MIME("img/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.