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

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

# Base.stdout — Constant

stdout::IO

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

# Base.stderr — Constant

stderr::IO

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

# Base.stdin — Constant

stdin::IO

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

# Base.open — Method

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(f::Function, command, args...; kwargs...)

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

# Base.open — Method

open(filename::AbstractString; lock = true, keywords...) -> IOStream

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

Ключевое слово Описание По умолчанию

Ключевое слово	Описание	По умолчанию
`read`	открыть для чтения	`!write`
`write`	открыть для записи	`truncate \| append`
`create`	создать, если не существует	`!read & write \| truncate \| append`
`truncate`	обрезать до нулевого размера	`!read & write`
`append`	выполнять поиск до конца	`false`

read

открыть для чтения

!write

write

открыть для записи

truncate | append

create

создать, если не существует

!read & write | truncate | append

truncate

обрезать до нулевого размера

!read & write

append

выполнять поиск до конца

false

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

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

Совместимость: Julia 1.5

Аргумент lock впервые реализован в Julia 1.5.

# Base.open — Method

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

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

Режим Описание Ключевые слова

Режим	Описание	Ключевые слова
`r`	чтение	нет
`w`	чтение, создание, обрезка	`write = true`
`a`	чтение, создание, присоединение	`append = true`
`r+`	чтение, запись	`read = true, write = true`
`w+`	чтение, запись, создание, обрезка	`truncate = true, read = true`
`a+`	чтение, запись, создание, присоединение	`append = true, read = true`

r

чтение

нет

w

чтение, создание, обрезка

write = true

a

чтение, создание, присоединение

append = true

r+

чтение, запись

read = true, write = true

w+

чтение, запись, создание, обрезка

truncate = true, read = true

a+

чтение, запись, создание, присоединение

append = true, read = true

Примеры

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

Совместимость: Julia 1.5

Аргумент lock впервые реализован в Julia 1.5.

# Base.IOStream — Type

IOStream

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

# Base.IOBuffer — Type

IOBuffer([data::AbstractVector{UInt8}]; keywords...) -> IOBuffer

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

Возможно, потребуются необязательные именованные аргументы:

read, write, append: ограничивает операции с буфером; подробные сведения см. в open.
truncate: выполняет обрезку размера буфера до нулевой длины.
maxsize: задает размер, при выходе за пределы которого буфер нельзя будет увеличить.
sizehint: предлагает емкость буфера (data должен реализовать sizehint!(data, size)).

Если data не задан, буфер по умолчанию будет доступен для чтения и записи.

Примеры

julia> io = IOBuffer();

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

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

julia> io = IOBuffer(b"JuliaLang is a GitHub organization.")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=35, maxsize=Inf, ptr=1, mark=-1)

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

julia> write(io, "This isn't writable.")
ERROR: ArgumentError: ensureroom failed, IOBuffer is not writeable

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

julia> write(io, "JuliaLang is a GitHub organization.")
34

julia> String(take!(io))
"JuliaLang is a GitHub organization"

julia> length(read(IOBuffer(b"data", read=true, truncate=false)))
4

julia> length(read(IOBuffer(b"data", read=true, truncate=true)))
0

IOBuffer(string::String)

Создает IOBuffer со свойством «только чтение» для данных, которые являются базовыми для данной строки.

Примеры

julia> io = IOBuffer("Haho");

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

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

# Base.take! — Method

take!(b::IOBuffer)

Получает содержимое IOBuffer в виде массива. После этого IOBuffer сбрасывается до исходного состояния.

Примеры

julia> io = IOBuffer();

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

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

# Base.fdio — Function

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

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

# Base.flush — Function

flush(stream)

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

# Base.close — Function

close(stream)

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

# Base.closewrite — Function

closewrite(stream)

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

Примеры

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

julia> write(io, "request");

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

julia> closewrite(io);

julia> read(io, String)
"request"

# Base.write — Function

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(); # произвольное временное имя файла

julia> open(fname,"w") do f
           # Убедиться в том, что выполняется запись 64-разрядного целочисленного значения в формате прямого порядка следования байтов
           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))

