I/O and Network

stdout::IO

Variable global que se refiere al flujo de salida estándar.

stderr::IO

Variable global que se refiere al flujo de error estándar.

stdin::IO

Variable global que se refiere al flujo de entrada estándar.

read(filename::AbstractString)

Lee todo el contenido de un archivo como un Vector{UInt8}.

read(filename::AbstractString, String)

Lee todo el contenido de un archivo como una cadena.

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

Abre un archivo y lee su contenido. args se pasa a read: esto es equivalente a open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Escribe la representación binaria canónica de content en un archivo, que se creará si aún no existe o se sobrescribirá si ya existe.

Devuelve el número de bytes escritos en el archivo.

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

Aplica la función f al resultado de open(args...; kwargs...) y cierra el descriptor de archivo resultante al finalizar.

Ejemplos

julia> write("myfile.txt", "¡Hola mundo!");

julia> open(io->read(io, String), "myfile.txt")
"¡Hola mundo!"

julia> rm("myfile.txt")

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

Abre un archivo en un modo especificado por cinco argumentos booleanos de palabra clave:

El predeterminado cuando no se pasan palabras clave es abrir archivos solo para lectura. Devuelve un flujo para acceder al archivo abierto.

El argumento de palabra clave lock controla si las operaciones estarán bloqueadas para un acceso seguro en múltiples hilos.

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

Sintaxis alternativa para open, donde se utiliza un especificador de modo basado en cadenas en lugar de los cinco booleanos. Los valores de mode corresponden a los de fopen(3) o Perl open, y son equivalentes a establecer los siguientes grupos booleanos:

El argumento de palabra clave lock controla si las operaciones estarán bloqueadas para un acceso seguro en múltiples hilos.

Ejemplos

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

julia> write(io, "¡Hola mundo!");

julia> close(io);

julia> io = open("myfile.txt", "r");

julia> read(io, String)
"¡Hola mundo!"

julia> write(io, "Este archivo es solo de lectura")
ERROR: ArgumentError: write failed, IOStream is not writeable
[...]

julia> close(io)

julia> io = open("myfile.txt", "a");

julia> write(io, "Este flujo no es solo de lectura")
28

julia> close(io)

julia> rm("myfile.txt")

open(fd::OS_HANDLE) -> IO

Toma un descriptor de archivo en bruto, envuélvelo en un tipo IO consciente de Julia y toma posesión del manejador fd. Llama a open(Libc.dup(fd)) para evitar la captura de propiedad del manejador original.

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

Ejecuta command de manera asíncrona. Al igual que open(command, stdio; read, write), excepto que se especifican las banderas de lectura y escritura a través de una cadena de modo en lugar de argumentos de palabra clave. Las cadenas de modo posibles son:

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

Comienza a ejecutar command de manera asíncrona y devuelve un objeto process::IO. Si read es verdadero, entonces las lecturas del proceso provienen de la salida estándar del proceso y stdio especifica opcionalmente el flujo de entrada estándar del proceso. Si write es verdadero, entonces las escrituras van al flujo de entrada estándar del proceso y stdio especifica opcionalmente el flujo de salida estándar del proceso. El flujo de error estándar del proceso está conectado al stderr global actual.

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

Similar a open(command, args...; kwargs...), pero llama a f(stream) en el flujo de proceso resultante, luego cierra el flujo de entrada y espera a que el proceso se complete. Devuelve el valor devuelto por f en caso de éxito. Lanza un error si el proceso falla, o si el proceso intenta imprimir algo en stdout.

IOStream

Un flujo de IO con búfer que envuelve un descriptor de archivo del sistema operativo. Principalmente utilizado para representar archivos devueltos por open.

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

Crea un flujo de I/O en memoria, que puede operar opcionalmente sobre un arreglo preexistente.

Puede tomar argumentos de palabra clave opcionales:

• read, write, append: restringe las operaciones al búfer; consulta open para más detalles.
• truncate: trunca el tamaño del búfer a cero.
• maxsize: especifica un tamaño más allá del cual el búfer no puede crecer.
• sizehint: sugiere una capacidad del búfer (data debe implementar sizehint!(data, size)).

Cuando data no se proporciona, el búfer será tanto legible como escribible por defecto.

Ejemplos

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)

Crea un IOBuffer de solo lectura sobre los datos subyacentes de la cadena dada.

Ejemplos

julia> io = IOBuffer("Haho");

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

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

take!(b::IOBuffer)

Obtiene el contenido de un IOBuffer como un arreglo. Después, el IOBuffer se restablece a su estado inicial.

Ejemplos

julia> io = IOBuffer();

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

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

Pipe()

Construye un objeto Pipe no inicializado, especialmente para la comunicación de IO entre múltiples procesos.

El extremo apropiado del pipe se inicializará automáticamente si el objeto se utiliza en la creación de procesos. Esto puede ser útil para obtener fácilmente referencias en tuberías de procesos, por ejemplo:

julia> err = Pipe()

# Después de esto, `err` estará inicializado y podrás leer `foo`'s
# stderr desde el pipe `err`, o pasar `err` a otras tuberías.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# Ahora destruye la mitad de escritura del pipe, para que la mitad de lectura obtenga EOF
julia> closewrite(err)

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

