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

Общие операции ввода/вывода

STDOUT

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

STDERR

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

STDIN

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

open(filename[, read, write, create, truncate, append]) → IOStream

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

open(filename[, mode]) → IOStream

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

Режим	Описание
r	чтение
r+	чтение, запись
w	запись, создание, обнуление
w+	чтение, запись, создание, обнуление
a	запись, создание, добавление
a+	чтение, запись, создание, добавление

open(command, mode::AbstractString="r", stdio=DevNull)

Начать выполнение command асинхронно и вернуть кортеж (stream,process). Если mode равно "r", тогда stream считывает данные из стандартного потока вывода процесса, и stdio необязательно указывает стандартный поток ввода процесса. Если mode равно "w", тогда stream записывает данные в стандартный поток ввода процесса, и stdio необязательно указывает стандартный поток вывода процесса.

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

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

open(f::Function, args...)

Применить функцию f к результату open(args...) и закрыть полученный дескриптор файла по завершении.

Пример: open(readstring, "file.txt")

IOBuffer() → IOBuffer

Создать поток ввода/вывода в памяти.

IOBuffer(size::Int)

Создать буфер ввода/вывода фиксированного размера. Буфер не будет динамически увеличиваться.

IOBuffer(string)

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

IOBuffer([data][, readable, writable[, maxsize]])

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

takebuf_array(b::IOBuffer)

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

takebuf_string(b::IOBuffer)

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

fdio([name::AbstractString, ]fd::Integer[, own::Bool]) → IOStream

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

flush(stream)

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

close(stream)

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

write(stream::IO, x)

write(filename::AbstractString, x)

Записать каноническое двоичное представление значения в заданный поток ввода/вывода или файл. Возвращает количество записанных байтов в поток.

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

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

read(stream::IO, T)

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

read(stream::IO, T, dims)

Прочитать ряд значений типа T из stream, в каноническом двоичном представлении. dims — это либо кортеж, либо ряд целочисленных аргументов, задающих размер Array{T} для возврата.

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

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

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

readbytes!(stream::IO, b::AbstractVector{UInt8}, nb=length(b); all=true)

Прочитать не более nb байтов из stream в b, вернув количество прочитанных байтов. Размер b увеличится при необходимости (то есть, если nb больше length(b) и достаточно байтов было прочитано), но никогда не уменьшится.

См. read для описания параметра all.

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(filename::AbstractString, args...)

Открыть файл и прочитать его содержимое. args передаётся в read: это эквивалентно open(io->read(io, args...), filename).

unsafe_read(io, ref, nbytes)

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

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

unsafe_write(io, ref, nbytes)

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

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

position(s)

Получить текущую позицию потока.

seek(s, pos)

Переместить поток в заданную позицию.

seekstart(s)

Переместить поток в начало.

seekend(s)

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

skip(s, offset)

Переместить поток относительно текущей позиции.

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(stream) → Bool

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

iswritable(io) → Bool

Возвращает true, если указанный объект IO является записываемым (если это можно определить).

isreadable(io) → Bool

Возвращает true, если указанный объект IO является читаемым (если это можно определить).

isopen(object) → Bool

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

serialize(stream, value)

Записать произвольное значение в поток в неявном формате, чтобы его можно было прочитать обратно с помощью deserialize. Прочитанное значение будет максимально идентично оригинальному. В целом, этот процесс не будет работать, если чтение и запись выполняются различными версиями Julia или экземпляром Julia с другим системным изображением. Значения Ptr сериализуются как нулевые битовые шаблоны (NULL).

deserialize(stream)

Прочитать значение, записанное с помощью serialize. deserialize предполагает, что двоичные данные, прочитанные из stream, правильные и были сериализованы совместимой реализацией serialize. Она разработана с целью простоты и производительности и не проверяет прочитанные данные. Некорректные данные могут привести к завершению процесса. Вызывающая сторона должна гарантировать целостность и корректность данных, прочитанных из stream.

