I/O and Network

stdout::IO

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

stderr::IO

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

stdin::IO

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

read(filename::AbstractString)

Читает все содержимое файла как Vector{UInt8}.

read(filename::AbstractString, String)

Читает все содержимое файла как строку.

read(filename::AbstractString, args...)

Открывает файл и читает его содержимое. args передается в read: это эквивалентно open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Запишите каноническое двоичное представление content в файл, который будет создан, если он еще не существует, или перезаписан, если он существует.

Возвращает количество байт, записанных в файл.

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

Примените функцию f к результату open(args...; kwargs...) и закройте полученный дескриптор файла по завершении.

Примеры

julia> write("myfile.txt", "Hello world!");

julia> open(io->read(io, 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 истинно, то чтение из процесса происходит из стандартного вывода процесса, а stdio опционально указывает стандартный поток ввода процесса. Если write истинно, то записи идут в стандартный ввод процесса, а 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."

Pipe()

Создайте неинициализированный объект Pipe, особенно для IO-коммуникации между несколькими процессами.

Соответствующий конец трубы будет автоматически инициализирован, если объект используется при создании процесса. Это может быть полезно для легкого получения ссылок в процессных конвейерах, например:

julia> err = Pipe()

# После этого `err` будет инициализирован, и вы сможете читать `foo`'s
# stderr из трубы `err`, или передать `err` в другие конвейеры.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# Теперь уничтожьте запись половину трубы, чтобы чтение половина получила EOF
julia> closewrite(err)

julia> read(err, String)
"stderr messages"

Смотрите также Base.link_pipe!.

link_pipe!(pipe; reader_supports_async=false, writer_supports_async=false)

Инициализируйте pipe и свяжите конечную точку in с конечной точкой out. Ключевые аргументы reader_supports_async/writer_supports_async соответствуют OVERLAPPED в Windows и O_NONBLOCK в системах POSIX. Они должны быть true, если не будут использоваться внешней программой (например, выводом команды, выполненной с помощью run).

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

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

flush(stream)

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

close(stream)

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

closewrite(stream)

Закрывает запись в двунаправленном I/O потоке. Сначала выполняет flush. Уведомляет другую сторону о том, что больше данных не будет записано в основной файл. Это не поддерживается всеми типами ввода-вывода.

Если реализовано, closewrite приводит к тому, что последующие вызовы read или eof, которые блокировали бы выполнение, вместо этого выбрасывают EOF или возвращают true соответственно. Если поток уже закрыт, это идемпотентно.

Примеры

julia> io = Base.BufferStream(); # это никогда не блокирует, поэтому мы можем читать и записывать в одном Task

julia> write(io, "request");

julia> # вызов `read(io)` здесь заблокировал бы выполнение навсегда

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

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

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

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

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

Примеры

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

julia> fname = tempname(); # случайное временное имя файла

julia> open(fname,"w") do f
           # Убедитесь, что мы записываем 64-битное целое число в порядке байтов little-endian
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # Преобразуйте обратно в порядок байтов хоста и тип целого числа хоста
           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 (категория Lu: Буква, заглавная)

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

julia> read(io, String)
"JuliaLang is a GitHub organization"

read(filename::AbstractString)

Читает все содержимое файла как Vector{UInt8}.

read(filename::AbstractString, String)

Читает все содержимое файла как строку.

read(filename::AbstractString, args...)

Открывает файл и читает его содержимое. args передается в read: это эквивалентно open(io->read(io, args...), filename).

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 из потока, не продвигая текущую позицию в потоке. См. также startswith(stream, char_or_string).

Примеры

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (категория Ll: буква, строчная)

position(l::Lexer)

Возвращает текущее положение.

позиция(и)

Получите текущую позицию потока.

Примеры

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 (категория Lu: Буква, заглавная)

seekstart(s)

Переместить поток в его начало.

Примеры

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

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (категория Lu: Буква, заглавная)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (категория Lu: Буква, заглавная)

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 (категория Lu: Буква, заглавная)

mark(s::IO)

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

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

unmark(s::IO)

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

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

reset(s::IO)

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

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

ismarked(s::IO)

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

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

eof(stream) -> Bool

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

Примеры

julia> b = IOBuffer("my buffer");

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

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

Примеры

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

Возвращает true, если права доступа для данного path разрешают запись текущему пользователю.

См. также ispath, isexecutable, isreadable.

iswritable(io) -> Bool

Возвращает false, если указанный объект 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(path::String)

Возвращает true, если права доступа для данного path разрешают чтение текущим пользователем.

См. также ispath, isexecutable, iswritable.

isreadable(io) -> Bool

Возвращает false, если указанный объект 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")

isexecutable(path::String)

Возвращает true, если указанный path имеет разрешения на выполнение.

См. также ispath, isreadable, iswritable.

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) # не поддерживается

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

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # не поддерживается

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> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

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')
countlines(filename::AbstractString; 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) # подсчет строк перемещает указатель файла
true

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

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

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\n")
36

julia> countlines("my_file.txt")
1

julia> countlines("my_file.txt", eol = 'n')
4

julia> rm("my_file.txt")

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

Ан 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: кортеж Tuple{Int,Int}, задающий размер в строках и столбцах для текстового вывода. Это можно использовать для переопределения размера отображения для вызываемых функций, но для получения размера экрана используйте функцию displaysize.
• :typeinfo: тип, характеризующий информацию, уже напечатанную о типе объекта, который собираются отображать. Это в основном полезно при отображении коллекции объектов одного типа, чтобы избежать избыточной информации о типе (например, [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 (часто проверяется как get(io, :compact, false)::Bool) в таких методах, так как некоторые контейнеры показывают свои элементы, вызывая этот метод с :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, за которым следует новая строка. Если 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, italic::Bool=false, underline::Bool=false, blink::Bool=false, reverse::Bool=false, hidden::Bool=false, color::Union{Symbol,Int}=:normal)

Выводит xs в цвете, указанном в виде символа или целого числа, опционально выделяя жирным шрифтом.

Ключевое слово color может принимать любое из значений :normal, :italic, :default, :bold, :black, :blink, :blue, :cyan, :green, :hidden, :light_black, :light_blue, :light_cyan, :light_green, :light_magenta, :light_red, :light_white, :light_yellow, :magenta, :nothing, :red, :reverse, :underline, :white или :yellow, или целое число от 0 до 255 включительно. Обратите внимание, что не все терминалы поддерживают 256 цветов.

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

Возвращает String. Смотрите также copyline, чтобы вместо этого записать на месте в другой поток (который может быть предварительно выделенным IOBuffer).

Смотрите также readuntil для чтения до более общих разделителей.

Примеры

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

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

julia> print("Введите ваше имя: ")
Введите ваше имя:

julia> your_name = readline()
Логан
"Логан"

readuntil(stream::IO, delim; keep::Bool = false)
readuntil(filename::AbstractString, delim; keep::Bool = false)

Читает строку из потока ввода-вывода stream или файла до указанного разделителя. Разделитель может быть UInt8, AbstractChar, строкой или вектором. Ключевой аргумент keep управляет тем, включен ли разделитель в результат. Предполагается, что текст закодирован в UTF-8.

Возвращает String, если delim является AbstractChar или строкой, в противном случае возвращает Vector{typeof(delim)}. См. также copyuntil, чтобы вместо этого записать на месте в другой поток (который может быть предварительно выделенным IOBuffer).

Примеры

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

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 многократно с теми же аргументами и сохранению полученных строк в виде вектора строк. См. также eachline, чтобы итерироваться по строкам, не читая их все сразу.

Примеры

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

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

Iterators.reverse можно использовать на объекте EachLine, чтобы читать строки в обратном порядке (для файлов, буферов и других потоков ввода/вывода, поддерживающих seek), а first или last можно использовать для извлечения начальных или конечных строк соответственно.

Примеры

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\n It has many members.\n");

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

copyline(out::IO, io::IO=stdin; keep::Bool=false)
copyline(out::IO, filename::AbstractString; keep::Bool=false)

Скопируйте одну строку текста из потока ввода/вывода `stream` или файла в поток `out`, возвращая `out`.

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

Похоже на [`readline`](@ref), который возвращает `String`; в отличие от этого, `copyline` записывает непосредственно в `out`, не выделяя строку. (Это можно использовать, например, для чтения данных в предварительно выделенный [`IOBuffer`](@ref).)

Смотрите также [`copyuntil`](@ref) для чтения до более общих разделителей.

# Примеры

jldoctest julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyline(IOBuffer(), "my_file.txt"))) "JuliaLang is a GitHub organization."

