I/O and Network

stdout::IO

Globale Variable, die auf den Standardausgabestrom verweist.

stderr::IO

Globale Variable, die auf den Standardfehlerstrom verweist.

stdin::IO

Globale Variable, die auf den Standard-Eingabestrom verweist.

read(filename::AbstractString)

Lese den gesamten Inhalt einer Datei als Vector{UInt8}.

read(filename::AbstractString, String)

Lese den gesamten Inhalt einer Datei als Zeichenfolge.

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

Öffne eine Datei und lese ihren Inhalt. args wird an read übergeben: dies entspricht open(io->read(io, args...), filename).

write(filename::AbstractString, content)

Schreibt die kanonische binäre Darstellung von content in eine Datei, die erstellt wird, wenn sie noch nicht existiert, oder überschrieben wird, wenn sie bereits existiert.

Gibt die Anzahl der in die Datei geschriebenen Bytes zurück.

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

Wenden Sie die Funktion f auf das Ergebnis von open(args...; kwargs...) an und schließen Sie den resultierenden Dateideskriptor nach Abschluss.

Beispiele

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

Öffnen Sie eine Datei in einem Modus, der durch fünf boolesche Schlüsselwortargumente angegeben ist:

Der Standardwert, wenn keine Schlüsselwörter übergeben werden, ist, Dateien nur zum Lesen zu öffnen. Gibt einen Stream zum Zugreifen auf die geöffnete Datei zurück.

Das Schlüsselwortargument lock steuert, ob Operationen für einen sicheren mehrstufigen Zugriff gesperrt werden.

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

Alternative Syntax für open, bei der ein stringbasierter Modus-Spezifizierer anstelle der fünf Booleans verwendet wird. Die Werte von mode entsprechen denen von fopen(3) oder Perl open und sind äquivalent zu den folgenden booleschen Gruppen:

Das Schlüsselwortargument lock steuert, ob Operationen für einen sicheren Multi-Thread-Zugriff gesperrt werden.

Beispiele

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

Nehmen Sie einen rohen Dateideskriptor, wickeln Sie ihn in einen Julia-bewussten IO-Typ und übernehmen Sie das Eigentum des fd-Handels. Rufen Sie open(Libc.dup(fd)) auf, um die Eigentumserfassung des ursprünglichen Handgriffs zu vermeiden.

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

Führen Sie command asynchron aus. Ähnlich wie open(command, stdio; read, write), jedoch werden die Lese- und Schreibflags über eine Moduszeichenfolge anstelle von Schlüsselwortargumenten angegeben. Mögliche Moduszeichenfolgen sind:

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

Beginnen Sie mit der asynchronen Ausführung von command und geben Sie ein process::IO-Objekt zurück. Wenn read wahr ist, stammen die Lesevorgänge vom Standardausgang des Prozesses, und stdio gibt optional den Standard-Eingabestrom des Prozesses an. Wenn write wahr ist, gehen die Schreibvorgänge an den Standard-Eingabestrom des Prozesses, und stdio gibt optional den Standard-Ausgangsstrom des Prozesses an. Der Standard-Fehlerstrom des Prozesses ist mit dem aktuellen globalen stderr verbunden.

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

Ähnlich wie open(command, args...; kwargs...), aber ruft f(stream) auf dem resultierenden Prozessstream auf, schließt dann den Eingabestream und wartet, bis der Prozess abgeschlossen ist. Gibt den Wert zurück, den f bei Erfolg zurückgibt. Wirft einen Fehler, wenn der Prozess fehlgeschlagen ist oder wenn der Prozess versucht, etwas auf stdout auszugeben.

IOStream

Ein gepufferter IO-Stream, der einen OS-Dateideskriptor umschließt. Wird hauptsächlich verwendet, um Dateien darzustellen, die von open zurückgegeben werden.

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

Erstellt einen In-Memory-I/O-Stream, der optional auf einem bereits vorhandenen Array arbeiten kann.

Es können optionale Schlüsselwortargumente übergeben werden:

• read, write, append: beschränkt die Operationen auf den Puffer; siehe open für Details.
• truncate: kürzt die Puffergröße auf null Länge.
• maxsize: gibt eine Größe an, über die der Puffer nicht vergrößert werden darf.
• sizehint: schlägt eine Kapazität des Puffers vor (data muss sizehint!(data, size) implementieren).

Wenn data nicht angegeben ist, ist der Puffer standardmäßig sowohl lesbar als auch schreibbar.

Beispiele

julia> io = IOBuffer();

julia> write(io, "JuliaLang ist eine GitHub-Organisation.", " Es hat viele Mitglieder.")
56

julia> String(take!(io))
"JuliaLang ist eine GitHub-Organisation. Es hat viele Mitglieder."

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

julia> read(io, String)
"JuliaLang ist eine GitHub-Organisation."

julia> write(io, "Das ist nicht schreibbar.")
ERROR: ArgumentError: ensureroom failed, IOBuffer ist nicht schreibbar

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 ist eine GitHub-Organisation.")
34

julia> String(take!(io))
"JuliaLang ist eine GitHub-Organisation"

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)

Erstellen Sie einen schreibgeschützten IOBuffer für die Daten, die dem angegebenen String zugrunde liegen.

Beispiele

julia> io = IOBuffer("Haho");

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

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

take!(b::IOBuffer)

Erhalten Sie den Inhalt eines IOBuffer als Array. Danach wird der IOBuffer auf seinen ursprünglichen Zustand zurückgesetzt.

Beispiele

julia> io = IOBuffer();

julia> write(io, "JuliaLang ist eine GitHub-Organisation.", " Es hat viele Mitglieder.")
56

julia> String(take!(io))
"JuliaLang ist eine GitHub-Organisation. Es hat viele Mitglieder."

Pipe()

Konstruiere ein nicht initialisiertes Pipe-Objekt, insbesondere für die IO-Kommunikation zwischen mehreren Prozessen.

Das entsprechende Ende der Pipe wird automatisch initialisiert, wenn das Objekt beim Erzeugen von Prozessen verwendet wird. Dies kann nützlich sein, um einfach Referenzen in Prozess-Pipelines zu erhalten, z.B.:

