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

Общий ввод/вывод

Base.stdoutКонстанта

stdout

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

Base.stderrКонстанта

stderr

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

Base.stdinКонстанта

stdin

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

Base.openФункция

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; keywords...) -> IOStream

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

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

open(filename::AbstractString, [mode::AbstractString]) -> IOStream

Альтернативный синтаксис для open, где используется строковый спецификатор режима вместо пяти булевых значений. Значения mode соответствуют значениям из fopen(3) или Perl open, и эквивалентны установке следующих булевых групп:

Примеры

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.

Base.IOStreamТип

IOStream

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

Base.IOBufferТип

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"

Base.take!Метод

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

Base.fdioФункция

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

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

Base.flushФункция

flush(stream)

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

Base.closeФункция

close(stream)

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

Base.writeФункция

write(io::IO, x)
write(filename::AbstractString, x)

Запишите каноническое двоичное представление значения в заданный поток ввода-вывода или файл. Верните количество байтов, записанных в поток. Также см. print, чтобы записать текстовое представление (с кодировкой, которая может зависеть от io).

Вы можете записать несколько значений с помощью одного и того же вызова write. Например, следующие выражения эквивалентны:

write(io, x, y...)
write(io, x) + write(io, y...)

Примеры

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

Base.readФункция

read(io::IO, T)

Прочитайте одно значение типа T из io, в каноническом двоичном представлении.

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.

Base.read!Функция

read!(stream::IO, array::Union{Array, BitArray})
read!(filename::AbstractString, array::Union{Array, BitArray})

Прочитать двоичные данные из потока ввода-вывода или файла, заполняя array.

Base.readbytes!Функция

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.

Base.unsafe_readФункция

unsafe_read(io::IO, ref, nbytes::UInt)

Скопировать nbytes из объекта потока IO в ref (преобразованный в указатель).

Рекомендуется, чтобы подтипы T<:IO переопределяли следующую сигнатуру метода, чтобы обеспечить более эффективные реализации: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

Base.unsafe_writeФункция

unsafe_write(io::IO, ref, nbytes::UInt)

Скопировать nbytes из ref (преобразованного в указатель) в объект IO.

Рекомендуется, чтобы подтипы T<:IO переопределяли следующую сигнатуру метода, чтобы обеспечить более эффективные реализации: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

Base.positionФункция

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

Base.seekФункция

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)

Base.seekstartФункция

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)

Base.seekendФункция

seekend(s)

Переместить поток к его концу.

Base.skipФункция

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)

Base.markФункция

mark(s)

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

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

Base.unmarkФункция

unmark(s)

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

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

Base.resetФункция

reset(s)

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

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

Base.ismarkedФункция

ismarked(s)

Вернуть true если поток s помечен.

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

Base.eofФункция

eof(stream) -> Bool

Проверить, находится ли поток ввода-вывода в конце файла. Если поток ещё не исчерпан, функция будет блокироваться, ожидая дополнительных данных при необходимости, и затем вернёт false. Поэтому всегда безопасно прочитать один байт после того, как eof вернула false. eof вернёт false до тех пор, пока доступны буферизованные данные, даже если удалённый конец соединения закрыт.

Base.isreadonlyФункция

isreadonly(io) -> Bool

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

Примеры

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

Base.iswritableФункция

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

Base.isreadableФункция

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

Base.isopenФункция

isopen(object) -> Bool

Определяет, является ли объект — например, поток или таймер — ещё не закрытым. После закрытия объекта он больше не будет генерировать новые события. Однако, так как закрытый поток может всё ещё содержать данные в буфере, используйте eof, чтобы проверить возможность чтения данных. Используйте пакет FileWatching, чтобы получать уведомления, когда поток может быть доступен для записи или чтения.

Примеры

julia> io = open("my_file.txt", "w+");

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

Base.Grisu.print_shortestФункция

print_shortest(io::IO, x)

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

Base.fdФункция

fd(stream)

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

Base.redirect_stdoutФункция

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

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

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

Base.redirect_stdoutМетод

redirect_stdout(f::Function, stream)

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

Base.redirect_stderrФункция

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

Аналогично redirect_stdout, но для stderr.

Base.redirect_stderrМетод

redirect_stderr(f::Function, stream)

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

Base.redirect_stdinФункция

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

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

Base.redirect_stdinМетод

redirect_stdin(f::Function, stream)

Выполняет функцию f, перенаправляя stdin в stream. По завершении stdin восстанавливается до своего предыдущего состояния.

Base.readchompФункция

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

Base.truncateФункция

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"

Base.skipcharsФункция

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"

Base.countlinesФункция

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

Base.PipeBufferФункция

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

