I/O and Network

stdout::IO

Variable globale faisant référence au flux de sortie standard.

stderr::IO

Variable globale faisant référence au flux d'erreur standard.

stdin::IO

Variable globale faisant référence au flux d'entrée standard.

read(filename::AbstractString)

Lire le contenu entier d'un fichier sous forme de Vector{UInt8}.

read(filename::AbstractString, String)

Lire le contenu entier d'un fichier sous forme de chaîne.

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

Ouvrir un fichier et lire son contenu. args est passé à read : cela équivaut à open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Écrit la représentation binaire canonique de content dans un fichier, qui sera créé s'il n'existe pas encore ou écrasé s'il existe.

Retourne le nombre d'octets écrits dans le fichier.

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

Applique la fonction f au résultat de open(args...; kwargs...) et ferme le descripteur de fichier résultant à la fin.

Exemples

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

julia> open(io->read(io, String), "myfile.txt")
"Hello world!"

julia> rm("myfile.txt")

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

Ouvrir un fichier dans un mode spécifié par cinq arguments de mot-clé booléens :

La valeur par défaut lorsque aucun mot-clé n'est passé est d'ouvrir les fichiers uniquement pour la lecture. Renvoie un flux pour accéder au fichier ouvert.

L'argument de mot-clé lock contrôle si les opérations seront verrouillées pour un accès multi-threadé sécurisé.

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

Syntaxe alternative pour open, où un spécificateur de mode basé sur une chaîne est utilisé au lieu des cinq booléens. Les valeurs de mode correspondent à celles de fopen(3) ou de Perl open, et sont équivalentes à la définition des groupes booléens suivants :

L'argument clé lock contrôle si les opérations seront verrouillées pour un accès multi-threadé sécurisé.

Exemples

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

julia> write(io, "Hello world!");

julia> close(io);

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

julia> read(io, String)
"Hello world!"

julia> write(io, "This file is read only")
ERROR: ArgumentError: write failed, IOStream is not writeable
[...]

julia> close(io)

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

julia> write(io, "This stream is not read only")
28

julia> close(io)

julia> rm("myfile.txt")

open(fd::OS_HANDLE) -> IO

Prenez un descripteur de fichier brut, enveloppez-le dans un type IO conscient de Julia et prenez possession de la poignée fd. Appelez open(Libc.dup(fd)) pour éviter la capture de possession de la poignée originale.

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

Exécute command de manière asynchrone. Comme open(command, stdio; read, write) sauf qu'il spécifie les indicateurs de lecture et d'écriture via une chaîne de mode au lieu d'arguments de mot-clé. Les chaînes de mode possibles sont :

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

Commencez à exécuter command de manière asynchrone et renvoyez un objet process::IO. Si read est vrai, alors les lectures du processus proviennent de la sortie standard du processus et stdio spécifie éventuellement le flux d'entrée standard du processus. Si write est vrai, alors les écritures vont au flux d'entrée standard du processus et stdio spécifie éventuellement le flux de sortie standard du processus. Le flux d'erreur standard du processus est connecté à l'stderr global actuel.

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

Semblable à open(command, args...; kwargs...), mais appelle f(stream) sur le flux de processus résultant, puis ferme le flux d'entrée et attend que le processus se termine. Retourne la valeur renvoyée par f en cas de succès. Lève une erreur si le processus échoue, ou si le processus tente d'imprimer quoi que ce soit sur stdout.

IOStream

Un flux d'E/S tamponné enveloppant un descripteur de fichier du système d'exploitation. Principalement utilisé pour représenter des fichiers retournés par open.

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

Créez un flux d'E/S en mémoire, qui peut éventuellement fonctionner sur un tableau préexistant.

Il peut prendre des arguments de mot-clé optionnels :

• read, write, append : restreint les opérations au tampon ; voir open pour plus de détails.
• truncate : tronque la taille du tampon à une longueur nulle.
• maxsize : spécifie une taille au-delà de laquelle le tampon ne peut pas être agrandi.
• sizehint : suggère une capacité du tampon (data doit implémenter sizehint!(data, size)).

Lorsque data n'est pas donné, le tampon sera à la fois lisible et inscriptible par défaut.

Exemples

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)

Crée un IOBuffer en lecture seule sur les données sous-jacentes de la chaîne donnée.

Exemples

julia> io = IOBuffer("Haho");

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

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

take!(b::IOBuffer)

Obtenez le contenu d'un IOBuffer sous forme de tableau. Ensuite, le IOBuffer est réinitialisé à son état initial.

Exemples

julia> io = IOBuffer();

julia> write(io, "JuliaLang est une organisation GitHub.", " Elle a de nombreux membres.")
56

julia> String(take!(io))
"JuliaLang est une organisation GitHub. Elle a de nombreux membres."

Pipe()

Construit un objet Pipe non initialisé, spécialement pour la communication IO entre plusieurs processus.

L'extrémité appropriée du pipe sera automatiquement initialisée si l'objet est utilisé dans le lancement de processus. Cela peut être utile pour obtenir facilement des références dans des pipelines de processus, par exemple :

julia> err = Pipe()