escape_string(io, str::AbstractString, esc::AbstractString)

Общая экранировка традиционных C и Unicode последовательностей, а также любых символов в esc также экранируются (с обратным слешем).

unescape_string(io, s::AbstractString)

Общая раскодировка традиционных C и Unicode последовательностей. Обратное преобразование escape_string().

join(io, items, delim[, last])

Вывести элементы items в io с delim между ними. Если last указано, оно используется в качестве разделителя вместо delim.

print_shortest(io, x)

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

fd(stream)

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

redirect_stdout()

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

redirect_stdout(stream)

Заменить STDOUT потоком для всего вывода уровня C и Julia в STDOUT. Обратите внимание, что stream должен быть TTY, Pipe или TCPSocket.

redirect_stderr([stream])

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

redirect_stdin([stream])

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

readchomp(x)

Прочитать все данные x в виде строки и удалить единственный конечный символ новой строки. Эквивалентно chomp(readstring(x)).

truncate(file, n)

Изменить размер файла или буфера, заданного первым аргументом, ровно на n байт, заполняя ранее не выделенное пространство символами ‘\0’, если файл или буфер увеличивается.

skipchars(stream, predicate; linecomment::Char)

Переместить поток вперёд до символа, перед первым символом, для которого predicate возвращает false. Например, skipchars(stream, isspace) пропустит все пробелы. Если указан ключевой аргумент linecomment символы от этого символа до конца строки также будут пропущены.

countlines(io[, eol::Char])

Прочитать io до конца потока/файла и подсчитать количество строк. Для указания файла передайте имя файла в качестве первого аргумента. Поддерживаются маркеры EOL, отличные от ‘\n’, передавая их в качестве второго аргумента.

PipeBuffer()

IOBuffer, который позволяет читать и выполнять запись путём добавления. Поиск и обрезка не поддерживаются. Обратитесь к IOBuffer для доступных конструкторов.

PipeBuffer(data::Vector{UInt8}[, maxsize])

Создать PipeBuffer для работы с вектором данных, необязательно указав размер, превысив который базовый массив не может быть увеличен.

readavailable(stream)

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

IOContext

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

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

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

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

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

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

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

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

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

IOContext(io::IO; properties...)

То же, что и IOContext(io::IO, KV::Pair), но принимает свойства в качестве ключевых аргументов.

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

show(x)

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

showcompact(x)

Показать компактное представление значения.

Используется для вывода элементов массива без повторения информации о типе (что было бы избыточно с тем, что выводится один раз для всего массива), и без разрывов строк внутри представления элемента.

Чтобы предложить компактное представление, отличное от стандартного, пользовательский тип должен проверить get(io, :compact, false) в своём обычном методе show.

showall(x)

Аналогично show, за исключением того, что показывает все элементы массивов.

summary(x)

Возвращает строку, дающую краткое описание значения. По умолчанию возвращает string(typeof(x)), например, Int64.

Для массивов возвращает строку с информацией о размере и типе, например, 10-element Array{Int64,1}.

print(x)

Вывести (в стандартный поток вывода) каноническое (без декораций) текстовое представление значения, если оно есть, иначе вызвать show. Представление, используемое print включает минимальное форматирование и старается избежать деталей, специфичных для Julia.

println(x)

Вывести (используя print()) x, после чего добавить новую строку.

print_with_color(color::Symbol, [io, ]strings...)

Вывод строк в указанном цвете, заданном символом.

color может принимать любые значения :normal, :bold, :black, :blue, :cyan, :green, :magenta, :red, :white, или :yellow.

info(msg)

Отображение информационного сообщения. Аргумент msg представляет собой строку, описывающую отображаемую информацию.

warn(msg)

Отображение предупреждения. Аргумент msg представляет собой строку, описывающую отображаемое предупреждение.

@printf([io::IOStream, ]"%Fmt", args...)