Буфер IOBuffer, который позволяет читать и выполнять записи путём добавления. Поиск и обрезка не поддерживаются. См. IOBuffer для доступных конструкторов. Если data указан, создаёт буфер для работы с вектором данных, необязательно задавая размер, за пределами которого базовый Array может не увеличиваться.

Base.readavailableФункция

readavailable(stream)

Читает все доступные данные в потоке, блокируя задачу только в том случае, если данные недоступны. Результатом является Vector{UInt8,1}.

Base.IOContextТип

IOContext

IOContext предоставляет механизм для передачи настроек конфигурации вывода между методами show.

Короче говоря, это неизменяемый словарь, являющийся подклассом IO. Он поддерживает стандартные операции со словарями, такие как getindex, а также может использоваться как поток ввода-вывода.

Base.IOContextМетод

IOContext(io::IO, KV::Pair...)

Создаёт IOContext, который оборачивает заданный поток, добавляя указанные key=>value пары в свойства этого потока (обратите внимание, что io сам может быть IOContext).

• используйте (key => value) in io, чтобы проверить, присутствует ли данная комбинация в наборе свойств
• используйте get(io, key, default), чтобы получить последнее значение для определённого ключа

Следующие свойства часто используются:

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

Base.IOContextМетод

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

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

Текстовый ввод/вывод

Base.showМетод

show(x)

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

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

См. также print, который записывает представления без декораций.

Примеры

julia> show("Hello World!")
"Hello World!"
julia> print("Hello World!")
Hello World!

Base.summaryФункция

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

Base.printФункция

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

Base.printlnФункция

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"

Base.printstyledФункция

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, результат будет напечатан жирным шрифтом.

Base.sprintФункция

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

Base.showerrorФункция

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

Base.dumpФункция

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}

Base.Meta.@dumpМакрос

@dump expr

Отображает каждую часть представления данного выражения. Эквивалентно dump(:(expr)).

Base.readlineФункция

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

Base.readuntilФункция

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

Base.readlinesФункция

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

Base.eachlineФункция

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

Base.displaysizeФункция

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)

Мультимедийный ввод/вывод

Так же как текстовый вывод выполняется с помощью print, а пользовательские типы могут указывать своё текстовое представление переопределением show, Julia предоставляет стандартизированный механизм для богатого мультимедийного вывода (например, изображений, форматированного текста или даже аудио и видео), состоящий из трёх частей:

• Функция display(x) для запроса наиболее богатого доступного мультимедийного отображения объекта Julia x (с резервным текстовым выводом).
• Перегрузка show позволяет указывать произвольные мультимедийные представления (ключевые по стандартным типам MIME) для пользовательских типов.
• Мультимедийные дисплеи могут быть зарегистрированы путём наследования от универсального типа AbstractDisplay и добавления их в стек дисплеев через pushdisplay.

Базовый запуск Julia предоставляет только текстовый вывод, но более богатые дисплеи могут быть включены путём загрузки внешних модулей или использования графических сред Julia (например, ноутбука IJulia на основе IPython).

Base.Multimedia.AbstractDisplayТип

AbstractDisplay

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

Base.Multimedia.displayФункция

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-типов).

Base.Multimedia.redisplayФункция

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

По умолчанию функции redisplay просто вызывают display. Однако некоторые дисплеи могут переопределить redisplay для изменения существующего отображения x (если таковое имеется). Использование redisplay также является подсказкой для бэкенда, что x может быть отображено несколько раз, и бэкенд может отложить отображение до (например) следующего интерактивного запроса.

Base.Multimedia.displayableФункция

displayable(mime) -> Bool
displayable(d::AbstractDisplay, mime) -> Bool

Возвращает булево значение, указывающее, отображается ли данный mime тип (строка) любым из дисплеев в текущем стеке дисплеев, или конкретно дисплеем d во втором варианте.

Base.showМетод

show(io, mime, x)

Функции display в конечном итоге вызывают show для записи объекта x как заданного mime типа в заданный поток ввода-вывода io (обычно буфер памяти), если возможно. Для обеспечения богатого мультимедийного представления пользовательского типа T, достаточно определить новый show метод для T, через: show(io, ::MIME"mime", x::T) = ..., где mime — строка типа MIME, а тело функции вызывает write (или аналогичное) для записи этого представления x в io. (Обратите внимание, что обозначение MIME"" поддерживает только строковые литералы; для построения MIME типов более гибким способом используйте MIME{Symbol("")}.)

Например, если вы определили MyImage тип и знаете, как записать его в файл PNG, вы можете определить функцию show(io, ::MIME"image/png", x::MyImage) = ... для отображения ваших изображений на любом PNG-совместимом AbstractDisplay (например, IJulia). Как обычно, убедитесь, что import Base.show для добавления новых методов к встроенной функции Julia show.