# Après cela, `err` sera initialisé et vous pourrez lire `foo`'s
# stderr depuis le pipe `err`, ou passer `err` à d'autres pipelines.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# Maintenant, détruisez la moitié écrite du pipe, afin que la moitié lue obtienne EOF
julia> closewrite(err)

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

Voir aussi Base.link_pipe!.

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

Initialisez pipe et reliez le point d'extrémité in au point d'extrémité out. Les arguments de mot-clé reader_supports_async/writer_supports_async correspondent à OVERLAPPED sur Windows et O_NONBLOCK sur les systèmes POSIX. Ils devraient être true à moins qu'ils ne soient utilisés par un programme externe (par exemple, la sortie d'une commande exécutée avec run).

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

Crée un objet IOStream à partir d'un descripteur de fichier entier. Si own est true, la fermeture de cet objet fermera le descripteur sous-jacent. Par défaut, un IOStream est fermé lorsqu'il est collecté par le ramasse-miettes. name vous permet d'associer le descripteur à un fichier nommé.

flush(stream)

Engage tous les écrits actuellement mis en mémoire tampon dans le flux donné.

close(stream)

Ferme un flux d'E/S. Effectue d'abord un flush.

closewrite(stream)

Arrête la moitié écriture d'un flux I/O duplex complet. Effectue d'abord un flush. Informe l'autre extrémité qu'aucune donnée supplémentaire ne sera écrite dans le fichier sous-jacent. Cela n'est pas pris en charge par tous les types d'E/S.

Si implémenté, closewrite provoque que les appels ultérieurs à read ou eof qui bloqueraient lancent plutôt EOF ou retournent vrai, respectivement. Si le flux est déjà fermé, cela est idempotent.

Exemples

julia> io = Base.BufferStream(); # cela ne bloque jamais, donc nous pouvons lire et écrire sur la même tâche

julia> write(io, "request");

julia> # appeler `read(io)` ici bloquerait indéfiniment

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

Écrivez la représentation binaire canonique d'une valeur dans le flux ou le fichier I/O donné. Retournez le nombre d'octets écrits dans le flux. Voir aussi print pour écrire une représentation textuelle (avec un encodage qui peut dépendre de io).

L'endianness de la valeur écrite dépend de l'endianness du système hôte. Convertissez vers/depuis une endianness fixe lors de l'écriture/de la lecture (par exemple, en utilisant htol et ltoh) pour obtenir des résultats cohérents sur différentes plateformes.

Vous pouvez écrire plusieurs valeurs avec le même appel à write. c'est-à-dire que les éléments suivants sont équivalents :

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

Exemples

Sérialisation cohérente :

julia> fname = tempname(); # nom de fichier temporaire aléatoire

julia> open(fname,"w") do f
           # Assurez-vous d'écrire un entier 64 bits dans l'ordre des octets little-endian
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # Convertir à nouveau en ordre des octets hôte et type d'entier hôte
           Int(ltoh(read(f,Int64)))
       end
42

Fusion des appels d'écriture :

julia> io = IOBuffer();

julia> write(io, "JuliaLang est une organisation GitHub.", " Elle a de nombreux membres.")
56

julia> String(take!(io))
"JuliaLang est une organisation GitHub. Elle a de nombreux membres."

julia> write(io, "Parfois ces membres") + write(io, " écrivent de la documentation.")
44

julia> String(take!(io))
"Parfois ces membres écrivent de la documentation."

Les types de données simples définis par l'utilisateur sans méthodes write peuvent être écrits lorsqu'ils sont enveloppés dans 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)

Lire une seule valeur de type T à partir de io, dans une représentation binaire canonique.

Notez que Julia ne convertit pas l'endianness pour vous. Utilisez ntoh ou ltoh à cet effet.

read(io::IO, String)

Lire l'intégralité de io, en tant que String (voir aussi readchomp).

Exemples

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

julia> read(io, Char)
'J': ASCII/Unicode U+004A (catégorie Lu: Lettre, majuscule)

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

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

read(filename::AbstractString)

Lire le contenu entier d'un fichier sous forme de Vector{UInt8}.

read(filename::AbstractString, String)

Lire le contenu entier d'un fichier sous forme de chaîne.

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

Ouvrir un fichier et lire son contenu. args est passé à read : cela équivaut à open(io->read(io, args...), filename).

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

Lire au maximum nb octets de s, renvoyant un Vector{UInt8} des octets lus.

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

Lire au maximum nb octets de s, renvoyant un Vector{UInt8} des octets lus.

Si all est true (la valeur par défaut), cette fonction bloquera en essayant de lire tous les octets demandés, jusqu'à ce qu'une erreur ou la fin du fichier se produise. Si all est false, au maximum un appel à read est effectué, et la quantité de données renvoyées dépend du périphérique. Notez que tous les types de flux ne prennent pas en charge l'option all.

read(command::Cmd)

Exécutez command et renvoyez la sortie résultante sous forme de tableau d'octets.

read(command::Cmd, String)

Exécutez command et renvoie la sortie résultante sous forme de String.

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

Lire des données binaires à partir d'un flux d'E/S ou d'un fichier, remplissant array.

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

Lire au maximum nb octets depuis stream dans b, en retournant le nombre d'octets lus. La taille de b sera augmentée si nécessaire (c'est-à-dire si nb est supérieur à length(b) et que suffisamment d'octets ont pu être lus), mais elle ne sera jamais diminuée.

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

