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

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

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

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

IOStream

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

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

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

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

• read, write, append: ограничивает операции буфером; см. open для подробностей.
• truncate: обнуляет размер буфера.
• maxsize: задаёт максимальный размер, до которого может увеличиться буфер.
• sizehint: указывает рекомендуемый объём буфера (data должен реализовывать sizehint!(data, size)).

Если data не задан, буфер будет по умолчанию и читаемым, и записываемым.

Примеры

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

julia> io = IOBuffer(b"JuliaLang is a GitHub organization.")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=35, maxsize=Inf, ptr=1, mark=-1)

julia> read(io, String)
"JuliaLang is a GitHub organization."

julia> write(io, "This isn't writable.")
ERROR: ArgumentError: ensureroom failed, IOBuffer is not writeable

julia> io = IOBuffer(UInt8[], read=true, write=true, maxsize=34)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=34, ptr=1, mark=-1)

julia> write(io, "JuliaLang is a GitHub organization.")
34

julia> String(take!(io))
"JuliaLang is a GitHub organization"

julia> length(read(IOBuffer(b"data", read=true, truncate=false)))
4

julia> length(read(IOBuffer(b"data", read=true, truncate=true)))
0

IOBuffer(string::String)

Создаёт только для чтения IOBuffer на данных, лежащих в основе данной строки.

Примеры

julia> io = IOBuffer("Haho");

julia> String(take!(io))
"Haho"

julia> String(take!(io))
"Haho"

take!(b::IOBuffer)

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

Примеры

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

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

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

flush(stream)

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

close(stream)

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

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.

Примеры

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)

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, который позволяет читать и выполнять записи путем добавления. Поиск и обрезка не поддерживаются. См. 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: A Tuple{Int,Int}, задающий размеры в строках и столбцах для использования в текстовом выводе. Это может использоваться для переопределения размера отображения вызываемых функций, но для получения размера экрана используйте функцию displaysize.
• :typeinfo: a Type, характеризующий информацию, уже напечатанную о типе объекта, который собираются отобразить. Это в основном полезно при отображении коллекции объектов одного типа, чтобы избежать избыточной информации о типе (например, [Float16(0)] может отображаться как "Float16[0.0]" вместо "Float16[Float16(0.0)]" : при отображении элементов массива свойство :typeinfo будет установлено в значение Float16).
• :color: Булево значение, указывающее, поддерживаются ли ANSI-цветные коды/символы escape. По умолчанию это определяется тем, является ли io совместимым терминалом, а также любым --color флагом командной строки при запуске julia.

Примеры

julia> io = IOBuffer();

julia> printstyled(IOContext(io, :color => true), "string", color=:red)

julia> String(take!(io))
"\e[31mstring\e[39m"

julia> printstyled(io, "string", color=:red)

julia> String(take!(io))
"string"

julia> print(IOContext(stdout, :compact => false), 1.12341234)
1.12341234
julia> print(IOContext(stdout, :compact => true), 1.12341234)
1.12341

julia> function f(io::IO)
           if get(io, :short, false)
               print(io, "short")
           else
               print(io, "loooooong")
           end
       end
f (generic function with 1 method)

julia> f(stdout)
loooooong
julia> f(IOContext(stdout, :short => true))
short

IOContext(io::IO, context::IOContext)

Создать IOContext, который обертывает альтернативный IO, но наследует свойства context.

show([io::IO = stdout], x)

Записать текстовое представление значения x в выходной поток io. Новые типы T должны перегрузить show(io::IO, x::T). Представление, используемое show , обычно включает информацию о форматировании и типе, специфичную для Julia, и должно быть парсируемым кодом Julia, когда это возможно.

repr возвращает результат show в виде строки.

Чтобы настроить удобочитаемый текстовый вывод для объектов типа T, определите show(io::IO, ::MIME"text/plain", ::T) вместо него. Проверка свойства :compact IOContext объекта 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 Array{Float64,1}"

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 Array{Int64,1} 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 равно false (как по умолчанию), эти символы новой строки удаляются из строки перед возвратом. Когда keep равно true, они возвращаются как часть строки.

Примеры

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

julia> readline("my_file.txt")
"JuliaLang is a GitHub organization."

julia> readline("my_file.txt", keep=true)
"JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt")

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 Array{String,1}:
 "JuliaLang is a GitHub organization."
 "It has many members."

julia> readlines("my_file.txt", keep=true)
2-element Array{String,1}:
 "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)

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

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

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

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

AbstractDisplay 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) = ... для отображения ваших изображений на любом 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.

Типы контейнеров обычно реализуют 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)

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

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

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

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

Примеры

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

julia> repr("text/plain", A)
"2×2 Array{Int64,2}:\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 REPL.)

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.