Вывод args с использованием форматирования строк в стиле C printf(). Дополнительно, IOStream может быть передан как первый аргумент для перенаправления вывода.

@sprintf("%Fmt", args...)

Возвращает отформатированный вывод @printf в виде строки.

julia> s = @sprintf "this is a %s %15.1f" "test" 34.567;

julia> println(s)
this is a test            34.6

sprint(f::Function, args...)

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

showerror(io, e)

Отображение описательного представления объекта исключения.

dump(x)

Отображение всех частей представления значения.

readstring(stream::IO)

readstring(filename::AbstractString)

Чтение всего содержимого входного потока или файла в виде строки. Текст предполагается закодированным в UTF-8.

readline(stream::IO=STDIN)

readline(filename::AbstractString)

Чтение одной строки текста, включая заключительный символ новой строки (если он достигнут до конца ввода), из заданного входного потока или файла (по умолчанию STDIN). При чтении из файла, текст предполагается закодированным в UTF-8.

readuntil(stream::IO, delim)

readuntil(filename::AbstractString, delim)

Чтение строки из входного потока или файла до и включая заданный байт-разделитель. Текст предполагается закодированным в UTF-8.

readlines(stream::IO)

readlines(filename::AbstractString)

Чтение всех строк входного потока или файла в виде вектора строк. Текст предполагается закодированным в UTF-8.

eachline(stream::IO)

eachline(filename::AbstractString)

Создание итерируемого объекта, который выдает каждую строку из входного потока или файла. Текст предполагается закодированным в UTF-8.

readdlm(source, delim::Char, T::Type, eol::Char; header=false, skipstart=0, skipblanks=true, use_mmap, quotes=true, dims, comments=true, comment_char='#')

Чтение матрицы из источника, где каждая строка (разделенная eol) даёт одну строку, с элементами, разделенными заданным разделителем. Источником может быть текстовый файл, поток или массив байтов. Файлы с сопоставлением памяти могут быть использованы, передавая байтовое представление сопоставленного сегмента как источник.

Если T является числовым типом, результатом будет массив этого типа, с любыми нечисловыми элементами как NaN для чисел с плавающей точкой, или ноль. Другие полезные значения T включают String, AbstractString, и Any.

Если header равно true, первая строка данных будет считана как заголовок, и вместо только data_cells будет возвращена кортеж (data_cells, header_cells).

Указание skipstart пропустит соответствующее количество начальных строк из ввода.

Если skipblanks равно true, пустые строки во входных данных будут проигнорированы.

Если use_mmap равно true, файл, указанный source, будет сопоставлен в памяти для потенциального ускорения. По умолчанию true, за исключением Windows. На Windows вы можете указать true для больших файлов, который читается только один раз и не записывается.

Если quotes равно true, столбцы, заключённые в двойные кавычки (”), могут содержать новые строки и разделители столбцов. Двойные кавычки внутри цитируемого поля должны быть экранированы другой двойной кавычкой. Указание dims как кортежа ожидаемых строк и столбцов (включая заголовок, если он есть) может ускорить чтение больших файлов. Если comments равно true, строки, начинающиеся с comment_char, и текст, следующий за comment_char в любой строке, игнорируются.

readdlm(source, delim::Char, eol::Char; options...)

Если все данные числовые, результатом будет числовой массив. Если некоторые элементы нельзя разобрать как числа, возвращается разнородный массив чисел и строк.

readdlm(source, delim::Char, T::Type; options...)

Разделитель конца строки принимается как \n.

readdlm(source, delim::Char; options...)

Разделитель конца строки принимается как \n. Если все данные числовые, результатом будет числовой массив. Если некоторые элементы нельзя разобрать как числа, возвращается разнородный массив чисел и строк.

readdlm(source, T::Type; options...)

Столбцы предполагаются разделенными одной или несколькими пробелами. Разделитель конца строки принимается как \n.

readdlm(source; options...)