# Base.read — Function

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.

# Base.read! — Function

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

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

# Base.readbytes! — Function

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)

# Base.unsafe_read — Function

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

Выполняет копирование nbytes из объекта потока IO в ref (преобразовывается в адресную ссылку).

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

# Base.unsafe_write — Function

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

Выполняет копирование nbytes из ref (преобразовывается в адресную ссылку) в объект IO.

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

# Base.readeach — Function

readeach(io::IO, T)

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

См. также описание функций skipchars, eachline и readuntil.

Совместимость: Julia 1.6

Для readeach требуется версия не ниже Julia 1.6.

Примеры

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.

# Base.peek — Function

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)

Совместимость: Julia 1.5

Для метода, принимающего тип, требуется версия не ниже Julia 1.5.

# Base.position — Function

position(s)

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

Примеры

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

julia> seek(io, 5);

julia> position(io)
5

julia> skip(io, 10);

julia> position(io)
15

julia> seekend(io);

julia> position(io)
35

# Base.seek — Function

seek(s, pos)

Выполняет поиск по потоку вплоть до достижения данной позиции.

Примеры

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

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)

# Base.seekstart — Function

seekstart(s)

Выполняет поиск по потоку вплоть до достижения его начала.

Примеры

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

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

# Base.seekend — Function

seekend(s)

Выполняет поиск по потоку вплоть до достижения его конца.

# Base.skip — Function

skip(s, offset)

Выполняет поиск по потоку с учетом текущей позиции.

Примеры

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

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (category Lu: Letter, uppercase)

# Base.mark — Function

mark(s::IO)

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

См. также описание функций unmark, reset и ismarked.

# Base.unmark — Function

unmark(s::IO)

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

См. также описание функций mark, reset и ismarked.

# Base.reset — Method

reset(s::IO)

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

См. также описание функций mark, unmark и ismarked.

# Base.ismarked — Function

ismarked(s::IO)

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

См. также описание функций mark, unmark и reset.

# Base.eof — Function

eof(stream) -> Bool

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

Примеры

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

# Base.isreadonly — Function

isreadonly(io) -> Bool

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

Примеры

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

# Base.iswritable — Function

iswritable(io) -> Bool

Возвращает false, если запись в указанный объект ввода-вывода не поддерживается.

Примеры

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

# Base.isreadable — Function

isreadable(io) -> Bool

Возвращает false, если чтение из указанного объекта вывода не поддерживается.

Примеры

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")

# Base.isopen — Function

isopen(object) -> Bool

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

Примеры

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

# Base.fd — Function

fd(stream)

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

# Base.redirect_stdio — Function

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

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

Совместимость: Julia 1.7

Для redirect_stdio требуется версия не ниже Julia 1.7.

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

Совместимость: Julia 1.7

Для redirect_stdio требуется версия не ниже Julia 1.7.

# Base.redirect_stdout — Function

redirect_stdout([stream]) -> stream

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

stream должны быть совместимыми объектами, например IOStream, TTY, Pipe, сокет или devnull.

См. также описание redirect_stdio.

# Base.redirect_stdout — Method

redirect_stdout(f::Function, stream)

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

# Base.redirect_stderr — Function

redirect_stderr([stream]) -> stream

Аналогично redirect_stdout, но для stderr.

stream должны быть совместимыми объектами, например IOStream, TTY, Pipe, сокет или devnull.

См. также описание redirect_stdio.

# Base.redirect_stderr — Method

redirect_stderr(f::Function, stream)

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

# Base.redirect_stdin — Function

redirect_stdin([stream]) -> stream

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

stream должны быть совместимыми объектами, например IOStream, TTY, Pipe, сокет или devnull.

См. также описание redirect_stdio.

# Base.redirect_stdin — Method

redirect_stdin(f::Function, stream)

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

# Base.readchomp — Function

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

# Base.truncate — Function

truncate(file, n)

Изменяет размер файла или буфера, заданный первым аргументом, установив размер ровно n байт, заполнив ранее не выделенное пространство символами \0, если размер файла или буфера увеличен.