julia> err = Pipe()

# Nach diesem `err` wird initialisiert und Sie können `foo`'s
# stderr aus der `err`-Pipe lesen oder `err` an andere Pipelines übergeben.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# Zerstören Sie jetzt die Schreibhälfte der Pipe, damit die Lesehälfte EOF erhält
julia> closewrite(err)

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

Siehe auch Base.link_pipe!.

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

Initialisiere pipe und verlinke den in Endpunkt mit dem out Endpunkt. Die Schlüsselwortargumente reader_supports_async/writer_supports_async entsprechen OVERLAPPED unter Windows und O_NONBLOCK unter POSIX-Systemen. Sie sollten true sein, es sei denn, sie werden von einem externen Programm verwendet (z. B. die Ausgabe eines mit run ausgeführten Befehls).

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

Erstellt ein IOStream Objekt aus einem ganzzahligen Dateideskriptor. Wenn own true ist, wird das Schließen dieses Objekts den zugrunde liegenden Deskriptor schließen. Standardmäßig wird ein IOStream geschlossen, wenn er garbage collected wird. name ermöglicht es Ihnen, den Deskriptor mit einer benannten Datei zu verknüpfen.

flush(stream)

Alle derzeit gepufferten Schreibvorgänge an den angegebenen Stream übermitteln.

close(stream)

Schließt einen I/O-Stream. Führt zuerst ein flush durch.

closewrite(stream)

Fährt die Schreibhälfte eines voll-duplex I/O-Streams herunter. Führt zuerst einen flush durch. Benachrichtigt das andere Ende, dass keine weiteren Daten in die zugrunde liegende Datei geschrieben werden. Dies wird nicht von allen IO-Typen unterstützt.

Wenn implementiert, bewirkt closewrite, dass nachfolgende read- oder eof-Aufrufe, die blockieren würden, stattdessen EOF auslösen oder true zurückgeben. Wenn der Stream bereits geschlossen ist, ist dies idempotent.

Beispiele

julia> io = Base.BufferStream(); # dies blockiert niemals, sodass wir im selben Task lesen und schreiben können

julia> write(io, "request");

julia> # der Aufruf von `read(io)` hier würde für immer blockieren

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

Schreiben Sie die kanonische binäre Darstellung eines Wertes in den angegebenen I/O-Stream oder die Datei. Gibt die Anzahl der in den Stream geschriebenen Bytes zurück. Siehe auch print, um eine Textdarstellung zu schreiben (mit einer Kodierung, die von io abhängen kann).

Die Endianness des geschriebenen Wertes hängt von der Endianness des Host-Systems ab. Konvertieren Sie zu/von einer festen Endianness beim Schreiben/Lesen (z. B. unter Verwendung von htol und ltoh), um Ergebnisse zu erhalten, die plattformübergreifend konsistent sind.

Sie können mehrere Werte mit demselben write-Aufruf schreiben. d.h. die folgenden sind äquivalent:

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

Beispiele

Konsistente Serialisierung:

julia> fname = tempname(); # zufälliger temporärer Dateiname

julia> open(fname,"w") do f
           # Stellen Sie sicher, dass wir 64-Bit-Ganzzahlen in kleiner Endian-Byte-Reihenfolge schreiben
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # Konvertieren Sie zurück in die Host-Byte-Reihenfolge und den Host-Ganzzahltyp
           Int(ltoh(read(f,Int64)))
       end
42

Zusammenführen von Schreibaufrufen:

julia> io = IOBuffer();

julia> write(io, "JuliaLang ist eine GitHub-Organisation.", " Es hat viele Mitglieder.")
56

julia> String(take!(io))
"JuliaLang ist eine GitHub-Organisation. Es hat viele Mitglieder."

julia> write(io, "Manchmal schreiben diese Mitglieder") + write(io, " Dokumentation.")
44

julia> String(take!(io))
"Manchmal schreiben diese Mitglieder Dokumentation."

Benutzerdefinierte einfache Datentypen ohne write-Methoden können geschrieben werden, wenn sie in einem Ref verpackt sind:

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)

Lese einen einzelnen Wert des Typs T von io in kanonischer binärer Darstellung.

Beachte, dass Julia die Endianness nicht für dich konvertiert. Verwende ntoh oder ltoh zu diesem Zweck.

read(io::IO, String)

Lese den gesamten Inhalt von io als String (siehe auch readchomp).

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation");

julia> read(io, Char)
'J': ASCII/Unicode U+004A (Kategorie Lu: Buchstabe, groß)

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation");

julia> read(io, String)
"JuliaLang ist eine GitHub-Organisation"

read(filename::AbstractString)

Lese den gesamten Inhalt einer Datei als Vector{UInt8}.

read(filename::AbstractString, String)

Lese den gesamten Inhalt einer Datei als Zeichenfolge.

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

Öffne eine Datei und lese ihren Inhalt. args wird an read übergeben: dies entspricht open(io->read(io, args...), filename).

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

Lese höchstens nb Bytes von s und gebe einen Vector{UInt8} der gelesenen Bytes zurück.

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

Liest höchstens nb Bytes von s und gibt einen Vector{UInt8} der gelesenen Bytes zurück.

Wenn all true ist (der Standardwert), blockiert diese Funktion wiederholt, um alle angeforderten Bytes zu lesen, bis ein Fehler oder das Ende der Datei auftritt. Wenn all false ist, wird höchstens ein read-Aufruf durchgeführt, und die Menge der zurückgegebenen Daten ist geräteabhängig. Beachten Sie, dass nicht alle Streamtypen die all-Option unterstützen.

read(command::Cmd)

Führen Sie command aus und geben Sie die resultierende Ausgabe als ein Array von Bytes zurück.

read(command::Cmd, String)

Führen Sie command aus und geben Sie die resultierende Ausgabe als String zurück.

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

Lese Binärdaten aus einem I/O-Stream oder einer Datei und fülle array.

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