Consulta también Base.link_pipe!.

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

Inicializa pipe y vincula el extremo in al extremo out. Los argumentos de palabra clave reader_supports_async/writer_supports_async corresponden a OVERLAPPED en Windows y O_NONBLOCK en sistemas POSIX. Deben ser true a menos que sean utilizados por un programa externo (por ejemplo, la salida de un comando ejecutado con run).

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

Crea un objeto IOStream a partir de un descriptor de archivo entero. Si own es true, cerrar este objeto cerrará el descriptor subyacente. Por defecto, un IOStream se cierra cuando es recolectado por el recolector de basura. name te permite asociar el descriptor con un archivo nombrado.

flush(stream)

Confirma todas las escrituras actualmente en búfer al flujo dado.

close(stream)

Cierra un flujo de E/S. Realiza un flush primero.

closewrite(stream)

Cierra la mitad de escritura de un flujo de E/S de doble dirección. Realiza un flush primero. Notifica al otro extremo que no se escribirá más datos en el archivo subyacente. Esto no es compatible con todos los tipos de E/S.

Si se implementa, closewrite provoca que las llamadas subsiguientes a read o eof que bloquearían, en su lugar lancen EOF o devuelvan verdadero, respectivamente. Si el flujo ya está cerrado, esto es idempotente.

Ejemplos

julia> io = Base.BufferStream(); # esto nunca bloquea, así que podemos leer y escribir en la misma Tarea

julia> write(io, "request");

julia> # llamar a `read(io)` aquí bloquearía para siempre

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

Escribe la representación binaria canónica de un valor en el flujo de E/S o archivo dado. Devuelve el número de bytes escritos en el flujo. Consulta también print para escribir una representación de texto (con una codificación que puede depender de io).

El orden de bytes del valor escrito depende del orden de bytes del sistema anfitrión. Convierte a/desde un orden de bytes fijo al escribir/leer (por ejemplo, usando htol y ltoh) para obtener resultados que sean consistentes en todas las plataformas.

Puedes escribir múltiples valores con la misma llamada a write. Es decir, lo siguiente es equivalente:

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

Ejemplos

Serialización consistente:

julia> fname = tempname(); # nombre de archivo temporal aleatorio

julia> open(fname,"w") do f
           # Asegúrate de que escribimos un entero de 64 bits en orden de bytes little-endian
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # Convierte de nuevo al orden de bytes del anfitrión y al tipo de entero del anfitrión
           Int(ltoh(read(f,Int64)))
       end
42

Fusionando llamadas a write:

julia> io = IOBuffer();

julia> write(io, "JuliaLang es una organización de GitHub.", " Tiene muchos miembros.")
56

julia> String(take!(io))
"JuliaLang es una organización de GitHub. Tiene muchos miembros."

julia> write(io, "A veces esos miembros") + write(io, " escriben documentación.")
44

julia> String(take!(io))
"A veces esos miembros escriben documentación."

Los tipos de datos simples definidos por el usuario sin métodos write pueden escribirse cuando están envueltos en un Ref:

julia> struct MyStruct; x::Float64; end

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

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

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

read(io::IO, T)

Lee un solo valor del tipo T desde io, en representación binaria canónica.

Ten en cuenta que Julia no convierte el orden de los bytes por ti. Usa ntoh o ltoh para este propósito.

read(io::IO, String)

Lee la totalidad de io, como un String (ver también readchomp).

Ejemplos

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

julia> read(io, Char)
'J': ASCII/Unicode U+004A (categoría Lu: Letra, mayúscula)

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

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

read(filename::AbstractString)

Lee todo el contenido de un archivo como un Vector{UInt8}.

read(filename::AbstractString, String)

Lee todo el contenido de un archivo como una cadena.

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

Abre un archivo y lee su contenido. args se pasa a read: esto es equivalente a open(io->read(io, args...), filename).

read(s::IO, nb=typemax(Int))

Lee como máximo nb bytes de s, devolviendo un Vector{UInt8} de los bytes leídos.

read(s::IOStream, nb::Integer; all=true)

Lee como máximo nb bytes de s, devolviendo un Vector{UInt8} de los bytes leídos.

Si all es true (el valor predeterminado), esta función bloqueará repetidamente intentando leer todos los bytes solicitados, hasta que ocurra un error o se alcance el final del archivo. Si all es false, se realiza como máximo una llamada a read, y la cantidad de datos devueltos depende del dispositivo. Ten en cuenta que no todos los tipos de flujo admiten la opción all.

read(command::Cmd)

Ejecuta command y devuelve la salida resultante como un arreglo de bytes.

read(command::Cmd, String)

Ejecuta command y devuelve la salida resultante como un String.

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

Lee datos binarios de un flujo de E/S o archivo, llenando array.

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

Lee como máximo nb bytes de stream en b, devolviendo el número de bytes leídos. El tamaño de b se incrementará si es necesario (es decir, si nb es mayor que length(b) y se pudieron leer suficientes bytes), pero nunca se reducirá.

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