Примеры

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.")
35

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

julia> String(take!(io))
"JuliaLang is a "

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.");

julia> truncate(io, 40);

julia> String(take!(io))
"JuliaLang is a GitHub organization.\0\0\0\0\0"

# Base.skipchars — Function

skipchars(predicate, io::IO; linecomment=nothing)

Передает поток io вперед, чтобы следующий считываемый символ был первым из оставшихся; для этого predicate возвращает false. Если именованный аргумент linecomment задан, все символы из этого символа вплоть до начала следующей строки будут игнорироваться.

Примеры

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

julia> skipchars(isspace, buf)
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=5, mark=-1)

julia> String(readavailable(buf))
"text"

# Base.countlines — Function

countlines(io::IO; eol::AbstractChar = '\n')

Выполняет чтение io вплоть до конца потока/файла и подсчитать количество строк. Чтобы указать файл, передайте имя файла как первый аргумент. Маркеры конца строки, отличные от '\n', поддерживаются путем их передачи в виде второго аргумента. Последняя непустая строка в io учитывается, даже если она не заканчивается с концом строки, совпадая по длине со значением, возвращаемым 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

# Base.PipeBuffer — Function

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

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

# Base.readavailable — Function

readavailable(stream)

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

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

# Base.IOContext — Type

IOContext

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

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

# Base.IOContext — Method

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: Type, характеризующий уже напечатанную информацию, относящуюся к типу объекта, который будет отображаться. Это, в частности, полезно при отображении коллекции объектов одного типа, позволяя избежать избыточной информации о типе (например, [Float16(0)] можно отображать как Float16[0.0], а не как Float16[Float16(0.0)]: при отображении элементов массива для свойства :typeinfo будет задано значение Float16).
:color: Логическое указание возможности поддержки/доступности цветового кодирования ANS/кода смены алфавита. По умолчанию это определяется тем, является ли io совместимым терминалом, а также любым

флагом командной строки --color, если запущен julia.

Примеры

julia> io = IOBuffer();

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

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

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

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

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

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

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

# Base.IOContext — Method

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

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

Текстовый ввод-вывод

# Base.show — Method

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) io в таких методах, поскольку некоторые контейнеры отображают элементы путем вызова этого метода с :compact => true.

См. также print, где описываются операции записи недекорированных представлений.

Примеры

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

# Base.summary — Function

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

# Base.print — Function

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

# Base.println — Function

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"

# Base.printstyled — Function

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_white, :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.

Совместимость: Julia 1.7

В Julia 1.7 добавлены ключевые слова за исключением color и bold.

# Base.sprint — Function

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

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

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

Совместимость: Julia 1.7

Для передачи кортежа в именованном аргументе context требуется версия Julia не ниже 1.7.

Примеры

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

# Base.showerror — Function

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

# Base.dump — Function

dump(x; maxdepth=8)

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

Примеры

julia> struct MyStruct
           x
           y
       end

julia> x = MyStruct(1, (2,3));

julia> dump(x)
MyStruct
  x: Int64 1
  y: Tuple{Int64, Int64}
    1: Int64 2
    2: Int64 3

julia> dump(x; maxdepth = 1)
MyStruct
  x: Int64 1
  y: Tuple{Int64, Int64}

# Base.Meta.@dump — Macro

@dump expr

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

# Base.readline — Function

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

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

Примеры

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("Enter your name: ")
Enter your name:

julia> your_name = readline()
Logan
"Logan"

# Base.readuntil — Function

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

Выполняет чтение строки из потока ввода-вывода или файла (до заданного символа-разграничителя). Символ-разграничитель может быть UInt8, AbstractChar, строкой или вектором. Именованный аргумент keep определяет, включается ли символ-разграничитель в результат. Предполагается, что для текста используется кодировка UTF-8.

Примеры

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

# Base.readlines — Function

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

# Base.eachline — Function

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

Совместимость: Julia 1.8

В Julia 1.8 необходимо использовать Iterators.reverse или last с итераторами eachline.

# Base.displaysize — Function

displaysize([io::IO]) -> (lines, columns)

