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

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

# Base.stdoutConstant

stdout::IO

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

# Base.stderrConstant

stderr::IO

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

# Base.stdinConstant

stdin::IO

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

# Base.openMethod

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

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

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

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

read

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

!write

write

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

truncate | append

create

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

!read & write | truncate | append

truncate

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

!read & write

append

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

false

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

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

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

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

# Base.openMethod

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

Именованный аргумент 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")
Совместимость: Julia 1.5

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

# Base.IOStreamType

IOStream

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

# Base.IOBufferType

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

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

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

# Base.flushFunction

flush(stream)

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

# Base.closeFunction

close(stream)

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

# Base.closewriteFunction

closewrite(stream)

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

Примеры

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

julia> write(io, "request");

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

julia> closewrite(io);

julia> read(io, String)
"request"

# Base.writeFunction

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

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)

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

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

# Base.unsafe_readFunction

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

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

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

# Base.unsafe_writeFunction

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

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

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

# Base.readeachFunction

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

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

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

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

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

seekend(s)

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

# Base.skipFunction

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

mark(s::IO)

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

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

# Base.unmarkFunction

unmark(s::IO)

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

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

# Base.resetMethod

reset(s::IO)

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

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

# Base.ismarkedFunction

ismarked(s::IO)

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

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

# Base.eofFunction

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

isreadonly(io) -> Bool

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

Примеры

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

# Base.iswritableFunction

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

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

isopen(object) -> Bool

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

Примеры

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

# Base.fdFunction

fd(stream)

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

# Base.redirect_stdioFunction

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_stdoutFunction

redirect_stdout([stream]) -> stream

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

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

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

# Base.redirect_stdoutMethod

redirect_stdout(f::Function, stream)

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

# Base.redirect_stderrFunction

redirect_stderr([stream]) -> stream

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

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

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

# Base.redirect_stderrMethod

redirect_stderr(f::Function, stream)

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

# Base.redirect_stdinFunction

redirect_stdin([stream]) -> stream

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

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

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

# Base.redirect_stdinMethod

redirect_stdin(f::Function, stream)

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

# Base.readchompFunction

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

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

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

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

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

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

# Base.readavailableFunction

readavailable(stream)

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

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

# Base.IOContextType

IOContext

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

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

# Base.IOContextMethod

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

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

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

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

# Base.showMethod

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

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

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

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

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

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

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

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.@dumpMacro

@dump expr

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

# Base.readlineFunction

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

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

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

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

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

AbstractDisplay

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

# Base.Multimedia.displayFunction

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

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

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

# Base.Multimedia.displayableFunction

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

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

# Base.showMethod

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

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

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

MIME

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

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

Примеры

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

# Base.Multimedia.@MIME_strMacro

@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.pushdisplayFunction

pushdisplay(d::AbstractDisplay)

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

# Base.Multimedia.popdisplayFunction

popdisplay()
popdisplay(d::AbstractDisplay)

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

# Base.Multimedia.TextDisplayType

TextDisplay(io::IO)

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

# Base.Multimedia.istextmimeFunction

istextmime(m::MIME)

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

Примеры

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

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

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

# Base.bytesavailableFunction

bytesavailable(io)

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

Примеры

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

julia> bytesavailable(io)
34

# Base.ntohFunction

ntoh(x)

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

# Base.htonFunction

hton(x)

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

# Base.ltohFunction

ltoh(x)

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

# Base.htolFunction

htol(x)

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

# Base.ENDIAN_BOMConstant

ENDIAN_BOM

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