Lese höchstens nb Bytes aus stream in b und gebe die Anzahl der gelesenen Bytes zurück. Die Größe von b wird bei Bedarf erhöht (d.h. wenn nb größer als length(b) ist und genügend Bytes gelesen werden konnten), aber sie wird niemals verringert.

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

Liest höchstens nb Bytes aus stream in b und gibt die Anzahl der gelesenen Bytes zurück. Die Größe von b wird bei Bedarf erhöht (d.h. wenn nb größer als length(b) ist und genügend Bytes gelesen werden konnten), aber sie wird niemals verringert.

Wenn all true ist (der Standardwert), blockiert diese Funktion wiederholt, um alle angeforderten Bytes zu lesen, bis ein Fehler oder das Ende der Datei auftritt. Wenn all false ist, wird höchstens ein read-Aufruf durchgeführt, und die Menge der zurückgegebenen Daten ist geräteabhängig. Beachten Sie, dass nicht alle Streamtypen die all-Option unterstützen.

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

Kopiere nbytes aus dem IO-Stream-Objekt in ref (konvertiert in einen Zeiger).

Es wird empfohlen, dass Subtypen T<:IO die folgende Methodensignatur überschreiben, um effizientere Implementierungen bereitzustellen: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

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

Kopiere nbytes von ref (in einen Zeiger umgewandelt) in das IO-Objekt.

Es wird empfohlen, dass Untertypen T<:IO die folgende Methodensignatur überschreiben, um effizientere Implementierungen bereitzustellen: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

Gibt ein iterierbares Objekt zurück, das read(io, T) liefert.

Siehe auch skipchars, eachline, readuntil.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.\n Es hat viele Mitglieder.\n");

julia> for c in readeach(io, Char)
           c == '\n' && break
           print(c)
       end
JuliaLang ist eine GitHub-Organisation.

peek(stream[, T=UInt8])

Lese und gebe einen Wert des Typs T aus einem Stream zurück, ohne die aktuelle Position im Stream zu verschieben. Siehe auch startswith(stream, char_or_string).

Beispiele

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (Kategorie Ll: Buchstabe, Kleinbuchstabe)

position(l::Lexer)

Gibt die aktuelle Position zurück.

position(en)

Holen Sie sich die aktuelle Position eines Streams.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.");

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)

Suchen Sie einen Stream an die angegebene Position.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (Kategorie Lu: Buchstabe, Großbuchstabe)

seekstart(s)

Bewege einen Stream zu seinem Anfang.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (Kategorie Lu: Buchstabe, Großbuchstabe)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (Kategorie Lu: Buchstabe, Großbuchstabe)

seekend(s)

Bewege einen Stream zu seinem Ende.

skip(s, offset)

Suchen Sie einen Stream relativ zur aktuellen Position.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.");

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (Kategorie Lu: Buchstabe, Großbuchstabe)

mark(s::IO)

Fügen Sie eine Markierung an der aktuellen Position des Streams s hinzu. Gibt die markierte Position zurück.

Siehe auch unmark, reset, ismarked.

unmark(s::IO)

Entfernt ein Markierung von dem Stream s. Gibt true zurück, wenn der Stream markiert war, andernfalls false.

Siehe auch mark, reset, ismarked.

reset(s::IO)

Setzt einen Stream s auf eine zuvor markierte Position zurück und entfernt die Markierung. Gibt die zuvor markierte Position zurück. Wirft einen Fehler, wenn der Stream nicht markiert ist.

Siehe auch mark, unmark, ismarked.

ismarked(s::IO)

Gibt true zurück, wenn der Stream s markiert ist.

Siehe auch mark, unmark, reset.

eof(stream) -> Bool

Testen, ob ein I/O-Stream am Ende der Datei ist. Wenn der Stream noch nicht erschöpft ist, wird diese Funktion blockieren, um auf weitere Daten zu warten, falls erforderlich, und dann false zurückgeben. Daher ist es immer sicher, ein Byte zu lesen, nachdem eof false zurückgegeben hat. eof gibt false zurück, solange gepufferte Daten noch verfügbar sind, selbst wenn das entfernte Ende einer Verbindung geschlossen ist.

Beispiele

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

Bestimmen Sie, ob ein Stream schreibgeschützt ist.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

Gibt true zurück, wenn die Zugriffsberechtigungen für den angegebenen path das Schreiben durch den aktuellen Benutzer erlauben.

Siehe auch ispath, isexecutable, isreadable.

iswritable(io) -> Bool

Gibt false zurück, wenn das angegebene IO-Objekt nicht beschreibbar ist.

Beispiele

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)

Gibt true zurück, wenn die Zugriffsberechtigungen für den angegebenen path das Lesen durch den aktuellen Benutzer erlauben.

Siehe auch ispath, isexecutable, iswritable.

isreadable(io) -> Bool

Gibt false zurück, wenn das angegebene IO-Objekt nicht lesbar ist.

Beispiele

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)

Gibt true zurück, wenn der angegebene path ausführbare Berechtigungen hat.

Siehe auch ispath, isreadable, iswritable.

isopen(object) -> Bool

Bestimmen Sie, ob ein Objekt - wie ein Stream oder Timer - noch nicht geschlossen ist. Sobald ein Objekt geschlossen ist, wird es niemals ein neues Ereignis erzeugen. Da ein geschlossener Stream jedoch möglicherweise noch Daten in seinem Puffer hat, verwenden Sie eof, um die Möglichkeit zu überprüfen, Daten zu lesen. Verwenden Sie das FileWatching-Paket, um benachrichtigt zu werden, wenn ein Stream möglicherweise beschreibbar oder lesbar ist.

Beispiele

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

Gibt den Dateideskriptor zurück, der den Stream oder die Datei unterstützt. Beachten Sie, dass diese Funktion nur für synchrone File- und IOStream-Objekte gilt, nicht für die asynchronen Streams.

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

Leitet eine Teilmenge der Streams stdin, stderr, stdout um. Jedes Argument muss ein IOStream, TTY, Pipe, Socket oder devnull sein.

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