Lit au maximum nb octets depuis stream dans b, retournant le nombre d'octets lus. La taille de b sera augmentée si nécessaire (c'est-à-dire si nb est supérieur à length(b) et que suffisamment d'octets ont pu être lus), mais elle ne sera jamais diminuée.

Si all est true (par défaut), cette fonction bloquera en essayant de lire tous les octets demandés, jusqu'à ce qu'une erreur ou la fin du fichier se produise. Si all est false, au maximum un appel à read est effectué, et la quantité de données retournées dépend du périphérique. Notez que tous les types de flux ne prennent pas en charge l'option all.

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

Copie nbytes de l'objet de flux IO dans ref (converti en pointeur).

Il est recommandé que les sous-types T<:IO remplacent la signature de méthode suivante pour fournir des implémentations plus efficaces : unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

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

Copie nbytes de ref (converti en pointeur) dans l'objet IO.

Il est recommandé que les sous-types T<:IO remplacent la signature de méthode suivante pour fournir des implémentations plus efficaces : unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

Renvoie un objet itérable produisant read(io, T).

Voir aussi skipchars, eachline, readuntil.

Exemples

julia> io = IOBuffer("JuliaLang est une organisation GitHub.\n Elle a de nombreux membres.\n");

julia> for c in readeach(io, Char)
           c == '\n' && break
           print(c)
       end
JuliaLang est une organisation GitHub.

peek(stream[, T=UInt8])

Lire et retourner une valeur de type T à partir d'un flux sans avancer la position actuelle dans le flux. Voir aussi startswith(stream, char_or_string).

Exemples

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (catégorie Ll: Lettre, minuscule)

position(l::Lexer)

Renvoie la position actuelle.

position(s)

Obtenez la position actuelle d'un flux.

Exemples

