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

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

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

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

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

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

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

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

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

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) и можно прочитать достаточно байтов), но никогда не уменьшится.

См. 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, если указанный объект ввода-вывода является записываемым (если это можно определить).

Примеры

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, если указанный объект ввода-вывода является читаемым (если это можно определить).

Примеры

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

A 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: Tuple{Int,Int}, задающий размер в строках и столбцах для использования при текстовом выводе. Это может быть использовано для переопределения размера отображения для вызываемых функций, но для получения размера экрана используйте функцию displaysize.
• :typeinfo: 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, x), где первый аргумент — поток. Представление, используемое show, обычно включает специфичные для Julia форматирование и информацию о типе.

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 не задан) каноническое (без декораций) текстовое представление значений xs, если оно есть, иначе вызвать show. Представление, используемое print, включает минимальное форматирование и старается избегать деталей, специфичных для Julia.

Вывод nothing запрещен и приводит к ошибке.

Примеры

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

Примеры

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

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

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

julia> rm("my_file.txt")

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)

Для получения размера вашего терминала:

julia> displaysize(stdout)
(34, 147)

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

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

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

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

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

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

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

В общем случае, нельзя предполагать, что вывод display попадает в stdout (в отличие от print(x) или show(x)). Например, display(x) может открыть отдельное окно с изображением. display(x) означает "отобразить x наилучшим способом для текущего(их) устройства(ов) вывода". Если вам нужен вывод текста, подобный REPL, который гарантированно попадает в stdout, используйте show(stdout, "text/plain", x) вместо этого.

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

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

Как упоминалось выше, вы также можете определить новые отображающие бэкэнды. Например, модуль, который может отображать изображения 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.