Leitet eine Teilmenge der Streams stdin, stderr, stdout um, ruftf()` auf und stellt jeden Stream wieder her.

Mögliche Werte für jeden Stream sind:

• nothing, was bedeutet, dass der Stream nicht umgeleitet werden soll.
• path::AbstractString, der den Stream auf die Datei unter path umleitet.
• io, ein IOStream, TTY, Pipe, Socket oder devnull.

Beispiele

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"

Randfälle

Es ist möglich, dass dasselbe Argument an stdout und stderr übergeben wird:

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

Es wird jedoch nicht unterstützt, zwei unterschiedliche Deskriptoren derselben Datei zu übergeben.

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

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

julia> redirect_stdio(f, stdout=io1, stderr=io2) # nicht unterstützt

Außerdem darf das Argument stdin nicht derselbe Deskriptor wie stdout oder stderr sein.

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # nicht unterstützt

redirect_stdout([stream]) -> stream

Erstellt ein Pipe, an das alle C- und Julia-Ebene stdout Ausgaben umgeleitet werden. Gibt einen Stream zurück, der die Enden des Pipes darstellt. Daten, die in stdout geschrieben werden, können jetzt vom rd Ende des Pipes gelesen werden.

!!! Hinweis stream muss ein kompatibles Objekt sein, wie ein IOStream, TTY, Pipe, Socket oder devnull.

Siehe auch redirect_stdio.

redirect_stdout(f::Function, stream)

Führen Sie die Funktion f aus, während stdout an stream umgeleitet wird. Nach Abschluss wird stdout auf seine vorherige Einstellung zurückgesetzt.

redirect_stderr([stream]) -> stream

Wie redirect_stdout, aber für stderr.

!!! Hinweis stream muss ein kompatibles Objekt sein, wie ein IOStream, TTY, Pipe, Socket oder devnull.

Siehe auch redirect_stdio.

redirect_stderr(f::Function, stream)

Führen Sie die Funktion f aus, während Sie stderr an stream umleiten. Nach Abschluss wird stderr auf seine vorherige Einstellung zurückgesetzt.

redirect_stdin([stream]) -> stream

Wie redirect_stdout, aber für stdin. Beachten Sie, dass die Richtung des Streams umgekehrt ist.

!!! Hinweis stream muss ein kompatibles Objekt sein, wie z.B. ein IOStream, TTY, Pipe, Socket oder devnull.

Siehe auch redirect_stdio.

redirect_stdin(f::Function, stream)

Führen Sie die Funktion f aus, während stdin auf stream umgeleitet wird. Nach Abschluss wird stdin auf seine vorherige Einstellung zurückgesetzt.

readchomp(x)

Liest den gesamten Inhalt von x als Zeichenfolge und entfernt eine einzelne abschließende neue Zeile, falls vorhanden. Entspricht chomp(read(x, String)).

Beispiele

julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\nEs hat viele Mitglieder.\n");

julia> readchomp("my_file.txt")
"JuliaLang ist eine GitHub-Organisation.\nEs hat viele Mitglieder."

julia> rm("my_file.txt");

truncate(file, n)

Ändert die Größe der Datei oder des Puffers, die durch das erste Argument angegeben ist, auf genau n Bytes und füllt zuvor nicht zugewiesenen Speicher mit '\0', wenn die Datei oder der Puffer vergrößert wird.

Beispiele

julia> io = IOBuffer();

julia> write(io, "JuliaLang ist eine GitHub-Organisation.")
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 ist eine "

julia> io = IOBuffer();

julia> write(io, "JuliaLang ist eine GitHub-Organisation.");

julia> truncate(io, 40);

julia> String(take!(io))
"JuliaLang ist eine GitHub-Organisation.\0\0\0\0\0"

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

Bewege den Stream io so, dass das nächste gelesene Zeichen das erste verbleibende ist, für das predicate false zurückgibt. Wenn das Schlüsselwort-Argument linecomment angegeben ist, werden alle Zeichen von diesem Zeichen bis zum Beginn der nächsten Zeile ignoriert.

Beispiele

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

Liest io bis zum Ende des Streams/der Datei und zählt die Anzahl der Zeilen. Um eine Datei anzugeben, übergeben Sie den Dateinamen als erstes Argument. EOL-Markierungen, die nicht '\n' sind, werden unterstützt, indem sie als zweites Argument übergeben werden. Die letzte nicht-leere Zeile von io wird gezählt, auch wenn sie nicht mit dem EOL endet, was der Länge entspricht, die von eachline und readlines zurückgegeben wird.

Um die Zeilen eines String zu zählen, kann countlines(IOBuffer(str)) verwendet werden.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.\n");

julia> countlines(io)
1

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.");

julia> countlines(io)
1

julia> eof(io) # Zeilen zählen bewegt den Dateizeiger
true

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation.");

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

julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\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))

Ein IOBuffer, der das Lesen ermöglicht und Schreibvorgänge durch Anhängen durchführt. Suchen und Truncieren werden nicht unterstützt. Siehe IOBuffer für die verfügbaren Konstruktoren. Wenn data angegeben ist, wird ein PipeBuffer erstellt, um auf einen Datenvektor zu arbeiten, wobei optional eine Größe angegeben werden kann, über die das zugrunde liegende Array nicht vergrößert werden darf.

readavailable(stream)

Lese verfügbare gepufferte Daten aus einem Stream. Tatsächliche I/O wird nur durchgeführt, wenn noch keine Daten gepuffert wurden. Das Ergebnis ist ein Vector{UInt8}.

IOContext

IOContext bietet einen Mechanismus zum Übertragen von Ausgabekonfigurationseinstellungen zwischen show Methoden.

Kurz gesagt, es ist ein unveränderliches Wörterbuch, das eine Unterklasse von IO ist. Es unterstützt Standard-Wörterbuchoperationen wie getindex und kann auch als I/O-Stream verwendet werden.

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

Erstellen Sie ein IOContext, das einen gegebenen Stream umschließt und die angegebenen key=>value-Paare zu den Eigenschaften dieses Streams hinzufügt (beachten Sie, dass io selbst ein IOContext sein kann).

• Verwenden Sie (key => value) in io, um zu sehen, ob diese spezielle Kombination in der Eigenschaftenmenge enthalten ist.
• Verwenden Sie get(io, key, default), um den aktuellsten Wert für einen bestimmten Schlüssel abzurufen.

Die folgenden Eigenschaften sind allgemein in Gebrauch:

• :compact: Boolean, der angibt, dass Werte kompakter gedruckt werden sollten, z. B. dass Zahlen mit weniger Ziffern gedruckt werden sollten. Dies wird beim Drucken von Array-Elementen gesetzt. Die :compact-Ausgabe sollte keine Zeilenumbrüche enthalten.
• :limit: Boolean, der angibt, dass Container abgeschnitten werden sollten, z. B. dass … anstelle der meisten Elemente angezeigt wird.
• :displaysize: Ein Tuple{Int,Int}, das die Größe in Zeilen und Spalten angibt, die für die Textausgabe verwendet werden soll. Dies kann verwendet werden, um die Anzeigegröße für aufgerufene Funktionen zu überschreiben, aber um die Größe des Bildschirms zu erhalten, verwenden Sie die Funktion displaysize.
• :typeinfo: ein Type, der die Informationen charakterisiert, die bereits über den Typ des Objekts, das angezeigt werden soll, gedruckt wurden. Dies ist hauptsächlich nützlich, wenn eine Sammlung von Objekten desselben Typs angezeigt wird, sodass redundante Typinformationen vermieden werden können (z. B. kann [Float16(0)] als "Float16[0.0]" anstelle von "Float16[Float16(0.0)]" angezeigt werden: während die Elemente des Arrays angezeigt werden, wird die :typeinfo-Eigenschaft auf Float16 gesetzt).
• :color: Boolean, der angibt, ob ANSI-Farben-/Escape-Codes unterstützt/erwartet werden. Standardmäßig wird dies bestimmt, indem geprüft wird, ob io ein kompatibles Terminal ist und durch ein beliebiges --color-Kommandozeilenflag, als julia gestartet wurde.

Beispiele

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 (generische Funktion mit 1 Methode)

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

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

Erstellen Sie einen IOContext, der ein alternatives IO umschließt, aber die Eigenschaften von context erbt.

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

Schreibt eine Textdarstellung eines Wertes x in den Ausgabestrom io. Neue Typen T sollten show(io::IO, x::T) überladen. Die von show verwendete Darstellung umfasst in der Regel Julia-spezifische Formatierung und Typinformationen und sollte, wenn möglich, als Julia-Code analysierbar sein.

repr gibt die Ausgabe von show als Zeichenfolge zurück.

Für eine ausführlichere, menschenlesbare Textausgabe für Objekte des Typs T definieren Sie zusätzlich show(io::IO, ::MIME"text/plain", ::T). Es wird empfohlen, den :compact IOContext Schlüssel (häufig überprüft als get(io, :compact, false)::Bool) von io in solchen Methoden zu überprüfen, da einige Container ihre Elemente anzeigen, indem sie diese Methode mit :compact => true aufrufen.

Siehe auch print, das un-dekorierte Darstellungen schreibt.

Beispiele

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

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

Druckt in einen Stream io oder gibt einen String str zurück, der eine kurze Beschreibung eines Wertes liefert. Standardmäßig wird string(typeof(x)) zurückgegeben, z.B. Int64.

Für Arrays wird ein String mit Größen- und Typinformationen zurückgegeben, z.B. 10-element Array{Int64,1}.

Beispiele

julia> summary(1)
"Int64"

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

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

Schreibt in io (oder in den Standardausgabestrom stdout, wenn io nicht angegeben ist) eine kanonische (un-dekorierte) Textdarstellung. Die von print verwendete Darstellung umfasst minimale Formatierung und versucht, Julia-spezifische Details zu vermeiden.

print greift auf show zurück, sodass die meisten Typen einfach show definieren sollten. Definieren Sie print, wenn Ihr Typ eine separate "einfache" Darstellung hat. Zum Beispiel zeigt show Zeichenfolgen mit Anführungszeichen an, und print zeigt Zeichenfolgen ohne Anführungszeichen an.

Siehe auch println, string, printstyled.

Beispiele

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

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

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

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

Druckt (unter Verwendung von print) xs auf io, gefolgt von einem Zeilenumbruch. Wenn io nicht angegeben ist, wird auf den Standardausgabestrom stdout gedruckt.

Siehe auch printstyled, um Farben usw. hinzuzufügen.

Beispiele

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)

Druckt xs in einer Farbe, die als Symbol oder Ganzzahl angegeben ist, optional fett.

Das Schlüsselwort color kann einen der Werte :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 oder :yellow oder eine Ganzzahl zwischen 0 und 255 annehmen. Beachten Sie, dass nicht alle Terminals 256 Farben unterstützen.

Die Schlüsselwörter bold=true, italic=true, underline=true, blink=true sind selbsterklärend. Das Schlüsselwort reverse=true druckt mit vertauschten Vorder- und Hintergrundfarben, und hidden=true sollte im Terminal unsichtbar sein, kann aber dennoch kopiert werden. Diese Eigenschaften können in beliebiger Kombination verwendet werden.

Siehe auch print, println, show.

!!! Hinweis Nicht alle Terminals unterstützen kursiven Text. Einige Terminals interpretieren kursiv als umgekehrt oder blinkend.

!!! Kompatibilität "Julia 1.7" Schlüsselwörter außer color und bold wurden in Julia 1.7 hinzugefügt.

!!! Kompatibilität "Julia 1.10" Unterstützung für kursiven Text wurde in Julia 1.10 hinzugefügt.

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

Rufen Sie die angegebene Funktion mit einem I/O-Stream und den bereitgestellten zusätzlichen Argumenten auf. Alles, was in diesen I/O-Stream geschrieben wird, wird als String zurückgegeben. context kann ein IOContext sein, dessen Eigenschaften verwendet werden, ein Pair, das eine Eigenschaft und ihren Wert angibt, oder ein Tupel von Pair, das mehrere Eigenschaften und deren Werte angibt. sizehint schlägt die Kapazität des Puffers (in Bytes) vor.

Das optionale Schlüsselwort-Argument context kann auf ein :key=>value-Paar, ein Tupel von :key=>value-Paaren oder ein IO- oder IOContext-Objekt gesetzt werden, dessen Attribute für den an f übergebenen I/O-Stream verwendet werden. Der optionale sizehint ist eine empfohlene Größe (in Bytes), die für den Puffer, der zum Schreiben des Strings verwendet wird, zugewiesen werden soll.

Beispiele

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)

Zeigt eine beschreibende Darstellung eines Ausnahmeobjekts e. Diese Methode wird verwendet, um die Ausnahme nach einem Aufruf von throw anzuzeigen.

Beispiele

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)

Zeigt jeden Teil der Darstellung eines Wertes an. Die Tiefe der Ausgabe wird auf maxdepth gekürzt.

Beispiele

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

Zeige jeden Teil der Darstellung des gegebenen Ausdrucks. Entspricht dump(:(expr)).

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

Liest eine einzelne Zeile Text aus dem angegebenen I/O-Stream oder der Datei (standardmäßig stdin). Beim Lesen aus einer Datei wird angenommen, dass der Text in UTF-8 kodiert ist. Zeilen im Eingabestrom enden mit '\n' oder "\r\n" oder dem Ende eines Eingabestroms. Wenn keep false ist (wie standardmäßig), werden diese nachfolgenden Zeilenumbrüche von der Zeile entfernt, bevor sie zurückgegeben wird. Wenn keep true ist, werden sie als Teil der Zeile zurückgegeben.

Gibt einen String zurück. Siehe auch copyline, um stattdessen in-place in einen anderen Stream zu schreiben (der ein vorab zugewiesenes IOBuffer sein kann).

Siehe auch readuntil zum Lesen bis zu allgemeineren Trennzeichen.

Beispiele

julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\nEs hat viele Mitglieder.\n");

julia> readline("my_file.txt")
"JuliaLang ist eine GitHub-Organisation."

julia> readline("my_file.txt", keep=true)
"JuliaLang ist eine GitHub-Organisation.\n"

julia> rm("my_file.txt")

julia> print("Geben Sie Ihren Namen ein: ")
Geben Sie Ihren Namen ein:

julia> your_name = readline()
Logan
"Logan"

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

Lese einen String aus einem I/O stream oder einer Datei bis zum angegebenen Trennzeichen. Das Trennzeichen kann ein UInt8, AbstractChar, String oder Vektor sein. Das Schlüsselwort-Argument keep steuert, ob das Trennzeichen im Ergebnis enthalten ist. Der Text wird als in UTF-8 kodiert angenommen.

Gibt einen String zurück, wenn delim ein AbstractChar oder ein String ist, andernfalls wird ein Vector{typeof(delim)} zurückgegeben. Siehe auch copyuntil, um stattdessen in-place in einen anderen Stream zu schreiben (der ein vorab zugewiesenes IOBuffer sein kann).

Beispiele

julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\nEs hat viele Mitglieder.\n");

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

julia> readuntil("my_file.txt", '.', keep = true)
"JuliaLang ist eine GitHub-Organisation."

julia> rm("my_file.txt")

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

Liest alle Zeilen eines I/O-Streams oder einer Datei als Vektor von Strings. Das Verhalten entspricht dem Speichern des Ergebnisses des wiederholten Lesens von readline mit denselben Argumenten und dem Speichern der resultierenden Zeilen als Vektor von Strings. Siehe auch eachline, um über die Zeilen zu iterieren, ohne sie alle auf einmal zu lesen.

Beispiele

julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\nEs hat viele Mitglieder.\n");

julia> readlines("my_file.txt")
2-element Vector{String}:
 "JuliaLang ist eine GitHub-Organisation."
 "Es hat viele Mitglieder."

julia> readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "JuliaLang ist eine GitHub-Organisation.\n"
 "Es hat viele Mitglieder.\n"

julia> rm("my_file.txt")

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

Erstellen Sie ein iterierbares EachLine-Objekt, das jede Zeile aus einem I/O-Stream oder einer Datei liefert. Die Iteration ruft wiederholt readline mit dem Stream-Argument auf, wobei keep übergeben wird, um zu bestimmen, ob nachfolgende Zeilenendezeichen beibehalten werden. Wenn mit einem Dateinamen aufgerufen, wird die Datei zu Beginn der Iteration einmal geöffnet und am Ende geschlossen. Wenn die Iteration unterbrochen wird, wird die Datei geschlossen, wenn das EachLine-Objekt garbage collected wird.

Um über jede Zeile eines String zu iterieren, kann eachline(IOBuffer(str)) verwendet werden.

Iterators.reverse kann auf ein EachLine-Objekt angewendet werden, um die Zeilen in umgekehrter Reihenfolge zu lesen (für Dateien, Puffer und andere I/O-Streams, die seek unterstützen), und first oder last können verwendet werden, um die ersten oder letzten Zeilen zu extrahieren.

Beispiele

julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\n Es hat viele Mitglieder.\n");

julia> for line in eachline("my_file.txt")
           print(line)
       end
JuliaLang ist eine GitHub-Organisation. Es hat viele Mitglieder.

julia> rm("my_file.txt");

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

Kopiert eine einzelne Zeile Text von einem I/O `stream` oder einer Datei in den `out`-Stream und gibt `out` zurück.

Beim Lesen aus einer Datei wird angenommen, dass der Text in UTF-8 kodiert ist. Zeilen im Eingangsbereich enden mit `'\n'` oder `"\r\n"` oder dem Ende eines Eingabestreams. Wenn `keep` false ist (wie es standardmäßig der Fall ist), werden diese nachfolgenden Zeilenumbrüche von der Zeile entfernt, bevor sie zurückgegeben wird. Wenn `keep` true ist, werden sie als Teil der Zeile zurückgegeben.

Ähnlich wie [`readline`](@ref), das einen `String` zurückgibt; im Gegensatz dazu schreibt `copyline` direkt in `out`, ohne einen String zuzuweisen. (Dies kann beispielsweise verwendet werden, um Daten in einen vorab zugewiesenen [`IOBuffer`](@ref) zu lesen.)

Siehe auch [`copyuntil`](@ref) zum Lesen bis zu allgemeineren Trennzeichen.

# Beispiele

jldoctest julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\nEs hat viele Mitglieder.\n");

julia> String(take!(copyline(IOBuffer(), "my_file.txt"))) "JuliaLang ist eine GitHub-Organisation."

julia> String(take!(copyline(IOBuffer(), "my_file.txt", keep=true))) "JuliaLang ist eine GitHub-Organisation.\n"

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

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

Kopiert einen String aus einem I/O `stream` oder einer Datei bis zum angegebenen Trennzeichen in den `out`-Stream und gibt `out` zurück. Das Trennzeichen kann ein `UInt8`, `AbstractChar`, String oder Vektor sein. Das Schlüsselwort-Argument `keep` steuert, ob das Trennzeichen im Ergebnis enthalten ist. Der Text wird als in UTF-8 kodiert angenommen.

Ähnlich wie [`readuntil`](@ref), das einen `String` zurückgibt; im Gegensatz dazu schreibt `copyuntil` direkt in `out`, ohne einen String zuzuweisen. (Dies kann beispielsweise verwendet werden, um Daten in einen vorab zugewiesenen [`IOBuffer`](@ref) zu lesen.)

# Beispiele

jldoctest julia> write("my_file.txt", "JuliaLang ist eine GitHub-Organisation.\nEs hat viele Mitglieder.\n");

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

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", '.', keep = true))) "JuliaLang ist eine GitHub-Organisation."

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

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

Gibt die nominale Größe des Bildschirms zurück, die für die Ausgabe an dieses IO-Objekt verwendet werden kann. Wenn keine Eingabe bereitgestellt wird, werden die Umgebungsvariablen LINES und COLUMNS gelesen. Wenn diese nicht gesetzt sind, wird eine Standardgröße von (24, 80) zurückgegeben.

Beispiele

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

Um die Größe Ihres TTY zu erhalten,

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

Abstrakte Superklasse für reichhaltige Anzeigeausgabegeräte. TextDisplay ist eine Unterklasse davon.

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

Zeige x mit der obersten anwendbaren Anzeige im Anzeige-Stack an, typischerweise unter Verwendung der reichhaltigsten unterstützten Multimedia-Ausgabe für x, wobei die einfache Textausgabe stdout als Fallback dient. Die Variante display(d, x) versucht, x nur auf der angegebenen Anzeige d anzuzeigen und wirft einen MethodError, wenn d Objekte dieses Typs nicht anzeigen kann.

Im Allgemeinen kann man nicht davon ausgehen, dass die Ausgabe von display an stdout geht (im Gegensatz zu print(x) oder show(x)). Zum Beispiel kann display(x) ein separates Fenster mit einem Bild öffnen. display(x) bedeutet "zeige x auf die beste Weise, die du für das aktuelle Ausgabegerät(e) kannst." Wenn du eine REPL-ähnliche Textausgabe möchtest, die garantiert an stdout geht, verwende stattdessen show(stdout, "text/plain", x).

Es gibt auch zwei Varianten mit einem mime-Argument (einem MIME-Typ-String, wie "image/png"), die versuchen, x nur mit dem angeforderten MIME-Typ anzuzeigen, und einen MethodError werfen, wenn dieser Typ von den Anzeigen oder von x nicht unterstützt wird. Mit diesen Varianten kann man auch die "rohen" Daten im angeforderten MIME-Typ bereitstellen, indem man x::AbstractString (für MIME-Typen mit textbasierter Speicherung, wie text/html oder application/postscript) oder x::Vector{UInt8} (für binäre MIME-Typen) übergibt.

Um anzupassen, wie Instanzen eines Typs angezeigt werden, überlade show anstelle von display, wie im Handbuchabschnitt über benutzerdefiniertes hübsches Drucken erklärt.

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

Standardmäßig rufen die redisplay-Funktionen einfach display auf. Einige Anzeige-Backends können jedoch redisplay überschreiben, um eine vorhandene Anzeige von x (falls vorhanden) zu ändern. Die Verwendung von redisplay ist auch ein Hinweis an das Backend, dass x möglicherweise mehrere Male neu angezeigt werden kann, und das Backend kann entscheiden, die Anzeige bis (zum Beispiel) zur nächsten interaktiven Eingabeaufforderung zu verschieben.

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

Gibt einen booleschen Wert zurück, der angibt, ob der angegebene mime-Typ (String) von einem der Displays im aktuellen Display-Stack oder speziell vom Display d in der zweiten Variante angezeigt werden kann.

show(io::IO, mime, x)

Die display Funktionen rufen letztendlich show auf, um ein Objekt x als einen gegebenen mime Typ in einen gegebenen I/O Stream io (normalerweise ein Speicherpuffer) zu schreiben, wenn möglich. Um eine reichhaltige Multimedia-Darstellung eines benutzerdefinierten Typs T bereitzustellen, ist es nur notwendig, eine neue show Methode für T zu definieren, über: show(io, ::MIME"mime", x::T) = ..., wobei mime eine MIME-Typ-String ist und der Funktionskörper write (oder ähnliches) aufruft, um diese Darstellung von x in io zu schreiben. (Beachten Sie, dass die MIME"" Notation nur literale Strings unterstützt; um MIME Typen flexibler zu konstruieren, verwenden Sie MIME{Symbol("")}.)

Zum Beispiel, wenn Sie einen MyImage Typ definieren und wissen, wie man ihn in eine PNG-Datei schreibt, könnten Sie eine Funktion show(io, ::MIME"image/png", x::MyImage) = ... definieren, um Ihre Bilder auf jedem PNG-fähigen AbstractDisplay (wie IJulia) anzuzeigen. Wie gewohnt, stellen Sie sicher, dass Sie import Base.show verwenden, um neue Methoden zur eingebauten Julia-Funktion show hinzuzufügen.

Technisch gesehen definiert das MIME"mime" Makro einen Singleton-Typ für den gegebenen mime String, was es uns ermöglicht, Julias Dispatch-Mechanismen auszunutzen, um zu bestimmen, wie Objekte eines bestimmten Typs angezeigt werden.

Der Standard-MIME-Typ ist MIME"text/plain". Es gibt eine Fallback-Definition für text/plain Ausgabe, die show mit 2 Argumenten aufruft, sodass es nicht immer notwendig ist, eine Methode für diesen Fall hinzuzufügen. Wenn ein Typ jedoch von einer benutzerdefinierten menschenlesbaren Ausgabe profitiert, sollte show(::IO, ::MIME"text/plain", ::T) definiert werden. Zum Beispiel verwendet der Day Typ 1 day als Ausgabe für den text/plain MIME-Typ und Day(1) als Ausgabe von show mit 2 Argumenten.

Beispiele

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

Containertypen implementieren im Allgemeinen show mit 3 Argumenten, indem sie show(io, MIME"text/plain"(), x) für Elemente x aufrufen, wobei :compact => true in einem IOContext gesetzt ist, das als erstes Argument übergeben wird.

showable(mime, x)

Gibt einen booleschen Wert zurück, der angibt, ob das Objekt x als der angegebene mime-Typ geschrieben werden kann.

(Im Allgemeinen wird dies automatisch durch die Existenz der entsprechenden show-Methode für typeof(x) bestimmt. Einige Typen bieten benutzerdefinierte showable-Methoden an; zum Beispiel, wenn die verfügbaren MIME-Formate von dem Wert von x abhängen.)

Beispiele

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

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

repr(mime, x; context=nothing)

Gibt eine AbstractString oder Vector{UInt8} zurück, die die Darstellung von x im angeforderten mime-Typ enthält, wie von show(io, mime, x) geschrieben (wirft einen MethodError, wenn keine geeignete show verfügbar ist). Eine AbstractString wird für MIME-Typen mit textuellen Darstellungen (wie "text/html" oder "application/postscript") zurückgegeben, während binäre Daten als Vector{UInt8} zurückgegeben werden. (Die Funktion istextmime(mime) gibt zurück, ob Julia einen bestimmten mime-Typ als Text behandelt.)

Das optionale Schlüsselwort-Argument context kann auf ein :key=>value-Paar oder ein IO- oder IOContext-Objekt gesetzt werden, dessen Attribute für den I/O-Stream verwendet werden, der an show übergeben wird.

In einem speziellen Fall, wenn x eine AbstractString (für textuelle MIME-Typen) oder ein Vector{UInt8} (für binäre MIME-Typen) ist, geht die repr-Funktion davon aus, dass x bereits im angeforderten mime-Format vorliegt und gibt einfach x zurück. Dieser Sonderfall gilt nicht für den MIME-Typ "text/plain". Dies ist nützlich, damit Rohdaten an display(m::MIME, x) übergeben werden können.

Insbesondere ist repr("text/plain", x) typischerweise eine "schön formatierte" Version von x, die für den menschlichen Konsum gedacht ist. Siehe auch repr(x), um stattdessen eine Zeichenfolge zurückzugeben, die show(x) entspricht und näher daran sein könnte, wie der Wert von x in Julia eingegeben werden würde.

Beispiele

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

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

MIME

Ein Typ, der ein standardisiertes Internetdatenformat darstellt. "MIME" steht für "Multipurpose Internet Mail Extensions", da der Standard ursprünglich verwendet wurde, um Multimedia-Anhänge an E-Mail-Nachrichten zu beschreiben.

Ein MIME-Objekt kann als zweites Argument an show übergeben werden, um die Ausgabe in diesem Format anzufordern.

Beispiele

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

@MIME_str

Ein Komfort-Makro zum Schreiben von MIME Typen, das typischerweise verwendet wird, wenn Methoden zu show hinzugefügt werden. Zum Beispiel könnte die Syntax show(io::IO, ::MIME"text/html", x::MyType) = ... verwendet werden, um zu definieren, wie eine HTML-Darstellung von MyType geschrieben wird.

pushdisplay(d::AbstractDisplay)

Schiebt ein neues Display d oben auf den globalen Display-Backend-Stack. Der Aufruf von display(x) oder display(mime, x) zeigt x auf dem obersten kompatiblen Backend im Stack an (d.h. dem obersten Backend, das keinen MethodError auslöst).

popdisplay()
popdisplay(d::AbstractDisplay)

Entfernt das oberste Backend vom Display-Backend-Stack oder die oberste Kopie von d in der zweiten Variante.

TextDisplay(io::IO)

Gibt ein TextDisplay <: AbstractDisplay zurück, das jedes Objekt als MIME-Typ text/plain (standardmäßig) anzeigt und die Textdarstellung in den angegebenen I/O-Stream schreibt. (So werden Objekte in der Julia REPL ausgegeben.)

istextmime(m::MIME)

Bestimmen Sie, ob ein MIME-Typ Textdaten ist. MIME-Typen werden als Binärdaten angesehen, mit Ausnahme einer Reihe von Typen, die als Textdaten bekannt sind (möglicherweise Unicode).

Beispiele

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

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

bytesavailable(io)

Gibt die Anzahl der Bytes zurück, die zum Lesen verfügbar sind, bevor ein Lesevorgang aus diesem Stream oder Puffer blockiert.

Beispiele

julia> io = IOBuffer("JuliaLang ist eine GitHub-Organisation");

julia> bytesavailable(io)
34

ntoh(x)

Konvertiert die Endianness eines Wertes von Netzwerk-Byte-Reihenfolge (Big-Endian) zu der vom Host verwendeten.

hton(x)

Konvertiert die Endianness eines Wertes von der vom Host verwendeten in die Netzwerk-Byte-Reihenfolge (Big-Endian).

ltoh(x)

Konvertiert die Endianness eines Wertes von Little-endian in die vom Host verwendete.

htol(x)

Konvertiert die Endianness eines Wertes von der vom Host verwendeten in Little-endian.

ENDIAN_BOM

Das 32-Bit-Byte-Order-Mark zeigt die native Byte-Reihenfolge der Host-Maschine an. Little-Endian-Maschinen enthalten den Wert 0x04030201. Big-Endian-Maschinen enthalten den Wert 0x01020304.