Столбцы предполагаются разделенными одной или несколькими пробелами. Разделитель конца строки принимается как \n. Если все данные числовые, результатом будет числовой массив. Если некоторые элементы нельзя разобрать как числа, возвращается разнородный массив чисел и строк.

writedlm(f, A, delim='\t'; opts)

Запись A (вектор, матрица или итерируемая коллекция итерируемых строк) в виде текста в f (строка имени файла или поток IO), используя заданный разделитель delim (по умолчанию табуляция, но может быть любым печатаемым объектом Julia, обычно Char или AbstractString).

Например, два вектора x и y одинаковой длины могут быть записаны как два столбца табулированного текста в f либо writedlm(f, [x y]), либо writedlm(f, zip(x, y)).

readcsv(source, [T::Type]; options...)

Эквивалентно readdlm с delim установленным в запятую, и тип опционально определен T.

writecsv(filename, A; opts)

Эквивалентно writedlm() с delim установленным в запятую.

Base64EncodePipe(ostream)

Возвращает новый поток записи, который преобразует все записанные в него байты в ASCII-байты, закодированные в base64, и записывает их в ostream. Вызов close на потоке Base64EncodePipe необходим для завершения кодирования (но не закрывает ostream).

Base64DecodePipe(istream)

Возвращает новый поток чтения, который декодирует данные, закодированные в base64, считываемые из istream.

base64encode(writefunc, args...)

base64encode(args...)

Учитывая функцию типа write writefunc, которая принимает входной поток как первый аргумент, base64encode(writefunc, args...) вызывает writefunc для записи args... в закодированную в base64 строку и возвращает строку. base64encode(args...) эквивалентно base64encode(write, args...): преобразует свои аргументы в байты с использованием стандартных функций write и возвращает закодированную в base64 строку.

base64decode(string)

Декодирует закодированные в base64 string и возвращает Vector{UInt8} декодированных байтов.

displaysize(io) → (lines, columns)

Возвращает номинальный размер экрана, который может использоваться для рендеринга вывода в этот объект io.

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

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

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

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

display(x)

display(d::Display, x)

display(mime, x)

display(d::Display, mime, x)

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

Также существуют два варианта с аргументом mime (строка типа MIME, например, "image/png"), которые пытаются отобразить x с использованием запрошенного типа MIME только, выбросив MethodError, если этот тип не поддерживается ни одним из отображений, ни x. В этих вариантах также можно предоставить «сырые» данные в запрошенном типе MIME, передав x::AbstractString (для типов MIME с текстовым хранением, таких как text/html или application/postscript) или x::Vector{UInt8} (для двоичных типов MIME).

redisplay(x)

redisplay(d::Display, x)

redisplay(mime, x)

redisplay(d::Display, mime, x)

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

displayable(mime) → Bool

displayable(d::Display, mime) → Bool

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

show(stream, mime, x)

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

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

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

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

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

mimewritable(mime, x)

Возвращает логическое значение, указывающее, может ли объект x быть записан как заданный тип mime. (По умолчанию это определяется автоматически наличием соответствующей функции show для typeof(x).)

reprmime(mime, x)

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

В качестве специального случая, если x является AbstractString (для текстовых типов MIME) или Vector{UInt8} (для двоичных типов MIME), функция reprmime предполагает, что x уже находится в запрошенном формате mime и просто возвращает x.

stringmime(mime, x)

Возвращает AbstractString, содержащий представление x в запрошенном типе mime. Это похоже на reprmime за исключением того, что двоичные данные кодируются в формате base64 как строка ASCII.

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

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

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

pushdisplay(d::Display)

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

popdisplay()

popdisplay(d::Display)

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

TextDisplay(stream)

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

istextmime(m::MIME)

Определяет, является ли тип MIME текстовыми данными.

Операции ввода/вывода с отображением памяти

Mmap.Anonymous(name, readonly, create)

