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

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

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

stdout

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

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

stderr

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

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

stdin

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

Base.openФункция

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(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(fd::OS_HANDLE) -> IO

Возьмите необработанный дескриптор файла, оберните его в тип IO, понятный Julia, и присвойте себе управление дескриптором. Вызовите open(Libc.dup(fd)), чтобы избежать захвата управления исходным дескриптором.

open(command, other=devnull; write::Bool = false, read::Bool = !write)

Запустить command асинхронно и вернуть объект process::IO. Если read истинно, то чтение из процесса происходит со стандартного вывода процесса, а other (опционально) указывает на стандартный поток ввода процесса. Если write истинно, то запись происходит в стандартный поток ввода процесса, а other (опционально) указывает на стандартный поток вывода процесса. Стандартный поток ошибок процесса подключен к текущей глобальной переменной stderr.

open(f::Function, command, mode::AbstractString="r", stdio=devnull)

Аналогично open(command, mode, stdio), но вызывает 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 указан, создает PipeBuffer для работы с вектором данных, необязательно указывая размер, за пределами которого базовый 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: 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

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.

Печать nothing запрещена и вызывает ошибку.

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 notebook на основе 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 аргументами. Поэтому в этом случае следует определить метод show(io::IO, x::MyType) с 2 аргументами.

Технически, макрос 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 недоступен). AbstractString возвращается для MIME-типов с текстовыми представлениями (таких как "text/html" или "application/postscript"), в то время как бинарные данные возвращаются как Vector{UInt8}. (Функция istextmime(mime) возвращает, рассматривает ли Julia данный mime тип как текстовый.)

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

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

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

Примеры

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

julia> repr("text/plain", A)
"2×2 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 (по умолчанию), записывая текстовое представление в указанный поток ввода-вывода. (Вот как объекты печатаются в интерактивной оболочке 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.