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

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; lock = true, keywords...) -> IOStream

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

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

Ключевой аргумент lock управляет, будут ли операции блокироваться для безопасного многопоточного доступа.

open(filename::AbstractString, [mode::AbstractString]; lock = true) -> IOStream

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

Ключевой аргумент lock управляет, будут ли операции блокироваться для безопасного многопоточного доступа.

Примеры

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 равно true, то чтение из процесса происходит со стандартного вывода процесса, а stdio необязательно задает поток стандартного ввода процесса. Если write равно true, то запись происходит в стандартный ввод процесса, а stdio необязательно задает поток стандартного вывода процесса. Поток стандартных ошибок процесса подключен к текущей глобальной переменной stderr.

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

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

IOStream

Буферизованный поток ввода/вывода, оборачивающий дескриптор файла ОС. В основном используется для представления файлов, возвращаемых 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).

Порядок байтов записанного значения зависит от порядка байтов на целевой системе. Для получения результатов, которые согласованы на всех платформах, необходимо преобразовать к/из фиксированного порядка байтов (например, используя htol и ltoh).

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

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

Примеры

Согласованная сериализация:

julia> fname = tempname(); # random temporary filename

julia> open(fname,"w") do f
           # Make sure we write 64bit integer in little-endian byte order
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # Convert back to host byte order and host integer type
           Int(ltoh(read(f,Int64)))
       end
42

Объединение вызовов записи:

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, в каноническом двоичном представлении.

Обратите внимание, что Julia не преобразует порядок байтов за вас. Для этой цели используйте ntoh или ltoh.

read(io::IO, String)

Прочитать все содержимое io, как String (также см. readchomp).

Примеры

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)

readeach(io::IO, T)

Возвращает итерируемый объект, возвращающий значения read(io, T).

См. также skipchars, eachline, readuntil.

Примеры

julia> io = IOBuffer("JuliaLang is a GitHub organization.\n It has many members.\n");

julia> for c in readeach(io, Char)
           c == '\n' && break
           print(c)
       end
JuliaLang is a GitHub organization.

peek(stream[, T=UInt8])

Прочитать и вернуть значение типа T из потока, не изменяя текущую позицию в потоке.

Примеры

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

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_stdio(;stdin=stdin, stderr=stderr, stdout=stdout)

Перенаправить подмножество потоков stdin, stderr, stdout. Каждый аргумент должен быть IOStream, TTY, Pipe, сокетом или devnull.

redirect_stdio(f; stdin=nothing, stderr=nothing, stdout=nothing)

Перенаправить подмножество потоков stdin, stderr, stdout, выполнить f() и восстановить каждый поток.

Возможные значения для каждого потока:

• nothing — указывает, что поток не должен перенаправляться.
• path::AbstractString — перенаправление потока в файл по адресу path.
• io — IOStream, TTY, Pipe, сокет или devnull.

Примеры

julia> redirect_stdio(stdout="stdout.txt", stderr="stderr.txt") do
           print("hello stdout")
           print(stderr, "hello stderr")
       end

julia> read("stdout.txt", String)
"hello stdout"

julia> read("stderr.txt", String)
"hello stderr"

Случаи особые

Возможно передать один и тот же аргумент в stdout и stderr:

julia> redirect_stdio(stdout="log.txt", stderr="log.txt", stdin=devnull) do
    ...
end

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

julia> io1 = open("same/path", "w")

julia> io2 = open("same/path", "w")

julia> redirect_stdio(f, stdout=io1, stderr=io2) # not suppored

Также аргумент stdin не может быть тем же дескриптором, что и stdout или stderr.

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # not supported

redirect_stdout([stream]) -> stream

Создать канал, в который будет перенаправляться весь вывод C- и Julia-уровней stdout. Возвращает поток, представляющий концы канала. Данные, записанные в stdout, теперь могут быть прочитаны из конца rd канала.

См. также redirect_stdio.

redirect_stdout(f::Function, stream)

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

redirect_stderr([stream]) -> stream

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

См. также redirect_stdio.

redirect_stderr(f::Function, stream)

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

redirect_stdin([stream]) -> stream

Как redirect_stdout, но для stdin. Обратите внимание, что направление потока инвертировано.

См. также redirect_stdio.

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.

Для подсчета строк в String, можно использовать countlines(IOBuffer(str)).