Lee como máximo nb bytes desde stream en b, devolviendo el número de bytes leídos. El tamaño de b se incrementará si es necesario (es decir, si nb es mayor que length(b) y se pudieron leer suficientes bytes), pero nunca se reducirá.

Si all es true (el valor predeterminado), esta función bloqueará repetidamente intentando leer todos los bytes solicitados, hasta que ocurra un error o se alcance el final del archivo. Si all es false, se realiza como máximo una llamada a read, y la cantidad de datos devueltos depende del dispositivo. Tenga en cuenta que no todos los tipos de flujo admiten la opción all.

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

Copia nbytes del objeto de flujo IO en ref (convertido a un puntero).

Se recomienda que los subtipos T<:IO sobrescriban la siguiente firma de método para proporcionar implementaciones más eficientes: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

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

Copia nbytes de ref (convertido a un puntero) en el objeto IO.

Se recomienda que los subtipos T<:IO sobrescriban la siguiente firma de método para proporcionar implementaciones más eficientes: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

Devuelve un objeto iterable que produce read(io, T).

Véase también skipchars, eachline, readuntil.

Ejemplos

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

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

peek(stream[, T=UInt8])

Lee y devuelve un valor del tipo T de un flujo sin avanzar la posición actual en el flujo. Ver también startswith(stream, char_or_string).

Ejemplos

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (categoría Ll: Letra, minúscula)

position(l::Lexer)

Devuelve la posición actual.

posición(es)

Obtén la posición actual de un flujo.

Ejemplos

julia> io = IOBuffer("JuliaLang es una organización de GitHub.");

julia> seek(io, 5);

julia> position(io)
5

julia> skip(io, 10);

julia> position(io)
15

julia> seekend(io);

julia> position(io)
35

seek(s, pos)

Buscar un flujo en la posición dada.

Ejemplos