Возвращает номинальный размер экрана, который можно использовать для визуализации вывода в этот объект IO. Если ввод не предоставляется, считываются переменные среды LINES и COLUMNS. Если переменные не заданы, возвращается размер (24, 80) по умолчанию.

Примеры

julia> withenv("LINES" => 30, "COLUMNS" => 100) do
           displaysize()
       end
(30, 100)

Чтобы получить размер TTY,

julia> displaysize(stdout)
(34, 147)

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

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

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

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

# Base.Multimedia.AbstractDisplay — Type

AbstractDisplay

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

# Base.Multimedia.display — Function

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 с текстовым хранилищем, таким как текст HTML или приложение/postscript) или x::Vector{UInt8} (для двоичных типов MIME).

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

# Base.Multimedia.redisplay — Function

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

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

# Base.Multimedia.displayable — Function

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

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

# Base.show — Method

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 с двумя аргументами, поэтому не всегда обязательно добавлять метод для этого случая. Если тип использует настраиваемый человекочитаемый вывод, следует определить show(::IO, ::MIME"text/plain", ::T). Например, тип Day использует 1 day как вывод для типа MIME text/plain, а Day(1) — как вывод двойного аргумента show.

Примеры

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

# Base.Multimedia.showable — Function

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

# Base.repr — Method

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"

# Base.Multimedia.MIME — Type

MIME

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

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

Примеры

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

# Base.Multimedia.@MIME_str — Macro

@MIME_str

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

Как уже говорилось выше, можно также определить новые бэкенды отображения. Например, модуль, который может отображать PNG-изображения в окне, может зарегистрировать эту возможность в Julia, так что при вызове display(x) для типов с PNG-представлениями изображение будет автоматически отображаться в окне модуля.

Чтобы определить новый бэкенд отображения, необходимо сначала создать подтип D абстрактного класса AbstractDisplay. Затем для каждого типа MIME (строки mime), который может быть отображен в D, следует определить функцию display(d::D, ::MIME"mime", x) = ..., которая отображает x как этот тип MIME, обычно путем вызова show(io, mime, x) или repr(io, mime, x). Если x не может быть отображен как данный тип MIME, должна возникнуть ошибка MethodError. Это происходит автоматически при вызове show или repr. Наконец, следует определить функцию display(d::D, x), которая запрашивает showable(mime, x) о типах mime, поддерживаемых D, и выводит лучший из них. Если для x не найдено ни одного поддерживаемого типа MIME, должна возникнуть ошибка MethodError. Аналогичным образом, некоторые подтипы могут переопределять redisplay(d::D, ...). (Опять же, чтобы добавить новые методы для отображения (display), нужно import Base.display.) Возвращаемые значения этих функций зависят от реализации (поскольку в некоторых случаях может быть полезно возвращать «дескриптор» отображения какого-либо типа). Затем функции отображения для D можно вызывать напрямую, но они также могут быть вызваны автоматически из display(x), просто путем отправки нового дисплея в стек бэкендов отображения с помощью соответствующей функции.

# Base.Multimedia.pushdisplay — Function

pushdisplay(d::AbstractDisplay)

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

# Base.Multimedia.popdisplay — Function

popdisplay()
popdisplay(d::AbstractDisplay)

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

# Base.Multimedia.TextDisplay — Type

TextDisplay(io::IO)

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

# Base.Multimedia.istextmime — Function

istextmime(m::MIME)

Определяет, является ли тип MIME тестовыми данными. Предполагается, что типы MIME являются двоичными данными за исключением набора типов, которые заведомо относятся к текстовым данным (возможно, Юникод).

Примеры

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

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

Сетевой ввод-вывод

# Base.bytesavailable — Function

bytesavailable(io)

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

Примеры

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

julia> bytesavailable(io)
34

# Base.ntoh — Function

ntoh(x)

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

# Base.hton — Function

hton(x)

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

# Base.ltoh — Function

ltoh(x)

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

# Base.htol — Function

htol(x)

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

# Base.ENDIAN_BOM — Constant

ENDIAN_BOM

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