julia> io = IOBuffer("JuliaLang est une organisation 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)

Cherchez un flux à la position donnée.

Exemples

julia> io = IOBuffer("JuliaLang est une organisation GitHub.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (catégorie Lu: Lettre, majuscule)

seekstart(s)

Déplace un flux au début.

Exemples

julia> io = IOBuffer("JuliaLang est une organisation GitHub.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (catégorie Lu: Lettre, majuscule)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (catégorie Lu: Lettre, majuscule)

seekend(s)

Cherche un flux à sa fin.

skip(s, offset)

Chercher un flux par rapport à la position actuelle.

Exemples

julia> io = IOBuffer("JuliaLang est une organisation GitHub.");

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (catégorie Lu : Lettre, majuscule)

mark(s::IO)

Ajoute un marque à la position actuelle du flux s. Retourne la position marquée.

Voir aussi unmark, reset, ismarked.

unmark(s::IO)

Supprime une marque du flux s. Retourne true si le flux était marqué, false sinon.

Voir aussi mark, reset, ismarked.

reset(s::IO)

Réinitialise un flux s à une position marquée précédemment et supprime la marque. Retourne la position marquée précédemment. Lance une erreur si le flux n'est pas marqué.

Voir aussi mark, unmark, ismarked.

ismarked(s::IO)

Retourne true si le flux s est marqué.

Voir aussi mark, unmark, reset.

eof(stream) -> Bool

Teste si un flux d'E/S est à la fin du fichier. Si le flux n'est pas encore épuisé, cette fonction bloquera pour attendre plus de données si nécessaire, puis renverra false. Il est donc toujours sûr de lire un octet après avoir vu eof renvoyer false. eof renverra false tant que des données mises en mémoire tampon sont encore disponibles, même si l'extrémité distante d'une connexion est fermée.

Exemples

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

Déterminez si un flux est en lecture seule.

Exemples

julia> io = IOBuffer("JuliaLang est une organisation GitHub");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

Retourne true si les permissions d'accès pour le path donné permettent l'écriture par l'utilisateur actuel.

Voir aussi ispath, isexecutable, isreadable.

iswritable(io) -> Bool

Retourne false si l'objet IO spécifié n'est pas écrivable.

Exemples

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

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

julia> rm("myfile.txt")

isreadable(path::String)

Retourne true si les permissions d'accès pour le path donné permettent la lecture par l'utilisateur actuel.

Voir aussi ispath, isexecutable, iswritable.

isreadable(io) -> Bool

Retourne false si l'objet IO spécifié n'est pas lisible.

Exemples

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

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

julia> rm("myfile.txt")

isexecutable(path::String)

Retourne true si le path donné a des permissions d'exécution.

Voir aussi ispath, isreadable, iswritable.

isopen(object) -> Bool

Déterminez si un objet - tel qu'un flux ou un minuteur - n'est pas encore fermé. Une fois qu'un objet est fermé, il ne produira jamais un nouvel événement. Cependant, comme un flux fermé peut encore avoir des données à lire dans son tampon, utilisez eof pour vérifier la possibilité de lire des données. Utilisez le package FileWatching pour être informé lorsque un flux pourrait être écrivable ou lisible.

Exemples

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

Retourne le descripteur de fichier soutenant le flux ou le fichier. Notez que cette fonction ne s'applique qu'aux File et IOStream synchrones, et non à aucun des flux asynchrones.

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

Redirige un sous-ensemble des flux stdin, stderr, stdout. Chaque argument doit être un IOStream, TTY, Pipe, socket ou devnull.

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

Redirige un sous-ensemble des flux stdin, stderr, stdout, appelle f() et restaure chaque flux.

Les valeurs possibles pour chaque flux sont :

• nothing indiquant que le flux ne doit pas être redirigé.
• path::AbstractString redirigeant le flux vers le fichier à path.
• io un IOStream, TTY, Pipe, socket, ou devnull.

Exemples

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"

Cas particuliers

Il est possible de passer le même argument à stdout et stderr :

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

Cependant, il n'est pas supporté de passer deux descripteurs distincts du même fichier.

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

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

julia> redirect_stdio(f, stdout=io1, stderr=io2) # non supporté

De plus, l'argument stdin ne peut pas être le même descripteur que stdout ou stderr.

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # non supporté

redirect_stdout([stream]) -> stream

Créez un pipe vers lequel toute sortie stdout au niveau C et Julia sera redirigée. Retournez un flux représentant les extrémités du pipe. Les données écrites dans stdout peuvent maintenant être lues à partir de l'extrémité rd du pipe.

Voir aussi redirect_stdio.

redirect_stdout(f::Function, stream)

Exécutez la fonction f tout en redirigeant stdout vers stream. Une fois terminé, stdout est restauré à son paramètre précédent.

redirect_stderr([stream]) -> stream

Comme redirect_stdout, mais pour stderr.

Voir aussi redirect_stdio.

redirect_stderr(f::Function, stream)

Exécutez la fonction f tout en redirigeant stderr vers stream. Une fois terminé, stderr est restauré à son paramètre précédent.

redirect_stdin([stream]) -> stream

Comme redirect_stdout, mais pour stdin. Notez que la direction du flux est inversée.

Voir aussi redirect_stdio.

redirect_stdin(f::Function, stream)

Exécutez la fonction f tout en redirigeant stdin vers stream. Une fois terminé, stdin est restauré à son paramètre précédent.

readchomp(x)

Lit l'intégralité de x en tant que chaîne et supprime une seule nouvelle ligne à la fin s'il y en a une. Équivalent à chomp(read(x, String)).

Exemples

julia> write("my_file.txt", "JuliaLang est une organisation GitHub.\nElle a de nombreux membres.\n");

julia> readchomp("my_file.txt")
"JuliaLang est une organisation GitHub.\nElle a de nombreux membres."

julia> rm("my_file.txt");

truncate(file, n)

Redimensionne le fichier ou le tampon donné par le premier argument à exactement n octets, remplissant l'espace précédemment non alloué avec '\0' si le fichier ou le tampon est agrandi.

Exemples

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)

Avancez le flux io de sorte que le prochain caractère lu soit le premier restant pour lequel predicate renvoie false. Si l'argument clé linecomment est spécifié, tous les caractères de ce caractère jusqu'au début de la ligne suivante sont ignorés.

Exemples

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

Lire io jusqu'à la fin du flux/fichier et compter le nombre de lignes. Pour spécifier un fichier, passez le nom du fichier comme premier argument. Les marqueurs EOL autres que '\n' sont pris en charge en les passant comme deuxième argument. La dernière ligne non vide de io est comptée même si elle ne se termine pas par l'EOL, correspondant à la longueur renvoyée par eachline et readlines.

Pour compter les lignes d'une String, countlines(IOBuffer(str)) peut être utilisé.

Exemples

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) # compter les lignes déplace le pointeur de fichier
true

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

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

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

julia> countlines("my_file.txt")
1

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

julia> rm("my_file.txt")

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

Un IOBuffer qui permet de lire et effectue des écritures en ajoutant. La recherche et la troncature ne sont pas prises en charge. Voir IOBuffer pour les constructeurs disponibles. Si data est fourni, crée un PipeBuffer pour opérer sur un vecteur de données, en spécifiant éventuellement une taille au-delà de laquelle le tableau sous-jacent ne peut pas être agrandi.

readavailable(stream)

Lire les données mises en mémoire tampon disponibles à partir d'un flux. Les opérations d'E/S réelles ne sont effectuées que si aucune donnée n'a déjà été mise en mémoire tampon. Le résultat est un Vector{UInt8}.

IOContext

IOContext fournit un mécanisme pour passer des paramètres de configuration de sortie entre les méthodes show.

En résumé, c'est un dictionnaire immuable qui est une sous-classe de IO. Il prend en charge les opérations de dictionnaire standard telles que getindex, et peut également être utilisé comme un flux d'E/S.

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

Crée un IOContext qui enveloppe un flux donné, ajoutant les paires key=>value spécifiées aux propriétés de ce flux (notez que io peut lui-même être un IOContext).

• utilisez (key => value) in io pour voir si cette combinaison particulière est dans l'ensemble des propriétés
• utilisez get(io, key, default) pour récupérer la valeur la plus récente pour une clé particulière

Les propriétés suivantes sont couramment utilisées :

• :compact : Booléen spécifiant que les valeurs doivent être imprimées de manière plus compacte, par exemple que les nombres doivent être imprimés avec moins de chiffres. Cela est défini lors de l'impression des éléments d'un tableau. La sortie :compact ne doit pas contenir de sauts de ligne.
• :limit : Booléen spécifiant que les conteneurs doivent être tronqués, par exemple en montrant … à la place de la plupart des éléments.
• :displaysize : Un Tuple{Int,Int} donnant la taille en lignes et colonnes à utiliser pour la sortie texte. Cela peut être utilisé pour remplacer la taille d'affichage pour les fonctions appelées, mais pour obtenir la taille de l'écran, utilisez la fonction displaysize.
• :typeinfo : un Type caractérisant les informations déjà imprimées concernant le type de l'objet sur le point d'être affiché. Cela est principalement utile lors de l'affichage d'une collection d'objets du même type, afin d'éviter les informations de type redondantes (par exemple, [Float16(0)] peut être affiché comme "Float16[0.0]" au lieu de "Float16[Float16(0.0)]" : lors de l'affichage des éléments du tableau, la propriété :typeinfo sera définie sur Float16).
• :color : Booléen spécifiant si les codes de couleur/évasion ANSI sont pris en charge/attendus. Par défaut, cela est déterminé par le fait que io soit un terminal compatible et par tout drapeau de ligne de commande --color lorsque julia a été lancé.

Exemples

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)

Créez un IOContext qui enveloppe un IO alternatif mais hérite des propriétés de context.

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

Écrit une représentation textuelle d'une valeur x dans le flux de sortie io. Les nouveaux types T devraient surcharger show(io::IO, x::T). La représentation utilisée par show inclut généralement un formatage spécifique à Julia et des informations de type, et devrait être analysable en code Julia lorsque cela est possible.

repr renvoie la sortie de show sous forme de chaîne.

Pour une sortie textuelle plus détaillée et lisible par l'homme pour les objets de type T, définissez également show(io::IO, ::MIME"text/plain", ::T). Il est recommandé de vérifier la clé :compact de IOContext (souvent vérifiée comme get(io, :compact, false)::Bool) de io dans de telles méthodes, car certains conteneurs affichent leurs éléments en appelant cette méthode avec :compact => true.

Voir aussi print, qui écrit des représentations non décorées.

Exemples

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

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

Imprime dans un flux io, ou retourne une chaîne str, donnant une brève description d'une valeur. Par défaut, retourne string(typeof(x)), par exemple Int64.

Pour les tableaux, retourne une chaîne d'informations sur la taille et le type, par exemple 10-element Array{Int64,1}.

Exemples

julia> summary(1)
"Int64"

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

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

Écrit dans io (ou dans le flux de sortie par défaut stdout si io n'est pas donné) une représentation textuelle canonique (non décorée). La représentation utilisée par print inclut un formatage minimal et essaie d'éviter les détails spécifiques à Julia.

print se rabat sur l'appel de show, donc la plupart des types devraient simplement définir show. Définissez print si votre type a une représentation "plain" séparée. Par exemple, show affiche les chaînes avec des guillemets, et print affiche les chaînes sans guillemets.

Voir aussi println, string, printstyled.

Exemples

julia> print("Hello World!")
Hello World!
julia> io = IOBuffer();

julia> print(io, "Hello", ' ', :World!)

julia> String(take!(io))
"Hello World!"

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

Imprime (en utilisant print) xs sur io suivi d'une nouvelle ligne. Si io n'est pas fourni, imprime sur le flux de sortie par défaut stdout.

Voir aussi printstyled pour ajouter des couleurs, etc.

Exemples

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 dans une couleur spécifiée comme un symbole ou un entier, éventuellement en gras.

Le mot-clé color peut prendre n'importe quelle des valeurs :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, ou :yellow ou un entier entre 0 et 255 inclus. Notez que tous les terminaux ne prennent pas en charge 256 couleurs.

Les mots-clés bold=true, italic=true, underline=true, blink=true sont explicites. Le mot-clé reverse=true imprime avec les couleurs de premier plan et d'arrière-plan échangées, et hidden=true devrait être invisible dans le terminal mais peut toujours être copié. Ces propriétés peuvent être utilisées dans n'importe quelle combinaison.

Voir aussi print, println, show.

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

Appelle la fonction donnée avec un flux d'E/S et les arguments supplémentaires fournis. Tout ce qui est écrit dans ce flux d'E/S est renvoyé sous forme de chaîne. context peut être un IOContext dont les propriétés seront utilisées, une Pair spécifiant une propriété et sa valeur, ou un tuple de Pair spécifiant plusieurs propriétés et leurs valeurs. sizehint suggère la capacité du tampon (en octets).

L'argument clé optionnel context peut être défini comme une paire :key=>value, un tuple de paires :key=>value, ou un objet IO ou IOContext dont les attributs sont utilisés pour le flux d'E/S passé à f. L'optionnel sizehint est une taille suggérée (en octets) à allouer pour le tampon utilisé pour écrire la chaîne.

Exemples

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)

Affiche une représentation descriptive d'un objet d'exception e. Cette méthode est utilisée pour afficher l'exception après un appel à throw.

Exemples

julia> struct MyException <: Exception
           msg::String
       end

julia> function Base.showerror(io::IO, err::MyException)
           print(io, "MyException: ")
           print(io, err.msg)
       end

julia> err = MyException("test exception")
MyException("test exception")

julia> sprint(showerror, err)
"MyException: test exception"

julia> throw(MyException("test exception"))
ERROR: MyException: test exception

dump(x; maxdepth=8)

Montre chaque partie de la représentation d'une valeur. La profondeur de la sortie est tronquée à maxdepth.

Exemples

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

Montre chaque partie de la représentation de l'expression donnée. Équivalent à dump(:(expr)).

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

Lit une seule ligne de texte à partir du flux d'E/S ou du fichier donné (par défaut stdin). Lors de la lecture à partir d'un fichier, le texte est supposé être encodé en UTF-8. Les lignes dans l'entrée se terminent par '\n' ou "\r\n" ou la fin d'un flux d'entrée. Lorsque keep est faux (comme c'est le cas par défaut), ces caractères de nouvelle ligne finaux sont supprimés de la ligne avant qu'elle ne soit renvoyée. Lorsque keep est vrai, ils sont renvoyés comme partie de la ligne.

