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

stdout

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

stderr

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

stdin

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

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

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

open(command, mode::AbstractString, stdio=devnull)

Запустить command асинхронно. Аналогично open(command, stdio; read, write), но задаёт флаги чтения и записи через строку режима вместо ключевых аргументов. Возможные строки режима:

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

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

open(f::Function, command, args...; kwargs...)

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

IOStream

Буферизованный поток IO, оборачивающий дескриптор файла ОС. В основном используется для представления файлов, возвращаемых функцией open.

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"

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

fdio([name::AbstractString, ]fd::Integer[, own::Bool=false]) -> IOStream

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

flush(stream)

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

close(stream)

Закрыть поток ввода-вывода. Сначала выполняется flush.

write(io::IO, x)
write(filename::AbstractString, x)

Записать каноническое двоичное представление значения в указанный поток ввода-вывода или файл. Вернуть количество записанных байтов в поток. См. также print для записи текстового представления (с кодировкой, которая может зависеть от io).

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

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

Примеры

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

julia> write(io, "Sometimes those members") + write(io, " write documentation.")
44

julia> String(take!(io))
"Sometimes those members write documentation."

Пользовательские типы данных без методов write могут быть записаны, если они обернуты в Ref:

julia> struct MyStruct; x::Float64; end

julia> io = IOBuffer()
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=Inf, ptr=1, mark=-1)

julia> write(io, Ref(MyStruct(42.0)))
8

julia> seekstart(io); read!(io, Ref(MyStruct(NaN)))
Base.RefValue{MyStruct}(MyStruct(42.0))

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.

read!(stream::IO, array::AbstractArray)
read!(filename::AbstractString, array::AbstractArray)

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

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

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

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

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

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

unsafe_read(io::IO, ref, nbytes::UInt)

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

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

unsafe_write(io::IO, ref, nbytes::UInt)

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

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

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

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)

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)

seekend(s)

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

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)

mark(s)

Добавить метку в текущую позицию потока s. Вернуть помеченную позицию.

См. также unmark, reset, ismarked.

unmark(s)

Удалить метку из потока s. Вернуть true если поток был помечен, false в противном случае.

См. также mark, reset, ismarked.

reset(s)

Сбросить поток s до ранее помеченной позиции и удалить метку. Вернуть ранее помеченную позицию. Вызвать ошибку, если поток не помечен.

См. также mark, unmark, ismarked.

ismarked(s)

Возвращает true если поток s помечен.

См. также mark, unmark, reset.

eof(stream) -> Bool

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

isreadonly(io) -> Bool

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

Примеры

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

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

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

isopen(object) -> Bool

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

Примеры

julia> io = open("my_file.txt", "w+");

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

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

redirect_stdout([stream]) -> (rd, wr)

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

Если вызвано с необязательным аргументом stream, то возвращает stream само по себе.

redirect_stdout(f::Function, stream)

Выполняет функцию f с перенаправлением stdout на stream. После завершения stdout восстанавливается до предыдущего значения.

redirect_stderr([stream]) -> (rd, wr)

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

redirect_stderr(f::Function, stream)

Выполняет функцию f с перенаправлением stderr на stream. После завершения stderr восстанавливается до предыдущего значения.

redirect_stdin([stream]) -> (rd, wr)

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

redirect_stdin(f::Function, stream)

Выполняет функцию f с перенаправлением stdin на stream. После завершения stdin восстанавливается до предыдущего значения.

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

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"

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"

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

PipeBuffer(data::Vector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))

Буфер ввода-вывода IOBuffer, позволяющий чтение и запись путем добавления. Поиск и обрезка не поддерживаются. См. IOBuffer для доступных конструкторов. Если data задано, создаёт Array для работы с вектором данных, необязательно указывая размер, превышение которого не допускает роста базового Array.

readavailable(stream)

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

IOContext

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

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

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

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

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

show(x)

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

repr возвращает результат show в виде строки.

См. также print, который выводит неформатированные представления.

Примеры

julia> show("Hello World!")
"Hello World!"
julia> print("Hello World!")
Hello World!

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

print([io::IO], xs...)

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

print обращается к show, поэтому большинство типов должны просто определять show. Определите print, если у вашего типа есть отдельное "простое" представление. Например, show отображает строки с кавычками, а print отображает строки без кавычек.

string возвращает результат print в виде строки.

Примеры

julia> print("Hello World!")
Hello World!
julia> io = IOBuffer();

julia> print(io, "Hello", ' ', :World!)

julia> String(take!(io))
"Hello World!"

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"

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, результат будет выведен полужирным шрифтом.

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

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

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}

@dump expr

Показывает каждую часть представления данного выражения. Эквивалентно dump(:(expr)).

readline(io::IO=stdin; keep::Bool=false)
readline(filename::AbstractString; keep::Bool=false)

Считывает одну строку текста из заданного потока ввода-вывода или файла (по умолчанию stdin). При чтении из файла текст предполагается закодированным в UTF-8. Строки ввода завершаются '\n' или "\r\n" или концом потока ввода. Когда keep равно false (по умолчанию), эти заключительные символы новой строки удаляются из строки перед возвратом. Когда keep равно true, они возвращаются как часть строки.

Примеры

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

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

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

julia> rm("my_file.txt")

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

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

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

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)

AbstractDisplay

Абстрактный базовый тип для устройств вывода богатых отображений. TextDisplay является подтипом этого.

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

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

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

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

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

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

displayable(mime) -> Bool
displayable(d::AbstractDisplay, mime) -> Bool

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

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 (например, 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.

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

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"

MIME

Тип, представляющий стандартный интернет-формат данных. "MIME" означает "Multipurpose Internet Mail Extensions", так как этот стандарт изначально использовался для описания мультимедийных вложений в электронные письма.

Объект MIME может быть передан в качестве второго аргумента к show для запроса вывода в этом формате.

Примеры

julia> show(stdout, MIME("text/plain"), "hi")
"hi"

@MIME_str

Удобный макрос для записи типов MIME, обычно используемый при добавлении методов к show. Например, синтаксис show(io::IO, ::MIME"text/html", x::MyType) = ... можно использовать для определения способа записи HTML-представления MyType.

pushdisplay(d::AbstractDisplay)

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

popdisplay()
popdisplay(d::AbstractDisplay)

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

TextDisplay(io::IO)

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

istextmime(m::MIME)

Определяет, является ли тип MIME текстовыми данными. Типы MIME по умолчанию считаются двоичными данными, за исключением набора типов, известных как текстовые данные (возможно, Unicode).

Примеры

julia> istextmime(MIME("text/plain"))
true

julia> istextmime(MIME("img/png"))
false

bytesavailable(io)

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

Примеры

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> bytesavailable(io)
34

ntoh(x)

Преобразует порядок байтов значения из сетевого порядка байтов (big-endian) в порядок байтов, используемый хостом.

hton(x)

Преобразует порядок байтов значения из порядка байтов, используемого хостом, в сетевой порядок байтов (big-endian).

ltoh(x)

Преобразует порядок байтов значения из little-endian в порядок байтов, используемый хостом.

htol(x)

Преобразует порядок байтов значения из порядка байтов, используемого хостом, в little-endian.

ENDIAN_BOM

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