julia> io = IOBuffer("JuliaLang es una organización de GitHub.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (categoría Lu: Letra, mayúscula)

seekstart(s)

Busca un flujo hasta su comienzo.

Ejemplos

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

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (categoría Lu: Letra, mayúscula)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (categoría Lu: Letra, mayúscula)

seekend(s)

Buscar un flujo hasta su final.

skip(s, offset)

Buscar en un flujo relativo a la posición actual.

Ejemplos

julia> io = IOBuffer("JuliaLang es una organización de GitHub.");

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (categoría Lu: Letra, mayúscula)

mark(s::IO)

Agrega una marca en la posición actual del flujo s. Devuelve la posición marcada.

Véase también unmark, reset, ismarked.

unmark(s::IO)

Elimina una marca del flujo s. Devuelve true si el flujo estaba marcado, false en caso contrario.

Ver también mark, reset, ismarked.

reset(s::IO)

Restablece un flujo s a una posición marcada previamente y elimina la marca. Devuelve la posición marcada previamente. Lanza un error si el flujo no está marcado.

Véase también mark, unmark, ismarked.

ismarked(s::IO)

Devuelve true si el flujo s está marcado.

Véase también mark, unmark, reset.

eof(stream) -> Bool

Prueba si un flujo de E/S está al final del archivo. Si el flujo aún no se ha agotado, esta función bloqueará para esperar más datos si es necesario, y luego devolverá false. Por lo tanto, siempre es seguro leer un byte después de ver que eof devuelve false. eof devolverá false mientras haya datos en búfer disponibles, incluso si el extremo remoto de una conexión está cerrado.

Ejemplos

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

Determina si un flujo es de solo lectura.

Ejemplos

julia> io = IOBuffer("JuliaLang es una organización de GitHub");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

Devuelve true si los permisos de acceso para la ruta dada permiten la escritura por parte del usuario actual.

Véase también ispath, isexecutable, isreadable.

iswritable(io) -> Bool

Devuelve false si el objeto IO especificado no es escribible.

Ejemplos

julia> open("myfile.txt", "w") do io
           print(io, "¡Hola mundo!");
           iswritable(io)
       end
true

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

julia> rm("myfile.txt")

isreadable(path::String)

Devuelve true si los permisos de acceso para la ruta dada permiten la lectura por parte del usuario actual.

Véase también ispath, isexecutable, iswritable. ```

isreadable(io) -> Bool

Devuelve false si el objeto IO especificado no es legible.

Ejemplos

julia> open("myfile.txt", "w") do io
           print(io, "¡Hola mundo!");
           isreadable(io)
       end
false

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

julia> rm("myfile.txt")

isexecutable(path::String)

Devuelve true si el path dado tiene permisos de ejecución.

Véase también ispath, isreadable, iswritable.

isopen(object) -> Bool

Determina si un objeto - como un flujo o un temporizador - no está cerrado aún. Una vez que un objeto está cerrado, nunca producirá un nuevo evento. Sin embargo, dado que un flujo cerrado puede aún tener datos para leer en su búfer, utiliza eof para verificar la capacidad de leer datos. Usa el paquete FileWatching para ser notificado cuando un flujo pueda ser escribible o legible.

Ejemplos

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

Devuelve el descriptor de archivo que respalda el flujo o archivo. Ten en cuenta que esta función solo se aplica a File y IOStream síncronos, no a ninguno de los flujos asíncronos.

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

Redirigir un subconjunto de los flujos stdin, stderr, stdout. Cada argumento debe ser un IOStream, TTY, Pipe, socket o devnull.

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

Redirige un subconjunto de los flujos stdin, stderr, stdout, llama a f() y restaura cada flujo.

Los valores posibles para cada flujo son:

• nothing indicando que el flujo no debe ser redirigido.
• path::AbstractString redirigiendo el flujo al archivo en path.
• io un IOStream, TTY, Pipe, socket, o devnull.

Ejemplos

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"

Casos extremos

Es posible pasar el mismo argumento a stdout y stderr:

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

Sin embargo, no se admite pasar dos descriptores distintos del mismo archivo.

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

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

julia> redirect_stdio(f, stdout=io1, stderr=io2) # no soportado

Además, el argumento stdin no puede ser el mismo descriptor que stdout o stderr.

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # no soportado

redirect_stdout([stream]) -> stream

Crea un pipe al que se redirigirá toda la salida de nivel C y Julia stdout. Devuelve un flujo que representa los extremos del pipe. Los datos escritos en stdout ahora se pueden leer desde el extremo rd del pipe.

Consulta también redirect_stdio.

redirect_stdout(f::Function, stream)

Ejecuta la función f mientras rediriges stdout a stream. Al finalizar, stdout se restaura a su configuración anterior.

redirect_stderr([stream]) -> stream

Como redirect_stdout, pero para stderr.

Véase también redirect_stdio.

redirect_stderr(f::Function, stream)

Ejecuta la función f mientras redirige stderr a stream. Al finalizar, stderr se restaura a su configuración anterior.

redirect_stdin([stream]) -> stream

Como redirect_stdout, pero para stdin. Tenga en cuenta que la dirección del flujo está invertida.

Véase también redirect_stdio.

redirect_stdin(f::Function, stream)

Ejecuta la función f mientras redirige stdin a stream. Al finalizar, stdin se restaura a su configuración anterior.

readchomp(x)

Lee la totalidad de x como una cadena y elimina un solo salto de línea final si existe. Equivalente a chomp(read(x, String)).

Ejemplos

julia> write("my_file.txt", "JuliaLang es una organización de GitHub.\nTiene muchos miembros.\n");

julia> readchomp("my_file.txt")
"JuliaLang es una organización de GitHub.\nTiene muchos miembros."

julia> rm("my_file.txt");

truncate(file, n)

Redimensiona el archivo o búfer dado por el primer argumento a exactamente n bytes, llenando el espacio previamente no asignado con '\0' si el archivo o búfer se expande.

Ejemplos

julia> io = IOBuffer();

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

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

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

julia> io = IOBuffer();

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

julia> truncate(io, 40);

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

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

Avanza el flujo io de tal manera que el siguiente carácter que se lea será el primero restante para el cual predicate devuelve false. Si se especifica el argumento clave linecomment, se ignoran todos los caracteres desde ese carácter hasta el inicio de la siguiente línea.

Ejemplos

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

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

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

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

Lee io hasta el final del flujo/archivo y cuenta el número de líneas. Para especificar un archivo, pasa el nombre del archivo como el primer argumento. Se admiten marcadores EOL distintos de '\n' pasándolos como el segundo argumento. La última línea no vacía de io se cuenta incluso si no termina con el EOL, coincidiendo con la longitud devuelta por eachline y readlines.

Para contar líneas de un String, se puede usar countlines(IOBuffer(str)).

Ejemplos

julia> io = IOBuffer("JuliaLang es una organización de GitHub.\n");

julia> countlines(io)
1

julia> io = IOBuffer("JuliaLang es una organización de GitHub.");

julia> countlines(io)
1

julia> eof(io) # contar líneas mueve el puntero del archivo
true

julia> io = IOBuffer("JuliaLang es una organización de GitHub.");

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

julia> write("mi_archivo.txt", "JuliaLang es una organización de GitHub.\n")
36

julia> countlines("mi_archivo.txt")
1

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

julia> rm("mi_archivo.txt")

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

Un IOBuffer que permite la lectura y realiza escrituras mediante la adición. No se admite la búsqueda ni la truncación. Consulte IOBuffer para los constructores disponibles. Si se proporciona data, crea un PipeBuffer para operar en un vector de datos, especificando opcionalmente un tamaño más allá del cual el Array subyacente no puede crecer.

readavailable(stream)

Lee los datos en búfer disponibles de un flujo. La entrada/salida real se realiza solo si no se ha almacenado en búfer ningún dato. El resultado es un Vector{UInt8}.

IOContext

IOContext proporciona un mecanismo para pasar configuraciones de salida entre los métodos show.

En resumen, es un diccionario inmutable que es una subclase de IO. Soporta operaciones estándar de diccionario como getindex, y también puede ser utilizado como un flujo de I/O.

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

Crea un IOContext que envuelve un flujo dado, añadiendo los pares key=>value especificados a las propiedades de ese flujo (ten en cuenta que io puede ser en sí mismo un IOContext).

• usa (key => value) in io para ver si esta combinación particular está en el conjunto de propiedades
• usa get(io, key, default) para recuperar el valor más reciente para una clave particular

Las siguientes propiedades son de uso común:

• :compact: Booleano que especifica que los valores deben imprimirse de manera más compacta, por ejemplo, que los números deben imprimirse con menos dígitos. Esto se establece al imprimir elementos de un array. La salida :compact no debe contener saltos de línea.
• :limit: Booleano que especifica que los contenedores deben ser truncados, por ejemplo, mostrando … en lugar de la mayoría de los elementos.
• :displaysize: Un Tuple{Int,Int} que da el tamaño en filas y columnas a utilizar para la salida de texto. Esto se puede usar para anular el tamaño de visualización para funciones llamadas, pero para obtener el tamaño de la pantalla usa la función displaysize.
• :typeinfo: un Type que caracteriza la información ya impresa sobre el tipo del objeto que está a punto de ser mostrado. Esto es principalmente útil al mostrar una colección de objetos del mismo tipo, para que se pueda evitar información de tipo redundante (por ejemplo, [Float16(0)] puede mostrarse como "Float16[0.0]" en lugar de "Float16[Float16(0.0)]": al mostrar los elementos del array, la propiedad :typeinfo se establecerá en Float16).
• :color: Booleano que especifica si se admiten/se esperan códigos de color/escape ANSI. Por defecto, esto se determina por si io es un terminal compatible y por cualquier bandera de línea de comandos --color cuando se lanzó julia.

Ejemplos

julia> io = IOBuffer();

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

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

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

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

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

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

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

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

Crea un IOContext que envuelve un IO alternativo pero hereda las propiedades de context.

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

Escribe una representación de texto de un valor x en el flujo de salida io. Los nuevos tipos T deben sobrecargar show(io::IO, x::T). La representación utilizada por show generalmente incluye formato específico de Julia e información de tipo, y debe ser código Julia que se pueda analizar cuando sea posible.

repr devuelve la salida de show como una cadena.

Para una salida de texto más detallada y legible para humanos para objetos del tipo T, define show(io::IO, ::MIME"text/plain", ::T) además. Se recomienda verificar la clave :compact del IOContext (a menudo verificada como get(io, :compact, false)::Bool) de io en tales métodos, ya que algunos contenedores muestran sus elementos llamando a este método con :compact => true.

Consulta también print, que escribe representaciones no decoradas.

Ejemplos

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

summary(io::IO, x)
str = summary(x)

Imprime en un flujo io, o devuelve una cadena str, dando una breve descripción de un valor. Por defecto, devuelve string(typeof(x)), por ejemplo, Int64.

Para arreglos, devuelve una cadena con información sobre el tamaño y el tipo, por ejemplo, 10-element Array{Int64,1}.

Ejemplos

julia> summary(1)
"Int64"

julia> summary(zeros(2))
"2-element Vector{Float64}"

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

Escribe en io (o en el flujo de salida predeterminado stdout si io no se proporciona) una representación de texto canónica (sin decoración). La representación utilizada por print incluye un formato mínimo y trata de evitar detalles específicos de Julia.

print recurre a llamar a show, por lo que la mayoría de los tipos solo deberían definir show. Define print si tu tipo tiene una representación "plana" separada. Por ejemplo, show muestra cadenas con comillas, y print muestra cadenas sin comillas.

Consulta también println, string, printstyled.

Ejemplos

julia> print("¡Hola Mundo!")
¡Hola Mundo!
julia> io = IOBuffer();

julia> print(io, "Hola", ' ', :Mundo!)

julia> String(take!(io))
"Hola Mundo!"

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

Imprime (usando print) xs en io seguido de una nueva línea. Si io no se proporciona, imprime en el flujo de salida predeterminado stdout.

Véase también printstyled para agregar colores, etc.

Ejemplos

julia> println("Hello, world")
Hello, world

julia> io = IOBuffer();

julia> println(io, "Hello", ',', " world.")

julia> String(take!(io))
"Hello, world.\n"

printstyled([io], xs...; bold::Bool=false, italic::Bool=false, underline::Bool=false, blink::Bool=false, reverse::Bool=false, hidden::Bool=false, color::Union{Symbol,Int}=:normal)

Imprime xs en un color especificado como un símbolo o un entero, opcionalmente en negrita.

La palabra clave color puede tomar cualquiera de los valores :normal, :italic, :default, :bold, :black, :blink, :blue, :cyan, :green, :hidden, :light_black, :light_blue, :light_cyan, :light_green, :light_magenta, :light_red, :light_white, :light_yellow, :magenta, :nothing, :red, :reverse, :underline, :white, o :yellow o un entero entre 0 y 255 inclusive. Ten en cuenta que no todos los terminales soportan 256 colores.

Las palabras clave bold=true, italic=true, underline=true, blink=true son autoexplicativas. La palabra clave reverse=true imprime con los colores de primer plano y fondo intercambiados, y hidden=true debería ser invisible en el terminal pero aún puede ser copiado. Estas propiedades pueden ser utilizadas en cualquier combinación.

Consulta también print, println, show.

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

Llama a la función dada con un flujo de I/O y los argumentos adicionales suministrados. Todo lo escrito en este flujo de I/O se devuelve como una cadena. context puede ser un IOContext cuyas propiedades se utilizarán, un Pair que especifica una propiedad y su valor, o una tupla de Pair que especifica múltiples propiedades y sus valores. sizehint sugiere la capacidad del búfer (en bytes).

El argumento opcional context puede establecerse en un par :key=>value, una tupla de pares :key=>value, o un objeto IO o IOContext cuyas atributos se utilizan para el flujo de I/O pasado a f. El opcional sizehint es un tamaño sugerido (en bytes) para asignar al búfer utilizado para escribir la cadena.

Ejemplos

julia> sprint(show, 66.66666; context=:compact => true)
"66.6667"

julia> sprint(showerror, BoundsError([1], 100))
"BoundsError: attempt to access 1-element Vector{Int64} at index [100]"

showerror(io, e)

Muestra una representación descriptiva de un objeto de excepción e. Este método se utiliza para mostrar la excepción después de una llamada a throw.

Ejemplos

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("excepción de prueba")
MyException("excepción de prueba")

julia> sprint(showerror, err)
"MyException: excepción de prueba"

julia> throw(MyException("excepción de prueba"))
ERROR: MyException: excepción de prueba

dump(x; maxdepth=8)

Muestra cada parte de la representación de un valor. La profundidad de la salida se trunca en maxdepth.

Ejemplos

julia> struct MyStruct
           x
           y
       end

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

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

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

@dump expr

Muestra cada parte de la representación de la expresión dada. Equivalente a dump(:(expr)).

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

Lee una sola línea de texto del flujo de I/O o archivo dado (por defecto es stdin). Al leer de un archivo, se asume que el texto está codificado en UTF-8. Las líneas en la entrada terminan con '\n' o "\r\n" o el final de un flujo de entrada. Cuando keep es falso (como lo es por defecto), estos caracteres de nueva línea al final se eliminan de la línea antes de que se devuelva. Cuando keep es verdadero, se devuelven como parte de la línea.

Devuelve un String. Véase también copyline para escribir en su lugar en otro flujo (que puede ser un IOBuffer preasignado).

Véase también readuntil para leer hasta delimitadores más generales.

Ejemplos

julia> write("my_file.txt", "JuliaLang es una organización de GitHub.\nTiene muchos miembros.\n");

julia> readline("my_file.txt")
"JuliaLang es una organización de GitHub."

julia> readline("my_file.txt", keep=true)
"JuliaLang es una organización de GitHub.\n"

julia> rm("my_file.txt")

julia> print("Introduce tu nombre: ")
Introduce tu nombre:

julia> your_name = readline()
Logan
"Logan"

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

Lee una cadena de un stream de E/S o de un archivo, hasta el delimitador dado. El delimitador puede ser un UInt8, AbstractChar, cadena o vector. El argumento clave keep controla si el delimitador se incluye en el resultado. Se asume que el texto está codificado en UTF-8.

Devuelve un String si delim es un AbstractChar o una cadena, o de lo contrario devuelve un Vector{typeof(delim)}. Véase también copyuntil para escribir en su lugar en otro stream (que puede ser un IOBuffer preasignado).

Ejemplos

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

julia> readuntil("my_file.txt", 'L')
"Julia"

julia> readuntil("my_file.txt", '.', keep = true)
"JuliaLang is a GitHub organization."

julia> rm("my_file.txt")

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

Lee todas las líneas de un flujo de I/O o de un archivo como un vector de cadenas. El comportamiento es equivalente a guardar el resultado de leer readline repetidamente con los mismos argumentos y guardar las líneas resultantes como un vector de cadenas. Véase también eachline para iterar sobre las líneas sin leerlas todas a la vez.

Ejemplos

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

julia> readlines("my_file.txt")
2-element Vector{String}:
 "JuliaLang is a GitHub organization."
 "It has many members."

julia> readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "JuliaLang is a GitHub organization.\n"
 "It has many members.\n"

julia> rm("my_file.txt")

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

Crea un objeto iterable EachLine que generará cada línea de un flujo de E/S o un archivo. La iteración llama a readline en el argumento de flujo repetidamente con keep pasado, determinando si se retienen los caracteres de fin de línea al final. Cuando se llama con un nombre de archivo, el archivo se abre una vez al comienzo de la iteración y se cierra al final. Si la iteración se interrumpe, el archivo se cerrará cuando el objeto EachLine sea recolectado por el garbage collector.

Para iterar sobre cada línea de un String, se puede usar eachline(IOBuffer(str)).

Iterators.reverse se puede usar en un objeto EachLine para leer las líneas en orden inverso (para archivos, buffers y otros flujos de E/S que admiten seek), y first o last se pueden usar para extraer las líneas iniciales o finales, respectivamente.

Ejemplos

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

julia> for line in eachline("my_file.txt")
           print(line)
       end
JuliaLang is a GitHub organization. It has many members.

julia> rm("my_file.txt");

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

Copia una sola línea de texto de un stream de I/O o de un archivo al stream de out, devolviendo out.

Al leer de un archivo, se asume que el texto está codificado en UTF-8. Las líneas en la entrada terminan con '\n' o "\r\n" o el final de un stream de entrada. Cuando keep es falso (como lo es por defecto), estos caracteres de nueva línea al final se eliminan de la línea antes de que se devuelva. Cuando keep es verdadero, se devuelven como parte de la línea.

Similar a readline, que devuelve un String; en contraste, copyline escribe directamente en out, sin asignar una cadena. (Esto se puede usar, por ejemplo, para leer datos en un IOBuffer preasignado.)

Consulta también copyuntil para leer hasta delimitadores más generales.

Ejemplos

julia> write("my_file.txt", "JuliaLang es una organización de GitHub.\nTiene muchos miembros.\n");

julia> String(take!(copyline(IOBuffer(), "my_file.txt")))
"JuliaLang es una organización de GitHub."

julia> String(take!(copyline(IOBuffer(), "my_file.txt", keep=true)))
"JuliaLang es una organización de GitHub.\n"

julia> rm("my_file.txt")

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

Copia una cadena de un `stream` de I/O o de un archivo, hasta el delimitador dado, al stream `out`, devolviendo `out`. El delimitador puede ser un `UInt8`, `AbstractChar`, cadena o vector. El argumento clave `keep` controla si el delimitador se incluye en el resultado. Se asume que el texto está codificado en UTF-8.

Similar a [`readuntil`](@ref), que devuelve un `String`; en contraste, `copyuntil` escribe directamente en `out`, sin asignar una cadena. (Esto se puede usar, por ejemplo, para leer datos en un [`IOBuffer`](@ref) preasignado.)

# Ejemplos

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

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

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

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

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

Devuelve el tamaño nominal de la pantalla que puede ser utilizada para renderizar la salida a este objeto IO. Si no se proporciona ninguna entrada, se leen las variables de entorno LINES y COLUMNS. Si no están configuradas, se devuelve un tamaño predeterminado de (24, 80).

Ejemplos

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

Para obtener el tamaño de tu TTY,

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

Supertipo abstracto para dispositivos de salida de visualización rica. TextDisplay es un subtipo de esto.

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

Muestra x utilizando la visualización más aplicable en la pila de visualización, típicamente usando la salida multimedia más rica soportada para x, con salida de texto plano stdout como respaldo. La variante display(d, x) intenta mostrar x solo en la visualización dada d, lanzando un MethodError si d no puede mostrar objetos de este tipo.

En general, no puedes asumir que la salida de display va a stdout (a diferencia de print(x) o show(x)). Por ejemplo, display(x) puede abrir una ventana separada con una imagen. display(x) significa "muestra x de la mejor manera que puedas para el(los) dispositivo(s) de salida actuales." Si deseas una salida de texto similar a REPL que esté garantizada para ir a stdout, usa show(stdout, "text/plain", x) en su lugar.

También hay dos variantes con un argumento mime (una cadena de tipo MIME, como "image/png"), que intentan mostrar x utilizando el tipo MIME solicitado solo, lanzando un MethodError si este tipo no es soportado ni por la(s) visualización(es) ni por x. Con estas variantes, también se puede proporcionar los datos "crudos" en el tipo MIME solicitado pasando x::AbstractString (para tipos MIME con almacenamiento basado en texto, como text/html o application/postscript) o x::Vector{UInt8} (para tipos MIME binarios).

Para personalizar cómo se muestran las instancias de un tipo, sobrecarga show en lugar de display, como se explica en la sección del manual sobre impresión bonita personalizada.

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

Por defecto, las funciones redisplay simplemente llaman a display. Sin embargo, algunos backends de visualización pueden anular redisplay para modificar una visualización existente de x (si la hay). Usar redisplay también es una pista para el backend de que x puede ser visualizado varias veces, y el backend puede optar por diferir la visualización hasta (por ejemplo) el siguiente aviso interactivo.

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

Devuelve un valor booleano que indica si el tipo mime dado (cadena) es mostrable por cualquiera de los displays en la pila de displays actual, o específicamente por el display d en la segunda variante.

show(io::IO, mime, x)

Las funciones display llaman en última instancia a show para escribir un objeto x como un tipo mime dado en un flujo de E/S io (generalmente un búfer de memoria), si es posible. Para proporcionar una representación multimedia rica de un tipo definido por el usuario T, solo es necesario definir un nuevo método show para T, a través de: show(io, ::MIME"mime", x::T) = ..., donde mime es una cadena de tipo MIME y el cuerpo de la función llama a write (o similar) para escribir esa representación de x en io. (Tenga en cuenta que la notación MIME"" solo admite cadenas literales; para construir tipos MIME de manera más flexible, use MIME{Symbol("")}.)

Por ejemplo, si define un tipo MyImage y sabe cómo escribirlo en un archivo PNG, podría definir una función show(io, ::MIME"image/png", x::MyImage) = ... para permitir que sus imágenes se muestren en cualquier AbstractDisplay capaz de PNG (como IJulia). Como de costumbre, asegúrese de import Base.show para agregar nuevos métodos a la función incorporada de Julia show.

Técnicamente, la macro MIME"mime" define un tipo singleton para la cadena mime dada, lo que nos permite aprovechar los mecanismos de despacho de Julia para determinar cómo mostrar objetos de cualquier tipo dado.

El tipo MIME predeterminado es MIME"text/plain". Hay una definición de respaldo para la salida text/plain que llama a show con 2 argumentos, por lo que no siempre es necesario agregar un método para ese caso. Sin embargo, si un tipo se beneficia de una salida personalizada legible por humanos, se debe definir show(::IO, ::MIME"text/plain", ::T). Por ejemplo, el tipo Day utiliza 1 day como salida para el tipo MIME text/plain, y Day(1) como salida de show de 2 argumentos.

Ejemplos

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

Los tipos contenedores generalmente implementan show de 3 argumentos llamando a show(io, MIME"text/plain"(), x) para los elementos x, con :compact => true establecido en un IOContext pasado como el primer argumento.

showable(mime, x)

Devuelve un valor booleano que indica si el objeto x se puede escribir como el tipo mime dado.

(Por defecto, esto se determina automáticamente por la existencia del método correspondiente show para typeof(x). Algunos tipos proporcionan métodos showable personalizados; por ejemplo, si los formatos MIME disponibles dependen del valor de x.)

Ejemplos

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

julia> showable("image/png", rand(5))
false

repr(mime, x; context=nothing)

Devuelve un AbstractString o Vector{UInt8} que contiene la representación de x en el tipo mime solicitado, tal como lo escribe show(io, mime, x) (lanzando un MethodError si no hay un show apropiado disponible). Se devuelve un AbstractString para tipos MIME con representaciones textuales (como "text/html" o "application/postscript"), mientras que los datos binarios se devuelven como Vector{UInt8}. (La función istextmime(mime) devuelve si Julia trata un tipo mime dado como texto.)

El argumento de palabra clave opcional context se puede establecer como un par :key=>value o un objeto IO o IOContext cuyas atributos se utilizan para el flujo de I/O pasado a show.

Como caso especial, si x es un AbstractString (para tipos MIME textuales) o un Vector{UInt8} (para tipos MIME binarios), la función repr asume que x ya está en el formato mime solicitado y simplemente devuelve x. Este caso especial no se aplica al tipo MIME "text/plain". Esto es útil para que los datos en bruto se puedan pasar a display(m::MIME, x).

En particular, repr("text/plain", x) es típicamente una versión "bien formateada" de x diseñada para el consumo humano. Véase también repr(x) para devolver en su lugar una cadena correspondiente a show(x) que puede estar más cerca de cómo se ingresaría el valor de x en Julia.

Ejemplos

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

julia> repr("text/plain", A)
"2×2 Matrix{Int64}:\n 1  2\n 3  4"

MIME

Un tipo que representa un formato de datos estándar de internet. "MIME" significa "Extensiones de Correo de Internet Multipropósito", ya que el estándar se utilizó originalmente para describir archivos multimedia adjuntos a mensajes de correo electrónico.

Un objeto MIME se puede pasar como el segundo argumento a show para solicitar la salida en ese formato.

Ejemplos

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

@MIME_str

Una macro de conveniencia para escribir tipos de MIME, típicamente utilizada al agregar métodos a show. Por ejemplo, la sintaxis show(io::IO, ::MIME"text/html", x::MyType) = ... podría usarse para definir cómo escribir una representación HTML de MyType.

pushdisplay(d::AbstractDisplay)

Empuja una nueva pantalla d en la parte superior de la pila de backend de visualización global. Llamar a display(x) o display(mime, x) mostrará x en el backend compatible más alto en la pila (es decir, el backend más alto que no lanza un MethodError).

popdisplay()
popdisplay(d::AbstractDisplay)

Desapila el backend superior de la pila de backend de visualización, o la copia superior de d en la segunda variante.

TextDisplay(io::IO)

Devuelve un TextDisplay <: AbstractDisplay, que muestra cualquier objeto como el tipo MIME text/plain (por defecto), escribiendo la representación de texto en el flujo de I/O dado. (Así es como se imprimen los objetos en el REPL de Julia.)

istextmime(m::MIME)

Determina si un tipo MIME es datos de texto. Se asume que los tipos MIME son datos binarios, excepto por un conjunto de tipos que se sabe que son datos de texto (posiblemente Unicode).

Ejemplos

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

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

bytesavailable(io)

Devuelve el número de bytes disponibles para leer antes de que una lectura de este flujo o búfer bloquee.

Ejemplos

julia> io = IOBuffer("JuliaLang es una organización de GitHub");

julia> bytesavailable(io)
34

ntoh(x)

Convierte el orden de bytes de un valor del orden de bytes de red (big-endian) al que utiliza el host.

hton(x)

Convierte el orden de bytes de un valor del utilizado por el Host al orden de bytes de Red (big-endian).

ltoh(x)

Convierte el orden de bytes de un valor de Little-endian al utilizado por el Host.

htol(x)

Convierte el orden de bytes de un valor del utilizado por el Host a Little-endian.

ENDIAN_BOM

El marcador de orden de bytes de 32 bits indica el orden de bytes nativo de la máquina anfitriona. Las máquinas little-endian contendrán el valor 0x04030201. Las máquinas big-endian contendrán el valor 0x01020304.