Renvoie un String. Voir aussi copyline pour écrire à la place en place dans un autre flux (qui peut être un IOBuffer préalloué).

Voir aussi readuntil pour lire jusqu'à des délimiteurs plus généraux.

Exemples

julia> write("my_file.txt", "JuliaLang est une organisation GitHub.\nElle a de nombreux membres.\n");

julia> readline("my_file.txt")
"JuliaLang est une organisation GitHub."

julia> readline("my_file.txt", keep=true)
"JuliaLang est une organisation GitHub.\n"

julia> rm("my_file.txt")

julia> print("Entrez votre nom : ")
Entrez votre nom :

julia> your_name = readline()
Logan
"Logan"

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

Lit une chaîne à partir d'un flux I/O ou d'un fichier, jusqu'au délimiteur donné. Le délimiteur peut être un UInt8, AbstractChar, une chaîne ou un vecteur. L'argument clé keep contrôle si le délimiteur est inclus dans le résultat. Le texte est supposé être encodé en UTF-8.

Retourne une String si delim est un AbstractChar ou une chaîne, sinon retourne un Vector{typeof(delim)}. Voir aussi copyuntil pour écrire à la place dans un autre flux (qui peut être un IOBuffer préalloué).

Exemples

julia> write("my_file.txt", "JuliaLang est une organisation GitHub.\nElle a de nombreux membres.\n");

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

