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

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

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(command, stdio=devnull; write::Bool = false, read::Bool = !write)

Запустить command асинхронно и вернуть кортеж (stream,process). Если read равно true, то stream читает со стандартного потока вывода процесса, и stdio опционально указывает стандартный поток ввода процесса. Если write равно true, то stream записывает в стандартный поток ввода процесса, и stdio опционально указывает стандартный поток вывода процесса.

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, если указанный объект 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: 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 (таких как IPython-основанный IJulia-notebook).

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

Извлеките самый верхний бэкэнд из стека display-backend или самую верхнюю копию 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.