Примеры

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> eof(io) # counting lines moves the file pointer
true

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

julia> countlines(io, eol = '.')
1

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

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

readavailable(stream)

Прочитать доступные буферизованные данные из потока. Фактический ввод/вывод выполняется только в том случае, если данные ещё не буферизованы. Результат – это Vector{UInt8}.

IOContext

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

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

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

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

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

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

• :compact: Логическое значение, указывающее, что значения должны печататься более компактно, например, что числа должны печататься с меньшим количеством цифр. Это устанавливается при печати элементов массива. Вывод :compact не должен содержать разрывов строк.
• :limit: Логическое значение, указывающее, что контейнеры должны обрезаться, например, показывая … вместо большинства элементов.
• :displaysize: A 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

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

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

show([io::IO = stdout], x)

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

repr возвращает вывод show как строку.

Для настройки удобочитаемого текстового вывода для объектов типа T, определите show(io::IO, ::MIME"text/plain", ::T) вместо этого. Проверка свойства :compact IOContext в таких методах рекомендуется, поскольку некоторые контейнеры показывают свои элементы, вызывая этот метод с :compact => true.

См. также 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 Vector{Float64}"

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

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

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

См. также println, string, printstyled.

Примеры

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.

См. также printstyled для добавления цвета и т. д.

Примеры

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, underline::Bool=false, blink::Bool=false, reverse::Bool=false, hidden::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, underline=true, blink=true понятны сами по себе. Ключевое слово reverse=true меняет местами цвета переднего и заднего плана, а hidden=true должно быть невидимым в терминале, но его можно скопировать. Эти свойства можно использовать в любой комбинации.

См. также print, println, show.

sprint(f::Function, args...; context=nothing, sizehint=0)

Вызов заданной функции со входным потоком и дополнительными аргументами. Все, что записывается в этот поток ввода/вывода, возвращается как строка. context может быть IOContext , свойства которого будут использованы, Pair , указывающее на свойство и его значение, или кортеж из Pair , указывающий на несколько свойств и их значений. sizehint указывает на емкость буфера (в байтах).

Необязательный ключевой аргумент context может быть установлен на пару :key=>value, кортеж пар :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 Vector{Int64} at index [100]"

showerror(io, e)

Показать описательное представление объекта исключения e. Этот метод используется для отображения исключения после вызова throw.

Примеры

julia> struct MyException <: Exception
           msg::String
       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 ложно (как по умолчанию), эти символы новой строки удаляются из строки перед её возвращением. Когда 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")

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 Vector{String}:
 "JuliaLang is a GitHub organization."
 "It has many members."

julia> readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "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 будет удален сборщиком мусора.

Чтобы перебрать каждую строку String, можно использовать eachline(IOBuffer(str)).

Примеры

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-типов).

Для настройки способа отображения экземпляров типа, переопределите show, а не display, как описано в разделе руководства по настраиваемой красивой печати.

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::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" определяет тип-синглетон для данной строки mime, что позволяет использовать механизмы диспетчеризации Julia для определения способа отображения объектов любого данного типа.

MIME-тип по умолчанию — MIME"text/plain". Есть резервное определение для вывода в text/plain , которое вызывает show с 2 аргументами, поэтому добавление метода для этого случая не всегда необходимо. Однако, если тип нуждается в настраиваемом удобочитаемом выводе, следует определить show(::IO, ::MIME"text/plain", ::T) . Например, тип Day использует 1 day в качестве вывода для MIME-типа text/plain, и Day(1) в качестве вывода 2-аргументной show.

Типы-контейнеры обычно реализуют 3-аргументную show , вызывая show(io, MIME"text/plain"(), x) для элементов x, с :compact => true установленным в IOContext, переданном в качестве первого аргумента.

showable(mime, x)

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

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

Примеры

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

julia> showable("image/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 Matrix{Int64}:\n 1  2\n 3  4"

MIME

Тип, представляющий стандартный интернет-формат данных. «MIME» расшифровывается как «Многоцелевые расширения интернет-почты», так как стандарт изначально использовался для описания мультимедийных вложений в электронные письма.

Объект 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 REPL.)

istextmime(m::MIME)

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

Примеры

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

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

bytesavailable(io)

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

Примеры

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

julia> bytesavailable(io)
34

ntoh(x)

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

hton(x)

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

ltoh(x)

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

htol(x)

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

ENDIAN_BOM

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