julia> readuntil("my_file.txt", '.', keep = true)
"JuliaLang est une organisation GitHub."

julia> rm("my_file.txt")

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

Lit tous les lignes d'un flux I/O ou d'un fichier sous forme de vecteur de chaînes. Le comportement est équivalent à la sauvegarde du résultat de la lecture de readline de manière répétée avec les mêmes arguments et à la sauvegarde des lignes résultantes sous forme de vecteur de chaînes. Voir aussi eachline pour itérer sur les lignes sans les lire toutes en une seule fois.

Exemples

julia> write("my_file.txt", "JuliaLang est une organisation GitHub.\nElle a de nombreux membres.\n");

julia> readlines("my_file.txt")
2-element Vector{String}:
 "JuliaLang est une organisation GitHub."
 "Elle a de nombreux membres."

julia> readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "JuliaLang est une organisation GitHub.\n"
 "Elle a de nombreux membres.\n"

julia> rm("my_file.txt")

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

Créez un objet itérable EachLine qui renverra chaque ligne d'un flux I/O ou d'un fichier. L'itération appelle readline sur l'argument de flux de manière répétée avec keep passé, déterminant si les caractères de fin de ligne sont conservés. Lorsqu'il est appelé avec un nom de fichier, le fichier est ouvert une fois au début de l'itération et fermé à la fin. Si l'itération est interrompue, le fichier sera fermé lorsque l'objet EachLine sera collecté par le ramasse-miettes.

Pour itérer sur chaque ligne d'une String, eachline(IOBuffer(str)) peut être utilisé.

Iterators.reverse peut être utilisé sur un objet EachLine pour lire les lignes dans l'ordre inverse (pour les fichiers, les tampons et d'autres flux I/O prenant en charge seek), et first ou last peuvent être utilisés pour extraire respectivement les lignes initiales ou finales.

Exemples

julia> write("my_file.txt", "JuliaLang est une organisation GitHub.\n Elle a de nombreux membres.\n");

julia> for line in eachline("my_file.txt")
           print(line)
       end
JuliaLang est une organisation GitHub. Elle a de nombreux membres.

julia> rm("my_file.txt");

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

Copie une seule ligne de texte d'un `flux` I/O ou d'un fichier vers le flux `out`, retournant `out`.