julia> String(take!(copyline(IOBuffer(), "my_file.txt", keep=true))) "JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt") ```

copyuntil(out::IO, stream::IO, delim; keep::Bool = false)
copyuntil(out::IO, filename::AbstractString, delim; keep::Bool = false)

Копирует строку из I/O stream или файла до указанного разделителя в поток out, возвращая out. Разделитель может быть UInt8, AbstractChar, строкой или вектором. Ключевой аргумент keep управляет тем, включен ли разделитель в результат. Предполагается, что текст закодирован в UTF-8.

Похоже на readuntil, который возвращает String; в отличие от этого, copyuntil записывает непосредственно в out, не выделяя строку. (Это можно использовать, например, для чтения данных в предварительно выделенный IOBuffer.)

Примеры

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", 'L')))
"Julia"

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", '.', keep = true)))
"JuliaLang is a GitHub organization."

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)

Отобразите 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) = ..., чтобы ваши изображения могли отображаться на любом AbstractDisplay, поддерживающем 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) — в качестве вывода для show с 2 аргументами.

Примеры

julia> struct Day
           n::Int
       end

julia> Base.show(io::IO, ::MIME"text/plain", d::Day) = print(io, d.n, " day")

julia> Day(1)
1 day

Контейнерные типы обычно реализуют show с 3 аргументами, вызывая 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)

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

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

В качестве особого случая, если x является AbstractString (для текстовых MIME-типов) или Vector{UInt8} (для двоичных MIME-типов), функция repr предполагает, что x уже находится в запрашиваемом формате mime и просто возвращает x. Этот особый случай не применяется к MIME-типу "text/plain". Это полезно, чтобы необработанные данные могли быть переданы в display(m::MIME, x).

В частности, repr("text/plain", x) обычно является "красиво напечатанной" версией x, предназначенной для восприятия человеком. См. также repr(x), чтобы вместо этого вернуть строку, соответствующую show(x), которая может быть ближе к тому, как значение x будет введено в Julia.

Примеры

julia> A = [1 2; 3 4];

julia> repr("text/plain", A)
"2×2 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 (по умолчанию), записывая текстовое представление в данный поток ввода/вывода. (Так объекты выводятся в REPL Julia.)

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)

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

htol(x)

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

ENDIAN_BOM

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