Создает объект, подобный IO, для создания нулевых отображенных в памяти областей, которые не привязаны к файлу для использования в Mmap.mmap. Используется функцией SharedArray для создания массивов в общей памяти.

Mmap.mmap(io::Union{IOStream,AbstractString,Mmap.AnonymousMmap}[, type::Type{Array{T,N}}, dims, offset]; grow::Bool=true, shared::Bool=true)

Mmap.mmap(type::Type{Array{T, N}}, dims)

Создаёт Array со значениями, связанными с файлом с помощью памяти. Это удобный способ работы с данными, слишком большими для оперативной памяти компьютера.

Тип — Array{T,N} со значением типа бит T и размерностью N, которая определяет, как интерпретируются байты массива. Обратите внимание, что файл должен храниться в двоичном формате, и преобразования форматов невозможны (это ограничение операционных систем, а не Julia).

dims — кортеж или одно значение Integer, определяющее размер или длину массива.

Файл передаётся через аргумент потока, либо как открытый IOStream , либо как строка имени файла. При инициализации потока используйте "r" для «только для чтения» массива и "w+" для создания нового массива, используемого для записи значений на диск.

Если аргумент type не указан, используется значение по умолчанию Vector{UInt8}.

Можно указать смещение (в байтах), например, для пропуска заголовка в файле. Значение смещения по умолчанию — текущая позиция потока для IOStream.

Ключевой аргумент grow указывает, должен ли файл на диске быть расширен для размещения запрошенного размера массива (если общий размер файла меньше запрошенного размера массива). Требуются права на запись для расширения файла.

Ключевой аргумент shared указывает, будут ли изменения, внесённые в результирующее Array и сохранённые в нём, видны другим процессам, отображающим тот же файл.

Например, следующий код

# Create a file for mmapping
# (you could alternatively use mmap to do this step, too)
A = rand(1:20, 5, 30)
s = open("/tmp/mmap.bin", "w+")
# We'll write the dimensions of the array as the first two Ints in the file
write(s, size(A,1))
write(s, size(A,2))
# Now write the data
write(s, A)
close(s)

# Test by reading it back in
s = open("/tmp/mmap.bin")   # default is read-only
m = read(s, Int)
n = read(s, Int)
A2 = Mmap.mmap(s, Matrix{Int}, (m,n))

создаёт m×n Matrix{Int}, связанный с файлом, ассоциированным с потоком s.

Более портативный файл потребовал бы кодирования информации о размере слова — 32 бита или 64 бита — и о порядке байтов в заголовке. На практике рекомендуется использовать кодирование двоичных данных с использованием стандартных форматов, таких как HDF5 (который может быть использован с отображением в памяти).

Mmap.mmap(io, BitArray[, dims, offset])

Создаёт BitArray со значениями, связанными с файлом с помощью памяти; у него та же цель, он работает так же и имеет те же аргументы, что и mmap(), но представление байтов отличается.

Пример: B = Mmap.mmap(s, BitArray, (25,30000))

Это создаст массив 25×30000 BitArray, связанный с файлом, ассоциированным с потоком s.

Mmap.sync!(array)

Принудительно синхронизирует версию массива в памяти с версией на диске.

Сеть В/В

connect([host, ]port) → TCPSocket

Подключается к хосту host на порту port.

connect(path) → PipeEndpoint

Подключается к именованной трубе/сокету домена UNIX по адресу path.

listen([addr, ]port) → TCPServer

Прослушивает порт по адресу, указанному в addr. По умолчанию прослушивается только localhost. Чтобы прослушивать все интерфейсы, передайте IPv4(0) или IPv6(0) соответственно.

listen(path) → PipeServer

Создаёт и прослушивает именованную трубу/сокет домена UNIX.

getaddrinfo(host)

Получает IP-адрес host (возможно, потребуется выполнить поиск DNS).

getsockname(sock::Union{TCPServer, TCPSocket}) → (IPAddr,UInt16)