Lors de la lecture d'un fichier, le texte est supposé être encodé en UTF-8. Les lignes dans l'entrée se terminent par `'\n'` ou `"\r\n"` ou la fin d'un flux d'entrée. Lorsque `keep` est faux (comme c'est le cas par défaut), ces caractères de nouvelle ligne finaux sont supprimés de la ligne avant qu'elle ne soit retournée. Lorsque `keep` est vrai, ils sont retournés comme partie de la ligne.

Semblable à [`readline`](@ref), qui retourne une `String`; en revanche, `copyline` écrit directement dans `out`, sans allouer de chaîne. (Cela peut être utilisé, par exemple, pour lire des données dans un [`IOBuffer`](@ref) pré-alloué.)

Voir aussi [`copyuntil`](@ref) pour lire jusqu'à des délimiteurs plus généraux.

# Exemples

jldoctest julia> write("my_file.txt", "JuliaLang est une organisation GitHub.\nElle a de nombreux membres.\n");

julia> String(take!(copyline(IOBuffer(), "my_file.txt"))) "JuliaLang est une organisation GitHub."

julia> String(take!(copyline(IOBuffer(), "my_file.txt", keep=true))) "JuliaLang est une organisation 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)

Copie une chaîne d'un flux I/O `stream` ou d'un fichier, jusqu'au délimiteur donné, vers le flux `out`, en retournant `out`. Le délimiteur peut être un `UInt8`, `AbstractChar`, une chaîne ou un vecteur. L'argument clé `keep` contrôle si le délimiteur est inclus dans le résultat. Le texte est supposé être encodé en UTF-8.

Semblable à [`readuntil`](@ref), qui retourne une `String`; en revanche, `copyuntil` écrit directement dans `out`, sans allouer de chaîne. (Cela peut être utilisé, par exemple, pour lire des données dans un [`IOBuffer`](@ref) pré-alloué.)

# Exemples

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]) -> (lignes, colonnes)

Retourne la taille nominale de l'écran qui peut être utilisée pour le rendu de la sortie vers cet objet IO. Si aucun input n'est fourni, les variables d'environnement LINES et COLUMNS sont lues. Si celles-ci ne sont pas définies, une taille par défaut de (24, 80) est retournée.

Exemples

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

Pour obtenir la taille de votre TTY,

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

Supertype abstrait pour les dispositifs de sortie d'affichage riches. TextDisplay est un sous-type de cela.

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

Affichez x en utilisant l'affichage le plus applicable dans la pile d'affichage, généralement en utilisant la sortie multimédia la plus riche prise en charge pour x, avec une sortie en texte brut stdout comme solution de repli. La variante display(d, x) tente d'afficher x uniquement sur l'affichage donné d, lançant une MethodError si d ne peut pas afficher des objets de ce type.

En général, vous ne pouvez pas supposer que la sortie de display va vers stdout (contrairement à print(x) ou show(x)). Par exemple, display(x) peut ouvrir une fenêtre séparée avec une image. display(x) signifie "montrez x de la meilleure façon possible pour le(s) dispositif(s) de sortie actuel(s)." Si vous souhaitez une sortie textuelle semblable à celle du REPL qui est garantie d'aller vers stdout, utilisez show(stdout, "text/plain", x) à la place.

Il existe également deux variantes avec un argument mime (une chaîne de type MIME, telle que "image/png"), qui tentent d'afficher x en utilisant le type MIME demandé uniquement, lançant une MethodError si ce type n'est pas pris en charge par l'affichage ou par x. Avec ces variantes, on peut également fournir les données "brutes" dans le type MIME demandé en passant x::AbstractString (pour les types MIME avec stockage basé sur du texte, tels que text/html ou application/postscript) ou x::Vector{UInt8} (pour les types MIME binaires).

Pour personnaliser la façon dont les instances d'un type sont affichées, surchargez show plutôt que display, comme expliqué dans la section du manuel sur l'impression personnalisée.

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

Par défaut, les fonctions redisplay appellent simplement display. Cependant, certains backends d'affichage peuvent remplacer redisplay pour modifier un affichage existant de x (le cas échéant). Utiliser redisplay est également un indice pour le backend que x peut être réaffiché plusieurs fois, et le backend peut choisir de différer l'affichage jusqu'à (par exemple) la prochaine invite interactive.

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

Renvoie une valeur booléenne indiquant si le type mime donné (chaîne) est affichable par l'un des affichages dans la pile d'affichage actuelle, ou spécifiquement par l'affichage d dans la deuxième variante.

show(io::IO, mime, x)

Les fonctions display appellent finalement show afin d'écrire un objet x sous un type mime donné dans un flux d'E/S io donné (généralement un tampon mémoire), si possible. Pour fournir une représentation multimédia riche d'un type défini par l'utilisateur T, il suffit de définir une nouvelle méthode show pour T, via : show(io, ::MIME"mime", x::T) = ..., où mime est une chaîne de caractères de type MIME et le corps de la fonction appelle write (ou similaire) pour écrire cette représentation de x dans io. (Notez que la notation MIME"" ne prend en charge que des chaînes littérales ; pour construire des types MIME de manière plus flexible, utilisez MIME{Symbol("")}.)

Par exemple, si vous définissez un type MyImage et savez comment l'écrire dans un fichier PNG, vous pourriez définir une fonction show(io, ::MIME"image/png", x::MyImage) = ... pour permettre à vos images d'être affichées sur tout AbstractDisplay capable de PNG (comme IJulia). Comme d'habitude, assurez-vous d'importer Base.show afin d'ajouter de nouvelles méthodes à la fonction intégrée Julia show.