Тип MIME по умолчанию — MIME"text/plain". Существует резервное определение для вывода text/plain, которое вызывает show с 2 аргументами. Поэтому этот случай должен быть обработан определением 2-аргументного show(io::IO, x::MyType) метода.

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

Первый аргумент для show может быть IOContext, указывающим свойства формата вывода. Смотрите IOContext для получения подробностей.

Base.Multimedia.showableФункция

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

Base.reprМетод

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 Array{Int64,2}:\n 1  2\n 3  4"

Base.Multimedia.MIMEТип

MIME

Тип, представляющий стандартный интернет-формат данных. «MIME» расшифровывается как «Multipurpose Internet Mail Extensions», так как стандарт первоначально использовался для описания многоцелевых вложений в электронные письма.

Объект MIME может быть передан как второй аргумент к show, чтобы запросить вывод в этом формате.

Примеры

julia> show(stdout, MIME("text/plain"), "hi")
"hi"

Base.Multimedia.@MIME_strМакрос

@MIME_str

Удобный макрос для записи типов MIME, обычно используется при добавлении методов к show. Например, синтаксис show(io::IO, ::MIME"text/html", x::MyType) = ... можно использовать для определения способа записи HTML-представления MyType.

Как упоминалось выше, можно также определять новые бэкэнды отображения. Например, модуль, который может отображать изображения PNG в окне, может зарегистрировать эту возможность в Julia, чтобы вызов display(x) для типов с представлениями PNG автоматически отображал изображение с помощью окна модуля.

Для определения нового бэкэнда отображения необходимо сначала создать подтип D абстрактного класса AbstractDisplay. Затем для каждого MIME-типа (mime строка), который может быть отображен на D, необходимо определить функцию display(d::D, ::MIME"mime", x) = ... для отображения x в этом MIME-типе, обычно вызывая show(io, mime, x) или repr(io, mime, x). Следует генерировать MethodError, если x нельзя отобразить в этом MIME-типе; это происходит автоматически, если вызвать show или repr. Наконец, необходимо определить функцию display(d::D, x) для запроса showable(mime, x) для mime типов, поддерживаемых D, и отображения «лучшего» из них; необходимо генерировать MethodError, если для x не найдено поддерживаемых MIME-типов. Аналогично, некоторые подтипы могут захотеть переопределить redisplay(d::D, ...). (Опять же, следует import Base.display для добавления новых методов к display.) Значения возврата этих функций зависят от реализации (поскольку в некоторых случаях может быть полезно вернуть «дескриптор» отображения определенного типа).

Функции отображения для D затем можно вызвать напрямую, но их также можно вызвать автоматически из display(x), просто добавив новое отображение в стек бэкэндов отображения:

Base.Multimedia.pushdisplayФункция

pushdisplay(d::AbstractDisplay)

Добавляет новое отображение d в стек глобальных бэкэндов отображения. Вызов display(x) или display(mime, x) отобразит x на совместимом бэкэнде в стеке (т.е. бэкэнде, который не генерирует MethodError).

Base.Multimedia.popdisplayФункция

popdisplay()
popdisplay(d::AbstractDisplay)

Удаляет самый верхний бэкэнд из стека бэкэндов отображения или самый верхний экземпляр d во втором варианте.

Base.Multimedia.TextDisplayТип

TextDisplay(io::IO)

Возвращает TextDisplay <: AbstractDisplay, который отображает любой объект как MIME-тип text/plain (по умолчанию), записывая текстовое представление в заданный поток ввода-вывода. (Таким образом, объекты выводятся в REPL Julia.)

Base.Multimedia.istextmimeФункция

istextmime(m::MIME)

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

Примеры

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

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

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

Base.bytesavailableФункция

bytesavailable(io)

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

Примеры

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

julia> bytesavailable(io)
34

Base.ntohФункция

ntoh(x)

Преобразует порядок байтов значения из сетевого порядка (big-endian) в порядок, используемый хостом.

Base.htonФункция

hton(x)

Преобразует порядок байтов значения из порядка, используемого хостом, в сетевой порядок (big-endian).

Base.ltohФункция

ltoh(x)

Преобразует порядок байтов значения из little-endian в порядок, используемый хостом.

Base.htolФункция

htol(x)

Преобразует порядок байтов значения из порядка, используемого хостом, в little-endian.

Base.ENDIAN_BOMКонстанта

ENDIAN_BOM

32-битная метка порядка байтов указывает на порядок байтов хостовой машины. Машины little-endian содержат значение 0x04030201. Машины big-endian содержат значение 0x01020304.