Получает IP-адрес и порт, к которому подключён данный сокет TCP (или к которому привязан сокет TCPServer).

IPv4(host::Integer) → IPv4

Возвращает объект IPv4 из IP-адреса, представленного в виде целого числа.

IPv6(host::Integer) → IPv6

Возвращает объект IPv6 из IP-адреса, представленного в виде целого числа.

nb_available(stream)

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

accept(server[, client])

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

listenany(port_hint) → (UInt16,TCPServer)

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

poll_fd(fd, timeout_s::Real; readable=false, writable=false)

Отслеживает дескриптор файла fd на изменения доступности для чтения или записи с заданным таймаутом в timeout_s секундах.

Ключевые аргументы определяют, какие из состояний чтения и/или записи должны отслеживаться; хотя бы одно из них должно быть установлено в true.

Возвращаемое значение — объект с булевыми полями readable, writable, и timedout, отображающие результат опроса.

poll_file(path, interval_s::Real, timeout_s::Real) → (previous::StatStruct, current::StatStruct)

Отслеживает файл с помощью опроса каждые interval_s секунды до тех пор, пока не произойдёт изменение, или не пройдёт timeout_s секунд. interval_s должен быть большим интервалом; по умолчанию это 5,007 секунд.

Возвращает пару StatStruct объектов (previous, current) при обнаружении изменений.

Чтобы определить, когда файл был изменён, сравните mtime(prev) != mtime(current) для обнаружения уведомлений об изменениях. Однако использование watch_file для этой операции предпочтительнее, поскольку оно более надёжно и эффективно, хотя в некоторых ситуациях может быть недоступно.

watch_file(path, timeout_s::Real)

Отслеживает файл или директорию path на изменения до тех пор, пока не произойдёт изменение, или не пройдёт timeout_s секунд.

Возвращаемое значение — объект с булевыми полями changed, renamed, и timedout, отображающие результат отслеживания файла.

Это поведение функции немного отличается в разных платформах. Смотрите <https://nodejs.org/api/fs.html#fs_caveats> для получения более подробной информации.

bind(socket::Union{UDPSocket, TCPSocket}, host::IPAddr, port::Integer; ipv6only=false)

Привязывает socket к заданному host:port. Обратите внимание, что 0.0.0.0 будет прослушивать все устройства. Параметр ipv6only отключает режим двойного стека. Если он true, создаётся только стек IPv6.

send(socket::UDPSocket, host::IPv4, port::Integer, msg)

Отправляет msg по socket на host:port.

recv(socket::UDPSocket)

Считывает пакет UDP из указанного сокета и возвращает полученные байты. Этот вызов блокируется.

recvfrom(socket::UDPSocket) → (address, data)

Считывает пакет UDP из указанного сокета, возвращая кортеж (адрес, данные), где адрес будет либо IPv4, либо IPv6, в зависимости от ситуации.

setopt(sock::UDPSocket; multicast_loop = nothing, multicast_ttl=nothing, enable_broadcast=nothing, ttl=nothing)

Устанавливает параметры сокета UDP. multicast_loop: обратная связь для мультипольных пакетов (по умолчанию: true). multicast_ttl: TTL для мультипольных пакетов. enable_broadcast: флаг должен быть установлен в true если сокет будет использоваться для широковещательных сообщений, в противном случае система UDP вернёт ошибку доступа (по умолчанию: false). ttl: время жизни пакетов, отправленных по сокету.

ntoh(x)

Преобразует порядок байтов значения из сетевого порядка байтов (большая эндианность) в порядок байтов хоста.

hton(x)

Преобразует порядок байтов значения из порядка байтов хоста в сетевой порядок байтов (большая эндианность).

ltoh(x)

Преобразует порядок байтов значения из малой эндианности в порядок байтов хоста.

htol(x)

Преобразует порядок байтов значения из порядка байтов хоста в малую эндианность.

ENDIAN_BOM

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