Techniquement, la macro MIME"mime" définit un type singleton pour la chaîne mime donnée, ce qui nous permet d'exploiter les mécanismes de dispatch de Julia pour déterminer comment afficher des objets de tout type donné.

Le type MIME par défaut est MIME"text/plain". Il existe une définition de secours pour la sortie text/plain qui appelle show avec 2 arguments, donc il n'est pas toujours nécessaire d'ajouter une méthode pour ce cas. Si un type bénéficie d'une sortie personnalisée lisible par un humain, show(::IO, ::MIME"text/plain", ::T) devrait être défini. Par exemple, le type Day utilise 1 day comme sortie pour le type MIME text/plain, et Day(1) comme sortie de show à 2 arguments.

Exemples

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

Les types conteneurs implémentent généralement show à 3 arguments en appelant show(io, MIME"text/plain"(), x) pour les éléments x, avec :compact => true défini dans un IOContext passé comme premier argument.

showable(mime, x)

Renvoie une valeur booléenne indiquant si l'objet x peut être écrit sous le type mime donné.

(Par défaut, cela est déterminé automatiquement par l'existence de la méthode show correspondante pour typeof(x). Certains types fournissent des méthodes showable personnalisées ; par exemple, si les formats MIME disponibles dépendent de la valeur de x.)

Exemples

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

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

repr(mime, x; context=nothing)

Renvoie un AbstractString ou un Vector{UInt8} contenant la représentation de x dans le type mime demandé, comme écrit par show(io, mime, x) (générant une MethodError si aucune méthode show appropriée n'est disponible). Un AbstractString est renvoyé pour les types MIME avec des représentations textuelles (comme "text/html" ou "application/postscript"), tandis que les données binaires sont renvoyées sous forme de Vector{UInt8}. (La fonction istextmime(mime) renvoie si Julia traite un type mime donné comme texte.)

L'argument clé optionnel context peut être défini comme une paire :key=>value ou un objet IO ou IOContext dont les attributs sont utilisés pour le flux I/O passé à show.

Dans un cas particulier, si x est un AbstractString (pour les types MIME textuels) ou un Vector{UInt8} (pour les types MIME binaires), la fonction repr suppose que x est déjà au format mime demandé et renvoie simplement x. Ce cas particulier ne s'applique pas au type MIME "text/plain". Cela est utile pour que des données brutes puissent être passées à display(m::MIME, x).

En particulier, repr("text/plain", x) est généralement une version "bien formatée" de x conçue pour la consommation humaine. Voir aussi repr(x) pour renvoyer à la place une chaîne correspondant à show(x) qui pourrait être plus proche de la façon dont la valeur de x serait saisie dans Julia.

Exemples

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

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

MIME

Un type représentant un format de données Internet standard. "MIME" signifie "Multipurpose Internet Mail Extensions", car la norme a été initialement utilisée pour décrire des pièces jointes multimédias aux messages électroniques.

Un objet MIME peut être passé comme deuxième argument à show pour demander une sortie dans ce format.

Exemples

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

@MIME_str

Une macro de commodité pour écrire des types MIME, généralement utilisée lors de l'ajout de méthodes à show. Par exemple, la syntaxe show(io::IO, ::MIME"text/html", x::MyType) = ... pourrait être utilisée pour définir comment écrire une représentation HTML de MyType.

pushdisplay(d::AbstractDisplay)

Pousse un nouvel affichage d au sommet de la pile de backend d'affichage global. Appeler display(x) ou display(mime, x) affichera x sur le backend compatible le plus haut dans la pile (c'est-à-dire, le backend le plus haut qui ne génère pas une MethodError).

popdisplay()
popdisplay(d::AbstractDisplay)

Retire le backend le plus haut de la pile des backends d'affichage, ou la copie la plus haute de d dans la deuxième variante.

TextDisplay(io::IO)

Renvoie un TextDisplay <: AbstractDisplay, qui affiche tout objet sous le type MIME text/plain (par défaut), en écrivant la représentation textuelle dans le flux I/O donné. (C'est ainsi que les objets sont imprimés dans le REPL Julia.)

istextmime(m::MIME)

Déterminez si un type MIME est des données textuelles. Les types MIME sont supposés être des données binaires, sauf pour un ensemble de types connus pour être des données textuelles (possiblement Unicode).

Exemples

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

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

bytesavailable(io)

Renvoie le nombre d'octets disponibles pour la lecture avant qu'une lecture de ce flux ou tampon ne bloque.

Exemples

julia> io = IOBuffer("JuliaLang est une organisation GitHub");

julia> bytesavailable(io)
34

ntoh(x)

Convertit l'endianness d'une valeur de l'ordre des octets réseau (big-endian) à celui utilisé par l'hôte.

hton(x)

Convertit l'endianness d'une valeur de celle utilisée par l'hôte à l'ordre des octets réseau (big-endian).

ltoh(x)

Convertir l'endianness d'une valeur de Little-endian à celui utilisé par l'hôte.

htol(x)

Convertir l'endianness d'une valeur de celui utilisé par l'hôte en Little-endian.

ENDIAN_BOM

Le marqueur d'ordre des octets de 32 bits indique l'ordre des octets natif de la machine hôte. Les machines little-endian contiendront la valeur 0x04030201. Les machines big-endian contiendront la valeur 0x01020304.