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

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

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, возвращая массив прочитанных байтов.

read(s::IOStream, nb::Integer; all=true)

Читает не более nb байтов из s, возвращая массив прочитанных байтов.

Если all равно true (значение по умолчанию), эта функция будет многократно блокироваться, пытаясь прочитать все запрошенные байты, пока не произойдёт ошибка или не достигнут конец файла. Если all равно false, выполняется не более одного вызова read, а количество возвращаемых данных зависит от устройства. Обратите внимание, что не все типы потоков поддерживают опцию all.

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-цветные/escape-коды. По умолчанию это определяется тем, является ли io совместимым терминалом, и любыми флагами командной строки --color при запуске julia.

Примеры

julia> io = IOBuffer();

julia> printstyled(IOContext(io, :color => true), "string", color=:red)

julia> String(take!(io))
"\e[31mstring\e[39m"

julia> printstyled(io, "string", color=:red)

julia> String(take!(io))
"string"

julia> print(IOContext(stdout, :compact => false), 1.12341234)
1.12341234
julia> print(IOContext(stdout, :compact => true), 1.12341234)
1.12341

julia> function f(io::IO)
           if get(io, :short, false)
               print(io, "short")
           else
               print(io, "loooooong")
           end
       end
f (generic function with 1 method)

julia> f(stdout)
loooooong
julia> f(IOContext(stdout, :short => true))
short

Base.IOContextМетод

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

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

Вывод текста

Base.showМетод

show(x)

Запишите информативное текстовое представление значения в текущий поток вывода. Новые типы должны перегружать show(io, 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)

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

julia> displaysize(stdout)
(34, 147)

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

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

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

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

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) = ... для отображения ваших изображений в любом PNG-совместимом AbstractDisplay (таком как IJulia). Как обычно, убедитесь в import Base.show для добавления новых методов к встроенной функции Julia show.

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

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

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

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

showable(mime, x)

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

(По умолчанию это определяется автоматически наличием соответствующего метода show для typeof(x). Некоторые типы предоставляют пользовательские методы showable; например, если доступные форматы MIME зависят от *значения* x.)

Примеры

julia> showable(MIME("text/plain"), rand(5))
true

julia> showable("img/png", rand(5))
false

Base.reprМетод

repr(mime, x; context=nothing)

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

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

В качестве специального случая, если x является строкой (для текстовых типов MIME) или двоичным объектом (для двоичных типов 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)

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

Base.Multimedia.TextDisplayТип

TextDisplay(io::IO)

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

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.