Essentials

exit(code=0)

Beenden Sie das Programm mit einem Exit-Code. Der Standard-Exit-Code ist null, was anzeigt, dass das Programm erfolgreich abgeschlossen wurde. In einer interaktiven Sitzung kann exit() mit der Tastenkombination ^D aufgerufen werden.

atexit(f)

Registrieren Sie eine Null- oder Ein-Argument-Funktion f(), die beim Prozessausstieg aufgerufen wird. atexit()-Hooks werden in umgekehrter Reihenfolge (LIFO) aufgerufen und laufen vor den Objektfinalisierern.

Wenn f eine Methode für ein ganzzahliges Argument definiert hat, wird sie als f(n::Int32) aufgerufen, wobei n der aktuelle Exit-Code ist, andernfalls wird sie als f() aufgerufen.

Exit-Hooks dürfen exit(n) aufrufen, in diesem Fall wird Julia mit dem Exit-Code n (anstatt des ursprünglichen Exit-Codes) beendet. Wenn mehr als ein Exit-Hook exit(n) aufruft, wird Julia mit dem Exit-Code beendet, der dem zuletzt aufgerufenen Exit-Hook entspricht, der exit(n) aufruft. (Da Exit-Hooks in LIFO-Reihenfolge aufgerufen werden, ist "zuletzt aufgerufen" gleichbedeutend mit "zuerst registriert".)

Hinweis: Sobald alle Exit-Hooks aufgerufen wurden, können keine weiteren Exit-Hooks registriert werden, und jeder Aufruf von atexit(f) nach Abschluss aller Hooks wird eine Ausnahme auslösen. Diese Situation kann auftreten, wenn Sie Exit-Hooks aus Hintergrund-Tasks registrieren, die möglicherweise während des Herunterfahrens weiterhin gleichzeitig ausgeführt werden.

isinteractive() -> Bool

Bestimmen Sie, ob Julia in einer interaktiven Sitzung läuft.

Base.summarysize(obj; exclude=Union{...}, chargeall=Union{...}) -> Int

Berechnet die Menge an Speicher, in Bytes, die von allen einzigartigen Objekten verwendet wird, die vom Argument erreichbar sind.

Schlüsselwort-Argumente

• exclude: gibt die Typen von Objekten an, die von der Traversierung ausgeschlossen werden sollen.
• chargeall: gibt die Typen von Objekten an, deren Größe aller Felder immer berechnet werden soll, selbst wenn diese Felder normalerweise ausgeschlossen würden.

Siehe auch sizeof.

Beispiele

julia> Base.summarysize(1.0)
8

julia> Base.summarysize(Ref(rand(100)))
848

julia> sizeof(Ref(rand(100)))
8

__precompile__(isprecompilable::Bool)

Geben Sie an, ob die Datei, die diese Funktion aufruft, vorcompilierbar ist, standardmäßig true. Wenn ein Modul oder eine Datei nicht sicher vorcompilierbar ist, sollte es __precompile__(false) aufrufen, um einen Fehler auszulösen, wenn Julia versucht, es vorzukompilieren.

Base.include([mapexpr::Function,] m::Module, path::AbstractString)

Bewerten Sie den Inhalt der Eingabedatei im globalen Geltungsbereich des Moduls m. Jedes Modul (außer den mit baremodule definierten) hat seine eigene Definition von include, die das Argument m weglässt, was die Datei in diesem Modul auswertet. Gibt das Ergebnis des zuletzt ausgewerteten Ausdrucks der Eingabedatei zurück. Während des Einschlusses wird ein aufgabenlokaler Einschluss-Pfad auf das Verzeichnis gesetzt, das die Datei enthält. Verschachtelte Aufrufe von include suchen relativ zu diesem Pfad. Diese Funktion wird typischerweise verwendet, um Quellcode interaktiv zu laden oder um Dateien in Paketen zu kombinieren, die in mehrere Quelldateien aufgeteilt sind.

Das optionale erste Argument mapexpr kann verwendet werden, um den eingeschlossenen Code zu transformieren, bevor er ausgewertet wird: für jeden geparsten Ausdruck expr in path wertet die Funktion include tatsächlich mapexpr(expr) aus. Wenn es weggelassen wird, wird mapexpr standardmäßig auf identity gesetzt.

include([mapexpr::Function,] path::AbstractString)

Bewerten Sie den Inhalt der Eingabedatei im globalen Geltungsbereich des umschließenden Moduls. Jedes Modul (außer den mit baremodule definierten) hat seine eigene Definition von include, die die Datei in diesem Modul auswertet. Gibt das Ergebnis des letzten ausgewerteten Ausdrucks der Eingabedatei zurück. Während des Einschlusses wird ein aufgabenlokaler Einschluss-Pfad auf das Verzeichnis gesetzt, das die Datei enthält. Verschachtelte Aufrufe von include suchen relativ zu diesem Pfad. Diese Funktion wird typischerweise verwendet, um Quellcode interaktiv zu laden oder um Dateien in Paketen zu kombinieren, die in mehrere Quelldateien aufgeteilt sind. Das Argument path wird mit normpath normalisiert, was relative Pfad-Tokens wie .. auflöst und / in den entsprechenden Pfadtrennzeichen umwandelt.

Das optionale erste Argument mapexpr kann verwendet werden, um den eingeschlossenen Code zu transformieren, bevor er ausgewertet wird: für jeden geparsten Ausdruck expr in path wertet die Funktion include tatsächlich mapexpr(expr) aus. Wenn es weggelassen wird, wird mapexpr standardmäßig auf identity gesetzt.

Verwenden Sie Base.include, um eine Datei in ein anderes Modul auszuwerten.

include_string([mapexpr::Function,] m::Module, code::AbstractString, filename::AbstractString="string")

Wie include, außer dass der Code aus dem angegebenen String anstelle einer Datei gelesen wird.

Das optionale erste Argument mapexpr kann verwendet werden, um den eingeschlossenen Code vor der Auswertung zu transformieren: Für jeden geparsten Ausdruck expr in code wertet die Funktion include_string tatsächlich mapexpr(expr) aus. Wenn es weggelassen wird, wird mapexpr standardmäßig auf identity gesetzt.

include_dependency(path::AbstractString; track_content::Bool=true)

In einem Modul erklären Sie, dass die Datei, das Verzeichnis oder der symbolische Link, der durch path (relativ oder absolut) angegeben ist, eine Abhängigkeit für die Vorcompilierung ist; das heißt, wenn track_content=true ist, muss das Modul neu kompiliert werden, wenn sich der Inhalt von path ändert (wenn path ein Verzeichnis ist, entspricht der Inhalt join(readdir(path))). Wenn track_content=false ist, wird die Neukompilierung ausgelöst, wenn sich die Änderungszeit mtime von path ändert.

Dies ist nur erforderlich, wenn Ihr Modul von einem Pfad abhängt, der nicht über include verwendet wird. Es hat keine Auswirkungen außerhalb der Kompilierung.

__init__

Die Funktion __init__() in einem Modul wird sofort nachdem das Modul zur Laufzeit zum ersten Mal geladen wird, ausgeführt. Sie wird einmal aufgerufen, nachdem alle anderen Anweisungen im Modul ausgeführt wurden. Da sie nach dem vollständigen Import des Moduls aufgerufen wird, werden die __init__-Funktionen der Untermodule zuerst ausgeführt. Zwei typische Verwendungen von __init__ sind das Aufrufen von Laufzeitinitialisierungsfunktionen externer C-Bibliotheken und das Initialisieren globaler Konstanten, die Zeiger enthalten, die von externen Bibliotheken zurückgegeben werden. Siehe den Handbuchabschnitt über Module für weitere Details.

Beispiele

const foo_data_ptr = Ref{Ptr{Cvoid}}(0)
function __init__()
    ccall((:foo_init, :libfoo), Cvoid, ())
    foo_data_ptr[] = ccall((:foo_data, :libfoo), Ptr{Cvoid}, ())
    nothing
end

welches(f, typen)

Gibt die Methode von f (ein Method-Objekt) zurück, die für Argumente der angegebenen typen aufgerufen werden würde.

Wenn typen ein abstrakter Typ ist, wird die Methode zurückgegeben, die von invoke aufgerufen würde.

Siehe auch: parentmodule, @which und @edit.

methods(f, [types], [module])

Gibt die Methodentabelle für f zurück.

Wenn types angegeben ist, wird ein Array von Methoden zurückgegeben, deren Typen übereinstimmen. Wenn module angegeben ist, wird ein Array von Methoden zurückgegeben, die in diesem Modul definiert sind. Eine Liste von Modulen kann auch als Array angegeben werden.

Siehe auch: which, @which und methodswith.

@show exs...

Gibt einen oder mehrere Ausdrücke und deren Ergebnisse an stdout aus und gibt das letzte Ergebnis zurück.

Siehe auch: show, @info, println.

Beispiele

julia> x = @show 1+2
1 + 2 = 3
3

julia> @show x^2 x/2;
x ^ 2 = 9
x / 2 = 1.5

ans

Eine Variable, die auf den zuletzt berechneten Wert verweist und automatisch in die interaktive Eingabeaufforderung importiert wird.

err

Eine Variable, die auf die zuletzt geworfenen Fehler verweist, die automatisch in die interaktive Eingabeaufforderung importiert werden. Die geworfenen Fehler werden in einem Stapel von Ausnahmen gesammelt.

active_project()

Gibt den Pfad der aktiven Project.toml-Datei zurück. Siehe auch Base.set_active_project.

set_active_project(projfile::Union{AbstractString,Nothing})

Setze die aktive Project.toml-Datei auf projfile. Siehe auch Base.active_project.

module

module deklariert ein Module, das einen separaten globalen Variablen-Arbeitsbereich darstellt. Innerhalb eines Moduls können Sie steuern, welche Namen aus anderen Modulen sichtbar sind (durch Importieren), und festlegen, welche Ihrer Namen öffentlich sein sollen (durch export und public). Module ermöglichen es Ihnen, Definitionen auf oberster Ebene zu erstellen, ohne sich um Namenskonflikte sorgen zu müssen, wenn Ihr Code zusammen mit dem eines anderen verwendet wird. Siehe den Handbuchabschnitt über Module für weitere Details.

Beispiele

module Foo
import Base.show
export MyType, foo

struct MyType
    x
end

bar(x) = 2x
foo(a::MyType) = bar(a.x) + 1
show(io::IO, a::MyType) = print(io, "MyType $(a.x)")
end

export

export wird innerhalb von Modulen verwendet, um Julia mitzuteilen, welche Namen dem Benutzer zur Verfügung gestellt werden sollen. Zum Beispiel: export foo macht den Namen foo verfügbar, wenn das Modul mit using verwendet wird. Siehe den Handbuchabschnitt über Module für Details.

public

public wird innerhalb von Modulen verwendet, um Julia mitzuteilen, welche Namen Teil der öffentlichen API des Moduls sind. Zum Beispiel: public foo zeigt an, dass der Name foo öffentlich ist, ohne ihn verfügbar zu machen, wenn using das Modul verwendet wird. Siehe den Handbuchabschnitt über Module für Details.

import

import Foo lädt das Modul oder Paket Foo. Namen aus dem importierten Foo-Modul können mit der Punkt-Syntax zugegriffen werden (z. B. Foo.foo, um auf den Namen foo zuzugreifen). Siehe den Handbuchabschnitt über Module für Details.

using

using Foo lädt das Modul oder Paket Foo und macht seine exportierten Namen für die direkte Verwendung verfügbar. Namen können auch über die Punkt-Syntax verwendet werden (z. B. Foo.foo, um auf den Namen foo zuzugreifen), unabhängig davon, ob sie exportiert sind oder nicht. Siehe den Handbuchabschnitt über Module für Details.

as

as wird als Schlüsselwort verwendet, um einen Bezeichner, der durch import oder using in den Geltungsbereich gebracht wird, umzubenennen, um Namenskonflikte zu umgehen und um Namen zu verkürzen. (Außerhalb von import- oder using-Anweisungen ist as kein Schlüsselwort und kann als gewöhnlicher Bezeichner verwendet werden.)

import LinearAlgebra as LA bringt die importierte Standardbibliothek LinearAlgebra in den Geltungsbereich als LA.

import LinearAlgebra: eigen as eig, cholesky as chol bringt die Methoden eigen und cholesky aus LinearAlgebra in den Geltungsbereich als eig und chol respektive.

as funktioniert mit using nur, wenn einzelne Bezeichner in den Geltungsbereich gebracht werden. Zum Beispiel funktioniert using LinearAlgebra: eigen as eig oder using LinearAlgebra: eigen as eig, cholesky as chol, aber using LinearAlgebra as LA ist ungültige Syntax, da es unsinnig ist, alle exportierten Namen von LinearAlgebra in LA umzubenennen.

baremodule

baremodule deklariert ein Modul, das kein using Base oder lokale Definitionen von eval und include enthält. Es importiert jedoch weiterhin Core. Mit anderen Worten,

module Mod

...

end

ist äquivalent zu

baremodule Mod

using Base

eval(x) = Core.eval(Mod, x)
include(p) = Base.include(Mod, p)

...

end

Funktion

Funktionen werden mit dem Schlüsselwort function definiert:

function add(a, b)
    return a + b
end

Oder in der Kurzform:

add(a, b) = a + b

Die Verwendung des return Schlüsselworts ist genau die gleiche wie in anderen Sprachen, ist aber oft optional. Eine Funktion ohne eine explizite return-Anweisung gibt den letzten Ausdruck im Funktionskörper zurück.

macro

macro definiert eine Methode zum Einfügen von generiertem Code in ein Programm. Ein Makro ordnet eine Sequenz von Argumentausdrücken einem zurückgegebenen Ausdruck zu, und der resultierende Ausdruck wird direkt an der Stelle in das Programm eingefügt, an der das Makro aufgerufen wird. Makros sind eine Möglichkeit, generierten Code auszuführen, ohne eval aufzurufen, da der generierte Code stattdessen einfach Teil des umgebenden Programms wird. Makroargumente können Ausdrücke, literale Werte und Symbole enthalten. Makros können für eine variable Anzahl von Argumenten (varargs) definiert werden, akzeptieren jedoch keine Schlüsselwortargumente. Jedes Makro erhält auch implizit die Argumente __source__, die die Zeilennummer und den Dateinamen enthält, aus dem das Makro aufgerufen wird, und __module__, das das Modul ist, in dem das Makro erweitert wird.

Siehe den Abschnitt im Handbuch über Metaprogrammierung für weitere Informationen darüber, wie man ein Makro schreibt.

Beispiele

julia> macro sayhello(name)
           return :( println("Hello, ", $name, "!") )
       end
@sayhello (macro with 1 method)

julia> @sayhello "Charlie"
Hello, Charlie!

julia> macro saylots(x...)
           return :( println("Say: ", $(x...)) )
       end
@saylots (macro with 1 method)

julia> @saylots "hey " "there " "friend"
Say: hey there friend

return

return x bewirkt, dass die umschließende Funktion vorzeitig beendet wird und den angegebenen Wert x an den Aufrufer zurückgibt. return allein ohne Wert ist äquivalent zu return nothing (siehe nothing).

function compare(a, b)
    a == b && return "equal to"
    a < b ? "less than" : "greater than"
end

Im Allgemeinen können Sie eine return-Anweisung überall innerhalb eines Funktionskörpers platzieren, auch innerhalb von tief verschachtelten Schleifen oder Bedingungen, aber seien Sie vorsichtig mit do-Blöcken. Zum Beispiel:

function test1(xs)
    for x in xs
        iseven(x) && return 2x
    end
end

function test2(xs)
    map(xs) do x
        iseven(x) && return 2x
        x
    end
end

Im ersten Beispiel bricht die Rückgabe test1 sofort ab, sobald sie eine gerade Zahl erreicht, sodass test1([5,6,7]) 12 zurückgibt.

Sie könnten erwarten, dass das zweite Beispiel sich gleich verhält, aber in der Tat bricht das return dort nur aus der inneren Funktion (innerhalb des do-Blocks) aus und gibt einen Wert an map zurück. test2([5,6,7]) gibt dann [5,12,7] zurück.

Wenn return in einem Ausdruck auf oberster Ebene verwendet wird (d.h. außerhalb einer Funktion), bewirkt es, dass der gesamte aktuelle Ausdruck auf oberster Ebene vorzeitig beendet wird.

do

Erstellen Sie eine anonyme Funktion und übergeben Sie sie als erstes Argument an einen Funktionsaufruf. Zum Beispiel:

map(1:10) do x
    2x
end

ist äquivalent zu map(x->2x, 1:10).

Verwenden Sie mehrere Argumente wie folgt:

map(1:10, 11:20) do x, y
    x + y
end

begin

begin...end bezeichnet einen Codeblock.

begin
    println("Hallo, ")
    println("Welt!")
end

Normalerweise ist begin nicht notwendig, da Schlüsselwörter wie function und let implizit Codeblöcke beginnen. Siehe auch ;.

begin kann auch beim Indizieren verwendet werden, um den ersten Index einer Sammlung oder den ersten Index einer Dimension eines Arrays darzustellen. Zum Beispiel ist a[begin] das erste Element eines Arrays a.

Beispiele

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> A[begin, :]
2-element Array{Int64,1}:
 1
 2

end

end markiert den Abschluss eines Blocks von Ausdrücken, zum Beispiel module, struct, mutable struct, begin, let, for usw.

end kann auch beim Indizieren verwendet werden, um den letzten Index einer Sammlung oder den letzten Index einer Dimension eines Arrays darzustellen.

Beispiele

julia> A = [1 2; 3 4]
2×2 Array{Int64, 2}:
 1  2
 3  4

julia> A[end, :]
2-element Array{Int64, 1}:
 3
 4

let

let-Blöcke erstellen einen neuen harten Geltungsbereich und führen optional neue lokale Bindungen ein.

Genau wie die anderen Geltungsbereichs-Konstrukte definieren let-Blöcke den Codeblock, in dem neu eingeführte lokale Variablen zugänglich sind. Darüber hinaus hat die Syntax eine besondere Bedeutung für durch Kommas getrennte Zuweisungen und Variablennamen, die optional in derselben Zeile wie das let erscheinen können:

let var1 = value1, var2, var3 = value3
    code
end

Die auf dieser Zeile eingeführten Variablen sind lokal für den let-Block und die Zuweisungen werden der Reihe nach ausgewertet, wobei jede rechte Seite im Geltungsbereich ausgewertet wird, ohne den Namen auf der linken Seite zu berücksichtigen. Daher macht es Sinn, etwas wie let x = x zu schreiben, da die beiden x-Variablen unterschiedlich sind, wobei die linke Seite das x aus dem äußeren Geltungsbereich lokal überschattet. Dies kann sogar ein nützliches Idiom sein, da bei jedem Betreten lokaler Geltungsbereiche neue lokale Variablen frisch erstellt werden, aber dies ist nur im Fall von Variablen beobachtbar, die ihren Geltungsbereich durch Closures überdauern. Eine let-Variable ohne Zuweisung, wie var2 im obigen Beispiel, deklariert eine neue lokale Variable, die noch nicht an einen Wert gebunden ist.

Im Gegensatz dazu gruppieren begin-Blöcke ebenfalls mehrere Ausdrücke, führen jedoch keinen Geltungsbereich ein und haben nicht die spezielle Zuweisungssyntax.

Beispiele

In der folgenden Funktion gibt es ein einzelnes x, das dreimal iterativ durch die map aktualisiert wird. Die zurückgegebenen Closures beziehen sich alle auf dieses eine x mit seinem endgültigen Wert:

julia> function test_outer_x()
           x = 0
           map(1:3) do _
               x += 1
               return ()->x
           end
       end
test_outer_x (generische Funktion mit 1 Methode)

julia> [f() for f in test_outer_x()]
3-element Vector{Int64}:
 3
 3
 3

Wenn wir jedoch einen let-Block hinzufügen, der eine neue lokale Variable einführt, werden wir am Ende mit drei unterschiedlichen Variablen konfrontiert, die erfasst werden (eine bei jeder Iteration), obwohl wir uns entschieden haben, denselben Namen zu verwenden (zu überschatten).

julia> function test_let_x()
           x = 0
           map(1:3) do _
               x += 1
               let x = x
                   return ()->x
               end
           end
       end
test_let_x (generische Funktion mit 1 Methode)

julia> [f() for f in test_let_x()]
3-element Vector{Int64}:
 1
 2
 3

Alle Geltungsbereichs-Konstrukte, die neue lokale Variablen einführen, verhalten sich auf diese Weise, wenn sie wiederholt ausgeführt werden; das charakteristische Merkmal von let ist seine Fähigkeit, prägnant neue locals zu deklarieren, die äußere Variablen desselben Namens überschatten können. Zum Beispiel erfasst die direkte Verwendung des Arguments der do-Funktion ebenfalls drei unterschiedliche Variablen:

julia> function test_do_x()
           map(1:3) do x
               return ()->x
           end
       end
test_do_x (generische Funktion mit 1 Methode)

julia> [f() for f in test_do_x()]
3-element Vector{Int64}:
 1
 2
 3

if/elseif/else

if/elseif/else führt eine bedingte Auswertung durch, die es ermöglicht, Teile des Codes je nach Wert eines booleschen Ausdrucks auszuwerten oder nicht auszuwerten. Hier ist die Anatomie der if/elseif/else-Bedingungssyntax:

if x < y
    println("x ist kleiner als y")
elseif x > y
    println("x ist größer als y")
else
    println("x ist gleich y")
end

Wenn der Bedingungsausdruck x < y wahr ist, wird der entsprechende Block ausgewertet; andernfalls wird der Bedingungsausdruck x > y ausgewertet, und wenn dieser wahr ist, wird der entsprechende Block ausgewertet; wenn keiner der Ausdrücke wahr ist, wird der else-Block ausgewertet. Die elseif- und else-Blöcke sind optional, und es können so viele elseif-Blöcke verwendet werden, wie gewünscht.

Im Gegensatz zu einigen anderen Sprachen müssen Bedingungen vom Typ Bool sein. Es reicht nicht aus, wenn Bedingungen in Bool umwandelbar sind.

julia> if 1 end
ERROR: TypeError: non-boolean (Int64) used in boolean context

für

for-Schleifen bewerten wiederholt einen Block von Anweisungen, während sie über eine Sequenz von Werten iterieren.

Die Iterationsvariable ist immer eine neue Variable, selbst wenn eine Variable mit demselben Namen im umgebenden Gültigkeitsbereich existiert. Verwenden Sie outer, um eine vorhandene lokale Variable für die Iteration wiederzuverwenden.

Beispiele

julia> for i in [1, 4, 0]
           println(i)
       end
1
4
0

while

while-Schleifen bewerten wiederholt einen bedingten Ausdruck und setzen die Bewertung des Körpers der while-Schleife fort, solange der Ausdruck wahr bleibt. Wenn der Bedingungsausdruck falsch ist, wenn die while-Schleife zum ersten Mal erreicht wird, wird der Körper niemals bewertet.

Beispiele

julia> i = 1
1

julia> while i < 5
           println(i)
           global i += 1
       end
1
2
3
4

break

Bricht sofort aus einer Schleife aus.

Beispiele

julia> i = 0
0

julia> while true
           global i += 1
           i > 5 && break
           println(i)
       end
1
2
3
4
5

continue

Überspringen Sie den Rest der aktuellen Schleifeniteration.

Beispiele

julia> for i = 1:6
           iseven(i) && continue
           println(i)
       end
1
3
5

try/catch

Eine try/catch-Anweisung ermöglicht das Abfangen von Fehlern (Ausnahmen), die von throw ausgelöst werden, sodass die Programmausführung fortgesetzt werden kann. Zum Beispiel versucht der folgende Code, eine Datei zu schreiben, warnt jedoch den Benutzer und fährt fort, anstatt die Ausführung zu beenden, wenn die Datei nicht geschrieben werden kann:

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "Konnte die Datei nicht schreiben."
end

oder, wenn die Datei nicht in eine Variable gelesen werden kann:

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "Datei nicht gefunden."
end

Die Syntax catch e (wobei e eine beliebige Variable ist) weist das ausgelöste Ausnahmeobjekt der angegebenen Variablen innerhalb des catch-Blocks zu.

Die Stärke des try/catch-Konstrukts liegt in der Fähigkeit, eine tief verschachtelte Berechnung sofort auf ein viel höheres Niveau im Stapel der aufrufenden Funktionen zurückzuführen.

schließlich

Führen Sie einen Code aus, wenn ein gegebener Codeblock endet, unabhängig davon, wie er endet. Zum Beispiel, hier ist, wie wir garantieren können, dass eine geöffnete Datei geschlossen wird:

f = open("file")
try
    operate_on_file(f)
finally
    close(f)
end

Wenn die Kontrolle den try Block verlässt (zum Beispiel aufgrund eines return oder einfach normal endet), wird close(f) ausgeführt. Wenn der try Block aufgrund einer Ausnahme endet, wird die Ausnahme weiterhin propagiert. Ein catch Block kann ebenfalls mit try und finally kombiniert werden. In diesem Fall wird der finally Block ausgeführt, nachdem catch den Fehler behandelt hat.

quote

quote erstellt mehrere Ausdrucksobjekte in einem Block, ohne den expliziten Expr Konstruktor zu verwenden. Zum Beispiel:

ex = quote
    x = 1
    y = 2
    x + y
end

Im Gegensatz zu den anderen Methoden des Quotierens, :( ... ), führt diese Form QuoteNode-Elemente in den Ausdrucksbaum ein, die berücksichtigt werden müssen, wenn der Baum direkt manipuliert wird. Für andere Zwecke werden :( ... ) und quote .. end Blöcke identisch behandelt.

local

local führt eine neue lokale Variable ein. Siehe den Handbuchabschnitt zur Variablenbereich für weitere Informationen.

Beispiele

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # führt ein schleifenlokales x ein
               x = i
           end
           x
       end
foo (generische Funktion mit 1 Methode)

julia> foo(10)
0

global

global x lässt x im aktuellen Gültigkeitsbereich und seinen inneren Gültigkeitsbereichen auf die globale Variable mit diesem Namen verweisen. Siehe den Handbuchabschnitt über die Variablenbereich für weitere Informationen.

Beispiele

julia> z = 3
3

julia> function foo()
           global z = 6 # verwende die z-Variable, die außerhalb von foo definiert ist
       end
foo (generische Funktion mit 1 Methode)

julia> foo()
6

julia> z
6

für outer

Wiederverwenden einer vorhandenen lokalen Variablen für die Iteration in einer for-Schleife.

Siehe den Handbuchabschnitt über Variablenbereich für weitere Informationen.

Siehe auch for.

Beispiele

julia> function f()
           i = 0
           for i = 1:3
               # leer
           end
           return i
       end;

julia> f()
0

julia> function f()
           i = 0
           for outer i = 1:3
               # leer
           end
           return i
       end;

julia> f()
3

julia> i = 0 # globale Variable
       for outer i = 1:3
       end
ERROR: Syntax: keine äußere lokale Variablendeklaration für "for outer" vorhanden
[...]

const

const wird verwendet, um globale Variablen zu deklarieren, deren Werte sich nicht ändern werden. In fast allen Code (und insbesondere in leistungsempfindlichem Code) sollten globale Variablen auf diese Weise konstant deklariert werden.

const x = 5

Mehrere Variablen können innerhalb eines einzelnen const deklariert werden:

const y, z = 7, 11

Beachten Sie, dass const nur für eine =-Operation gilt, daher deklariert const x = y = 1 x als konstant, aber nicht y. Andererseits deklariert const x = const y = 1 sowohl x als auch y als konstant.

Beachten Sie, dass die "Konstanz" nicht in veränderliche Container hineinreicht; nur die Zuordnung zwischen einer Variablen und ihrem Wert ist konstant. Wenn x ein Array oder ein Dictionary (zum Beispiel) ist, können Sie dennoch Elemente ändern, hinzufügen oder entfernen.

In einigen Fällen gibt das Ändern des Wertes einer const-Variablen eine Warnung anstelle eines Fehlers aus. Dies kann jedoch unvorhersehbares Verhalten erzeugen oder den Zustand Ihres Programms beschädigen, und sollte daher vermieden werden. Diese Funktion ist nur für den Komfort während der interaktiven Nutzung gedacht.

struct

Die am häufigsten verwendete Art von Typ in Julia ist ein struct, der als Name und eine Menge von Feldern angegeben wird.

struct Point
    x
    y
end

Felder können Typbeschränkungen haben, die parametrisiert sein können:

struct Point{X}
    x::X
    y::Float64
end

Ein struct kann auch einen abstrakten Supertyp über die <:-Syntax deklarieren:

struct Point <: AbstractPoint
    x
    y
end

structs sind standardmäßig unveränderlich; eine Instanz eines dieser Typen kann nach der Konstruktion nicht mehr geändert werden. Verwenden Sie mutable struct, um einen Typ zu deklarieren, dessen Instanzen geändert werden können.

Siehe den Handbuchabschnitt über Composite Types für weitere Details, wie z.B. wie man Konstruktoren definiert.

mutable struct

mutable struct ist ähnlich wie struct, erlaubt jedoch zusätzlich, dass die Felder des Typs nach der Konstruktion gesetzt werden.

Einzelne Felder eines mutable struct können als const markiert werden, um sie unveränderlich zu machen:

mutable struct Baz
    a::Int
    const b::Float64
end

Siehe den Handbuchabschnitt über Composite Types für weitere Informationen.

@kwdef typedef

Dies ist ein Hilfsmakro, das automatisch einen konstruktorspezifischen Konstruktor für den in dem Ausdruck typedef deklarierten Typ definiert, der ein struct oder mutable struct Ausdruck sein muss. Das Standardargument wird bereitgestellt, indem Felder der Form field::T = default oder field = default deklariert werden. Wenn kein Standard bereitgestellt wird, wird das Schlüsselwortargument zu einem erforderlichen Schlüsselwortargument im resultierenden Typkonstruktor.

Innere Konstruktoren können weiterhin definiert werden, aber mindestens einer sollte Argumente in derselben Form wie der Standardinnere Konstruktor akzeptieren (d.h. ein positionsbasiertes Argument pro Feld), um korrekt mit dem äußeren Schlüsselwortkonstruktor zu funktionieren.

Beispiele

julia> @kwdef struct Foo
           a::Int = 1         # spezifiziertes Standard
           b::String          # erforderliches Schlüsselwort
       end
Foo

julia> Foo(b="hi")
Foo(1, "hi")

julia> Foo()
ERROR: UndefKeywordError: Schlüsselwortargument `b` nicht zugewiesen
Stacktrace:
[...]

abstract type

abstract type deklariert einen Typ, der nicht instanziiert werden kann, und dient nur als Knoten im Typgraphen, wodurch Mengen verwandter konkreter Typen beschrieben werden: jene konkreten Typen, die ihre Nachkommen sind. Abstrakte Typen bilden die konzeptionelle Hierarchie, die Julias Typsystem mehr als nur eine Sammlung von Objektimplementierungen macht. Zum Beispiel:

abstract type Number end
abstract type Real <: Number end

Number hat keinen Supertyp, während Real ein abstrakter Subtyp von Number ist.

primitiver Typ

primitiver Typ deklariert einen konkreten Typ, dessen Daten nur aus einer Reihe von Bits bestehen. Klassische Beispiele für primitive Typen sind Ganzzahlen und Fließkommawerte. Einige Beispiele für eingebaute primitive Typdeklarationen:

primitiver Typ Char 32 end
primitiver Typ Bool <: Integer 8 end

Die Zahl nach dem Namen gibt an, wie viele Bits Speicher der Typ benötigt. Derzeit werden nur Größen unterstützt, die Vielfache von 8 Bits sind. Die Bool Deklaration zeigt, wie ein primitiver Typ optional als Untertyp eines bestimmten Supertyps deklariert werden kann.

wo

Das where-Schlüsselwort erstellt einen UnionAll-Typ, der als eine iterierte Vereinigung anderer Typen über alle Werte einer Variablen betrachtet werden kann. Zum Beispiel umfasst Vector{T} where T<:Real alle Vectors, bei denen der Elementtyp eine Art von Real-Zahl ist.

Die Variablenbindung hat standardmäßig Any, wenn sie weggelassen wird:

Vector{T} where T    # kurz für `where T<:Any`

Variablen können auch untere Schranken haben:

Vector{T} where T>:Int
Vector{T} where Int<:T<:Real

Es gibt auch eine prägnante Syntax für geschachtelte where-Ausdrücke. Zum Beispiel kann dies:

Pair{T, S} where S<:Array{T} where T<:Number

verkürzt werden zu:

Pair{T, S} where {T<:Number, S<:Array{T}}

Diese Form findet sich häufig in Methodensignaturen.

Beachten Sie, dass in dieser Form die Variablen äußerste zuerst aufgelistet sind. Dies entspricht der Reihenfolge, in der Variablen substituiert werden, wenn ein Typ mit den Parameterwerten unter Verwendung der Syntax T{p1, p2, ...} "angewendet" wird.

...

Der "Splat"-Operator, ..., repräsentiert eine Sequenz von Argumenten. ... kann in Funktionsdefinitionen verwendet werden, um anzuzeigen, dass die Funktion eine beliebige Anzahl von Argumenten akzeptiert. ... kann auch verwendet werden, um eine Funktion auf eine Sequenz von Argumenten anzuwenden.

Beispiele

julia> add(xs...) = reduce(+, xs)
add (generische Funktion mit 1 Methode)

julia> add(1, 2, 3, 4, 5)
15

julia> add([1, 2, 3]...)
6

julia> add(7, 1:100..., 1000:1100...)
111107

;

; hat eine ähnliche Rolle in Julia wie in vielen C-ähnlichen Sprachen und wird verwendet, um das Ende der vorherigen Anweisung zu kennzeichnen.

; ist am Ende einer Zeile nicht notwendig, kann jedoch verwendet werden, um Anweisungen in einer einzigen Zeile zu trennen oder Anweisungen zu einem einzigen Ausdruck zu verbinden.

Das Hinzufügen von ; am Ende einer Zeile im REPL unterdrückt die Ausgabe des Ergebnisses dieses Ausdrucks.

In Funktionsdeklarationen und optional in Aufrufen trennt ; reguläre Argumente von Schlüsselwörtern.

In Array-Literalen werden durch Semikolons getrennte Argumente zusammengefügt. Ein Separator aus einem einzelnen ; fügt vertikal zusammen (d.h. entlang der ersten Dimension), ;; fügt horizontal zusammen (zweite Dimension), ;;; fügt entlang der dritten Dimension zusammen usw. Ein solcher Separator kann auch in letzter Position in den eckigen Klammern verwendet werden, um nachfolgende Dimensionen der Länge 1 hinzuzufügen.

Ein ; an erster Stelle innerhalb von Klammern kann verwendet werden, um ein benanntes Tupel zu erstellen. Die gleiche (; ...)-Syntax auf der linken Seite einer Zuweisung ermöglicht die Destrukturierung von Eigenschaften.

Im standardmäßigen REPL wechselt das Tippen von ; in einer leeren Zeile in den Shell-Modus.

Beispiele

julia> function foo()
           x = "Hello, "; x *= "World!"
           return x
       end
foo (generic function with 1 method)

julia> bar() = (x = "Hello, Mars!"; return x)
bar (generic function with 1 method)

julia> foo();

julia> bar()
"Hello, Mars!"

julia> function plot(x, y; style="solid", width=1, color="black")
           ###
       end

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> [1; 3;; 2; 4;;; 10*A]
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 3  4

[:, :, 2] =
 10  20
 30  40

julia> [2; 3;;;]
2×1×1 Array{Int64, 3}:
[:, :, 1] =
 2
 3

julia> nt = (; x=1) # ohne das ; oder ein nachfolgendes Komma würde dies x zuweisen
(x = 1,)

julia> key = :a; c = 3;

julia> nt2 = (; key => 1, b=2, c, nt.x)
(a = 1, b = 2, c = 3, x = 1)

julia> (; b, x) = nt2; # setze die Variablen b und x mit Hilfe der Destrukturierung von Eigenschaften

julia> b, x
(2, 1)

julia> ; # beim Tippen von ; ändert sich die Eingabeaufforderung (an Ort und Stelle) zu: shell>
shell> echo hello
hello

=

= ist der Zuweisungsoperator.

• Für die Variable a und den Ausdruck b bewirkt a = b, dass a auf den Wert von b verweist.
• Für Funktionen f(x) definiert f(x) = x eine neue Funktionskonstante f oder fügt f eine neue Methode hinzu, wenn f bereits definiert ist; diese Verwendung entspricht function f(x); x; end.
• a[i] = v ruft setindex!(a,v,i) auf.
• a.b = c ruft setproperty!(a,:b,c) auf.
• Innerhalb eines Funktionsaufrufs übergibt f(a=b) b als den Wert des Schlüsselwortarguments a.
• Innerhalb von Klammern mit Kommas konstruiert (a=1,) ein NamedTuple.

Beispiele

Die Zuweisung von a zu b erstellt keine Kopie von b; stattdessen verwenden Sie copy oder deepcopy.

julia> b = [1]; a = b; b[1] = 2; a
1-element Array{Int64, 1}:
 2

julia> b = [1]; a = copy(b); b[1] = 2; a
1-element Array{Int64, 1}:
 1

Sammlungen, die an Funktionen übergeben werden, werden ebenfalls nicht kopiert. Funktionen können den Inhalt der Objekte, auf die ihre Argumente verweisen, ändern (mutieren). (Die Namen von Funktionen, die dies tun, enden konventionell mit '!'.)

julia> function f!(x); x[:] .+= 1; end
f! (generische Funktion mit 1 Methode)

julia> a = [1]; f!(a); a
1-element Array{Int64, 1}:
 2

Die Zuweisung kann parallel auf mehrere Variablen wirken und Werte aus einem iterierbaren Objekt übernehmen:

julia> a, b = 4, 5
(4, 5)

julia> a, b = 1:3
1:3

julia> a, b
(1, 2)

Die Zuweisung kann seriell auf mehrere Variablen wirken und gibt den Wert des am weitesten rechts stehenden Ausdrucks zurück:

julia> a = [1]; b = [2]; c = [3]; a = b = c
1-element Array{Int64, 1}:
 3

julia> b[1] = 2; a, b, c
([2], [2], [2])

Die Zuweisung an Indizes außerhalb der Grenzen vergrößert eine Sammlung nicht. Wenn die Sammlung ein Vector ist, kann sie stattdessen mit push! oder append! vergrößert werden.

julia> a = [1, 1]; a[3] = 2
ERROR: BoundsError: Versuch, auf 2-element Array{Int64, 1} an Index [3] zuzugreifen
[...]

julia> push!(a, 2, 3)
4-element Array{Int64, 1}:
 1
 1
 2
 3

Die Zuweisung von [] entfernt keine Elemente aus einer Sammlung; stattdessen verwenden Sie filter!.

julia> a = collect(1:3); a[a .<= 1] = []
ERROR: DimensionMismatch: Versuch, 0 Elemente an 1 Ziel zuzuweisen
[...]

julia> filter!(x -> x > 1, a) # in-place & somit effizienter als a = a[a .> 1]
2-element Array{Int64, 1}:
 2
 3

a ? b : c

Kurze Form für Bedingungen; lese "wenn a, bewerte b, andernfalls bewerte c". Auch bekannt als der ternäre Operator.

Diese Syntax ist äquivalent zu if a; b else c end, wird jedoch oft verwendet, um den Wert b-oder-c zu betonen, der als Teil eines größeren Ausdrucks verwendet wird, anstatt die Nebenwirkungen, die die Bewertung von b oder c haben kann.

Siehe den Handbuchabschnitt über Kontrollfluss für weitere Details.

Beispiele

julia> x = 1; y = 2;

julia> x > y ? println("x ist größer") : println("x ist nicht größer")
x ist nicht größer

julia> x > y ? "x ist größer" : x == y ? "x und y sind gleich" : "y ist größer"
"y ist größer"

Haupt

Haupt ist das Modul auf oberster Ebene, und Julia beginnt mit Haupt, das als aktuelles Modul festgelegt ist. Variablen, die an der Eingabeaufforderung definiert werden, gehen in Haupt, und varinfo listet Variablen in Haupt auf.

julia> @__MODULE__
Haupt

Kern

Kern ist das Modul, das alle Bezeichner enthält, die als "eingebaut" in die Sprache betrachtet werden, d.h. Teil der Kernsprache und nicht von Bibliotheken. Jedes Modul gibt implizit using Kern an, da man ohne diese Definitionen nichts tun kann.

Basis

Die Basisbibliothek von Julia. Base ist ein Modul, das grundlegende Funktionen (den Inhalt von base/) enthält. Alle Module enthalten implizit using Base, da dies in den meisten Fällen erforderlich ist.

Base.Broadcast

Modul, das die Implementierung des Broadcastings enthält.

Dokumente

Das Docs-Modul bietet das @doc Makro, das verwendet werden kann, um Dokumentationsmetadaten für Julia-Objekte festzulegen und abzurufen.

Bitte siehe den Handbuchabschnitt über Dokumentation für weitere Informationen.

Methoden zum Arbeiten mit Iteratoren.

Schnittstelle zu libc, der C-Standardbibliothek.

Hilfsfunktionen für Metaprogrammierung.

Tools zum Sammeln und Manipulieren von Stack-Traces. Hauptsächlich verwendet zum Erstellen von Fehlern.

Bitte Methoden zum Abrufen von Informationen über Hardware und das Betriebssystem bereitstellen.

Multithreading-Unterstützung.

Base.GC

Modul mit Funktionen zur Speicherbereinigung.

===(x,y) -> Bool
≡(x,y) -> Bool

Bestimmen Sie, ob x und y identisch sind, im Sinne davon, dass kein Programm sie unterscheiden könnte. Zuerst werden die Typen von x und y verglichen. Wenn diese identisch sind, werden veränderliche Objekte nach Adresse im Speicher und unveränderliche Objekte (wie Zahlen) nach Inhalt auf Bit-Ebene verglichen. Diese Funktion wird manchmal "egal" genannt. Sie gibt immer einen Bool-Wert zurück.

Beispiele

julia> a = [1, 2]; b = [1, 2];

julia> a == b
true

julia> a === b
false

julia> a === a
true

isa(x, type) -> Bool

Bestimmen Sie, ob x vom angegebenen type ist. Kann auch als infix Operator verwendet werden, z.B. x isa type.

Beispiele

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true

isequal(x, y) -> Bool

Ähnlich wie ==, mit Ausnahme der Behandlung von Fließkommazahlen und fehlenden Werten. isequal behandelt alle Fließkomma-NaN-Werte als gleich zueinander, behandelt -0.0 als ungleich 0.0 und missing als gleich zu missing. Gibt immer einen Bool-Wert zurück.

isequal ist eine Äquivalenzrelation - sie ist reflexiv (=== impliziert isequal), symmetrisch (isequal(a, b) impliziert isequal(b, a)) und transitiv (isequal(a, b) und isequal(b, c) impliziert isequal(a, c)).

Implementierung

Die Standardimplementierung von isequal ruft == auf, sodass ein Typ, der keine Fließkommawerte enthält, im Allgemeinen nur == definieren muss.

isequal ist die Vergleichsfunktion, die von Hash-Tabellen (Dict) verwendet wird. isequal(x,y) muss implizieren, dass hash(x) == hash(y).

Das bedeutet typischerweise, dass Typen, für die eine benutzerdefinierte ==- oder isequal-Methode existiert, eine entsprechende hash-Methode implementieren müssen (und umgekehrt). Sammlungen implementieren typischerweise isequal, indem sie isequal rekursiv auf allen Inhalten aufrufen.

Darüber hinaus ist isequal mit isless verknüpft, und sie arbeiten zusammen, um eine feste totale Ordnung zu definieren, bei der genau einer von isequal(x, y), isless(x, y) oder isless(y, x) true sein muss (und die anderen beiden false).

Skalare Typen müssen im Allgemeinen isequal nicht separat von == implementieren, es sei denn, sie repräsentieren Fließkommazahlen, die eine effizientere Implementierung als die bereitgestellte generische Rückfallimplementierung (basierend auf isnan, signbit und ==) ermöglichen.

Beispiele

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

julia> missing == missing
missing

julia> isequal(missing, missing)
true

isequal(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von isequal vergleicht, d.h. eine Funktion, die äquivalent zu y -> isequal(y, x) ist.

Die zurückgegebene Funktion ist vom Typ Base.Fix2{typeof(isequal)}, die verwendet werden kann, um spezialisierte Methoden zu implementieren.

isless(x, y)

Testen Sie, ob x kleiner als y ist, gemäß einer festen Gesamtordnung (definiert zusammen mit isequal). isless ist nicht für Paare (x, y) aller Typen definiert. Wenn es jedoch definiert ist, wird erwartet, dass es die folgenden Bedingungen erfüllt:

• Wenn isless(x, y) definiert ist, dann ist auch isless(y, x) und isequal(x, y) definiert, und genau eines dieser drei ergibt true.
• Die durch isless definierte Relation ist transitiv, d.h. isless(x, y) && isless(y, z) impliziert isless(x, z).

Werte, die normalerweise ungeordnet sind, wie NaN, werden nach regulären Werten geordnet. missing Werte werden zuletzt geordnet.

Dies ist der Standardvergleich, der von sort! verwendet wird.

Implementierung

Nicht-numerische Typen mit einer Gesamtordnung sollten diese Funktion implementieren. Numerische Typen müssen sie nur implementieren, wenn sie spezielle Werte wie NaN haben. Typen mit einer partiellen Ordnung sollten < implementieren. Siehe die Dokumentation zu Alternativen Ordnungen für Informationen zur Definition alternativer Ordnungsarten, die beim Sortieren und verwandten Funktionen verwendet werden können.

Beispiele

julia> isless(1, 3)
true

julia> isless("Red", "Blue")
false

isunordered(x)

Gibt true zurück, wenn x ein Wert ist, der nicht nach < ordnungsfähig ist, wie NaN oder missing.

Die Werte, die mit diesem Prädikat zu true ausgewertet werden, können in Bezug auf andere Ordnungen wie isless ordnungsfähig sein.

ifelse(condition::Bool, x, y)

Gibt x zurück, wenn condition true ist, andernfalls y. Dies unterscheidet sich von ? oder if, da es sich um eine gewöhnliche Funktion handelt, sodass alle Argumente zuerst ausgewertet werden. In einigen Fällen kann die Verwendung von ifelse anstelle einer if-Anweisung den Zweig im generierten Code eliminieren und eine höhere Leistung in engen Schleifen bieten.

Beispiele

julia> ifelse(1 > 2, 1, 2)
2

typeassert(x, type)

Wirft einen TypeError, es sei denn, x isa type. Die Syntax x::type ruft diese Funktion auf.

Beispiele

julia> typeassert(2.5, Int)
ERROR: TypeError: in typeassert, expected Int64, got a value of type Float64
Stacktrace:
[...]

typeof(x)

Erhalte den konkreten Typ von x.

Siehe auch eltype.

Beispiele

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

julia> M = [1 2; 3.5 4];

julia> typeof(M)
Matrix{Float64} (alias für Array{Float64, 2})

tuple(xs...)

Konstruiere ein Tupel der gegebenen Objekte.

Siehe auch Tuple, ntuple, NamedTuple.

Beispiele

julia> tuple(1, 'b', pi)
(1, 'b', π)

julia> ans === (1, 'b', π)
true

julia> Tuple(Real[1, 2, pi])  # nimmt eine Sammlung
(1, 2, π)

ntuple(f, n::Integer)

Erstellt ein Tupel der Länge n, wobei jedes Element als f(i) berechnet wird, wobei i der Index des Elements ist.

Beispiele

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)

ntuple(f, ::Val{N})

Erstellt ein Tupel der Länge N, wobei jedes Element als f(i) berechnet wird, wobei i der Index des Elements ist. Durch die Verwendung eines Val(N)-Arguments ist es möglich, dass diese Version von ntuple effizienteren Code generieren kann als die Version, die die Länge als Ganzzahl verwendet. Aber ntuple(f, N) ist vorzuziehen gegenüber ntuple(f, Val(N)) in Fällen, in denen N zur Compile-Zeit nicht bestimmt werden kann.

Beispiele

julia> ntuple(i -> 2*i, Val(4))
(2, 4, 6, 8)

objectid(x) -> UInt

Erhalte einen Hash-Wert für x, basierend auf der Objektidentität.

Wenn x === y, dann ist objectid(x) == objectid(y), und normalerweise, wenn x !== y, ist objectid(x) != objectid(y).

Siehe auch hash, IdDict.

hash(x[, h::UInt]) -> UInt

Berechnet einen ganzzahligen Hash-Code, sodass isequal(x,y) impliziert, dass hash(x)==hash(y). Das optionale zweite Argument h ist ein weiterer Hash-Code, der mit dem Ergebnis gemischt werden soll.

Neue Typen sollten die 2-Argument-Form implementieren, typischerweise indem sie die 2-Argument hash-Methode rekursiv aufrufen, um die Hashes der Inhalte miteinander (und mit h) zu mischen. Typischerweise sollte jeder Typ, der hash implementiert, auch seine eigene == (und damit isequal) implementieren, um die oben genannte Eigenschaft zu garantieren.

Der Hash-Wert kann sich ändern, wenn ein neuer Julia-Prozess gestartet wird.

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # verwendet nur die Ausgabe einer anderen Hash-Funktion als zweites Argument
0xd42bad54a8575b16

Siehe auch: objectid, Dict, Set.

finalizer(f, x)

Registrieren Sie eine Funktion f(x), die aufgerufen wird, wenn es keine programmzugänglichen Referenzen zu x mehr gibt, und geben Sie x zurück. Der Typ von x muss eine mutable struct sein, andernfalls wird die Funktion einen Fehler auslösen.

f darf keinen Taskwechsel verursachen, was die meisten I/O-Operationen wie println ausschließt. Die Verwendung des @async-Makros (um den Kontextwechsel außerhalb des Finalizers zu verschieben) oder ccall, um I/O-Funktionen in C direkt aufzurufen, kann zu Debugging-Zwecken hilfreich sein.

Beachten Sie, dass es kein garantierter Weltalter für die Ausführung von f gibt. Es kann im Weltalter aufgerufen werden, in dem der Finalizer registriert wurde, oder in einem späteren Weltalter.

Beispiele

finalizer(my_mutable_struct) do x
    @async println("Finalizing $x.")
end

finalizer(my_mutable_struct) do x
    ccall(:jl_safe_printf, Cvoid, (Cstring, Cstring), "Finalizing %s.", repr(x))
end

Ein Finalizer kann bei der Objektkonstruktion registriert werden. Im folgenden Beispiel beachten Sie, dass wir implizit darauf vertrauen, dass der Finalizer die neu erstellte mutable struct x zurückgibt.

mutable struct MyMutableStruct
    bar
    function MyMutableStruct(bar)
        x = new(bar)
        f(t) = @async println("Finalizing $t.")
        finalizer(f, x)
    end
end

finalize(x)

Führen Sie sofort die für das Objekt x registrierten Finalisierer aus.

copy(x)

Erstellt eine flache Kopie von x: Die äußere Struktur wird kopiert, aber nicht alle internen Werte. Zum Beispiel erzeugt das Kopieren eines Arrays ein neues Array mit identisch gleichen Elementen wie das Original.

Siehe auch copy!, copyto!, deepcopy.

deepcopy(x)

Erstellt eine tiefe Kopie von x: alles wird rekursiv kopiert, was zu einem vollständig unabhängigen Objekt führt. Zum Beispiel erzeugt das tiefe Kopieren eines Arrays tiefe Kopien aller Objekte, die es enthält, und produziert ein neues Array mit der konsistenten Beziehungsstruktur (z. B. wenn die ersten beiden Elemente dasselbe Objekt im ursprünglichen Array sind, werden die ersten beiden Elemente des neuen Arrays ebenfalls dasselbe deepcopy-Objekt sein). Das Aufrufen von deepcopy auf einem Objekt sollte im Allgemeinen denselben Effekt haben wie das Serialisieren und anschließende Deserialisieren.

Obwohl es normalerweise nicht notwendig ist, können benutzerdefinierte Typen das Standardverhalten von deepcopy überschreiben, indem sie eine spezialisierte Version der Funktion deepcopy_internal(x::T, dict::IdDict) definieren (die ansonsten nicht verwendet werden sollte), wobei T der Typ ist, für den spezialisiert werden soll, und dict die bisher innerhalb der Rekursion kopierten Objekte verfolgt. Innerhalb der Definition sollte deepcopy_internal anstelle von deepcopy verwendet werden, und die dict-Variable sollte entsprechend aktualisiert werden, bevor sie zurückgegeben wird.

getproperty(value, name::Symbol)
getproperty(value, name::Symbol, order::Symbol)

Die Syntax a.b ruft getproperty(a, :b) auf. Die Syntax @atomic order a.b ruft getproperty(a, :b, :order) auf und die Syntax @atomic a.b ruft getproperty(a, :b, :sequentially_consistent) auf.

Beispiele

julia> struct MyType{T <: Number}
           x::T
       end

julia> function Base.getproperty(obj::MyType, sym::Symbol)
           if sym === :special
               return obj.x + 1
           else # fallback to getfield
               return getfield(obj, sym)
           end
       end

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

Man sollte getproperty nur dann überladen, wenn es notwendig ist, da es verwirrend sein kann, wenn das Verhalten der Syntax obj.f ungewöhnlich ist. Beachten Sie auch, dass die Verwendung von Methoden oft vorzuziehen ist. Siehe auch diese Stilrichtlinien-Dokumentation für weitere Informationen: Bevorzugen Sie exportierte Methoden gegenüber direktem Feldzugriff.

Siehe auch getfield, propertynames und setproperty!.

setproperty!(value, name::Symbol, x)
setproperty!(value, name::Symbol, x, order::Symbol)

Die Syntax a.b = c ruft setproperty!(a, :b, c) auf. Die Syntax @atomic order a.b = c ruft setproperty!(a, :b, c, :order) auf und die Syntax @atomic a.b = c ruft setproperty!(a, :b, c, :sequentially_consistent) auf.

Siehe auch setfield!, propertynames und getproperty.

replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

Führen Sie eine Vergleich-und-Tausch-Operation auf x.f von expected zu desired durch, gemäß egal. Die Syntax @atomicreplace x.f expected => desired kann anstelle der Funktionsaufrufsform verwendet werden.

Siehe auch replacefield! setproperty!, setpropertyonce!.

swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)

Die Syntax @atomic a.b, _ = c, a.b gibt (c, swapproperty!(a, :b, c, :sequentially_consistent)) zurück, wobei es einen getproperty-Ausdruck geben muss, der auf beiden Seiten gemeinsam ist.

Siehe auch swapfield! und setproperty!.

modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)

Die Syntax @atomic op(x.f, v) (und ihr Äquivalent @atomic x.f op v) gibt modifyproperty!(x, :f, op, v, :sequentially_consistent) zurück, wobei das erste Argument ein getproperty-Ausdruck sein muss und atomar modifiziert wird.

Der Aufruf von op(getproperty(x, f), v) muss standardmäßig einen Wert zurückgeben, der im Feld f des Objekts x gespeichert werden kann. Insbesondere wird im Gegensatz zum Standardverhalten von setproperty! die Funktion convert nicht automatisch aufgerufen.

Siehe auch modifyfield! und setproperty!.

setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

Führen Sie eine Vergleich-und-Tausch-Operation auf x.f durch, um es auf value zu setzen, wenn es zuvor nicht gesetzt war. Die Syntax @atomiconce x.f = value kann anstelle der Funktionsaufrufsform verwendet werden.

Siehe auch setfieldonce!, setproperty!, replaceproperty!.

propertynames(x, private=false)

Erhalten Sie ein Tupel oder einen Vektor der Eigenschaften (x.property) eines Objekts x. Dies ist typischerweise dasselbe wie fieldnames(typeof(x)), aber Typen, die getproperty überladen, sollten im Allgemeinen auch propertynames überladen, um die Eigenschaften einer Instanz des Typs zu erhalten.

propertynames(x) kann nur "öffentliche" Eigenschaftsnamen zurückgeben, die Teil der dokumentierten Schnittstelle von x sind. Wenn Sie möchten, dass auch "private" Eigenschaftsnamen zurückgegeben werden, die für den internen Gebrauch bestimmt sind, übergeben Sie true als optionales zweites Argument. Die REPL-Tab-Vervollständigung bei x. zeigt nur die private=false Eigenschaften an.

Siehe auch: hasproperty, hasfield.

hasproperty(x, s::Symbol)

Gibt einen Booleschen Wert zurück, der angibt, ob das Objekt x s als eines seiner eigenen Eigenschaften hat.

Siehe auch: propertynames, hasfield.

getfield(value, name::Symbol, [order::Symbol])
getfield(value, i::Int, [order::Symbol])

Extrahiert ein Feld aus einem zusammengesetzten value nach Name oder Position. Optional kann eine Reihenfolge für die Operation definiert werden. Wenn das Feld als @atomic deklariert wurde, wird empfohlen, dass die Spezifikation mit den Speicherungen an diesem Ort kompatibel ist. Andernfalls, wenn es nicht als @atomic deklariert ist, muss dieser Parameter, falls angegeben, :not_atomic sein. Siehe auch getproperty und fieldnames.

Beispiele

julia> a = 1//2
1//2

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1

setfield!(value, name::Symbol, x, [order::Symbol])
setfield!(value, i::Int, x, [order::Symbol])

Weisen Sie x einem benannten Feld in value eines zusammengesetzten Typs zu. Der value muss veränderlich sein und x muss ein Untertyp von fieldtype(typeof(value), name) sein. Zusätzlich kann eine Reihenfolge für diese Operation angegeben werden. Wenn das Feld als @atomic deklariert wurde, ist diese Spezifikation obligatorisch. Andernfalls, wenn es nicht als @atomic deklariert wurde, muss es :not_atomic sein, wenn es angegeben wird. Siehe auch setproperty!.

Beispiele

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

julia> setfield!(a, :field, 2);

julia> getfield(a, :field)
2

julia> a = 1//2
1//2

julia> setfield!(a, :num, 3);
ERROR: setfield!: immutable struct of type Rational cannot be changed

modifyfield!(value, name::Symbol, op, x, [order::Symbol]) -> Pair
modifyfield!(value, i::Int, op, x, [order::Symbol]) -> Pair

Führen Sie atomar die Operationen aus, um ein Feld zu lesen und zu setzen, nachdem die Funktion op angewendet wurde.

y = getfield(value, name)
z = op(y, x)
setfield!(value, name, z)
return y => z

Wenn von der Hardware unterstützt (zum Beispiel atomare Inkrementierung), kann dies auf die entsprechende Hardwareanweisung optimiert werden, andernfalls wird eine Schleife verwendet.

replacefield!(value, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
replacefield!(value, i::Int, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

Führen Sie atomar die Operationen aus, um ein Feld auf einen bestimmten Wert zu erhalten und bedingt zu setzen.

y = getfield(value, name, fail_order)
ok = y === expected
if ok
    setfield!(value, name, desired, success_order)
end
return (; old = y, success = ok)

Wenn von der Hardware unterstützt, kann dies auf die entsprechende Hardwareanweisung optimiert werden, andernfalls wird eine Schleife verwendet.

swapfield!(value, name::Symbol, x, [order::Symbol])
swapfield!(value, i::Int, x, [order::Symbol])

Führen Sie die Operationen atomar aus, um gleichzeitig ein Feld zu erhalten und zu setzen:

y = getfield(value, name)
setfield!(value, name, x)
return y

setfieldonce!(value, name::Union{Int,Symbol}, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

Führen Sie atomar die Operationen aus, um ein Feld auf einen bestimmten Wert zu setzen, nur wenn es zuvor nicht gesetzt war.

ok = !isdefined(value, name, fail_order)
if ok
    setfield!(value, name, desired, success_order)
end
return ok

isdefined(m::Module, s::Symbol, [order::Symbol])
isdefined(object, s::Symbol, [order::Symbol])
isdefined(object, index::Int, [order::Symbol])

Überprüft, ob eine globale Variable oder ein Objektfeld definiert ist. Die Argumente können ein Modul und ein Symbol oder ein zusammengesetztes Objekt und der Feldname (als Symbol) oder Index sein. Optional kann eine Reihenfolge für die Operation definiert werden. Wenn das Feld als @atomic deklariert wurde, wird empfohlen, dass die Spezifikation mit den Speicheroperationen an diesem Ort kompatibel ist. Andernfalls, wenn es nicht als @atomic deklariert ist, muss dieser Parameter, falls angegeben, :not_atomic sein.

Um zu testen, ob ein Array-Element definiert ist, verwenden Sie isassigned stattdessen.

Siehe auch @isdefined.

Beispiele

julia> isdefined(Base, :sum)
true

julia> isdefined(Base, :NonExistentMethod)
false

julia> a = 1//2;

julia> isdefined(a, 2)
true

julia> isdefined(a, 3)
false

julia> isdefined(a, :num)
true

julia> isdefined(a, :numerator)
false

@isdefined s -> Bool

Überprüft, ob die Variable s im aktuellen Gültigkeitsbereich definiert ist.

Siehe auch isdefined für Feld Eigenschaften und isassigned für Array-Indizes oder haskey für andere Zuordnungen.

Beispiele

julia> @isdefined newvar
false

julia> newvar = 1
1

julia> @isdefined newvar
true

julia> function f()
           println(@isdefined x)
           x = 3
           println(@isdefined x)
       end
f (generische Funktion mit 1 Methode)

julia> f()
false
true

convert(T, x)

Konvertiere x in einen Wert des Typs T.

Wenn T ein Integer Typ ist, wird ein InexactError ausgelöst, wenn x nicht durch T darstellbar ist, zum Beispiel wenn x keinen ganzzahligen Wert hat oder außerhalb des von T unterstützten Bereichs liegt.

Beispiele

julia> convert(Int, 3.0)
3

julia> convert(Int, 3.5)
ERROR: InexactError: Int64(3.5)
Stacktrace:
[...]

Wenn T ein AbstractFloat Typ ist, wird der nächstgelegene Wert zu x, der durch T darstellbar ist, zurückgegeben. Inf wird für die Bestimmung des Nächsten als um eine ulp größer als floatmax(T) behandelt.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

Wenn T ein Sammlungstyp ist und x eine Sammlung, kann das Ergebnis von convert(T, x) ganz oder teilweise mit x übereinstimmen.

julia> x = Int[1, 2, 3];

julia> y = convert(Vector{Int}, x);

julia> y === x
true

Siehe auch: round, trunc, oftype, reinterpret.

promote(xs...)

Konvertiere alle Argumente in einen gemeinsamen Typ und gebe sie alle (als Tuple) zurück. Wenn keine Argumente konvertiert werden können, wird ein Fehler ausgelöst.

Siehe auch: promote_type, promote_rule.

Beispiele

julia> promote(Int8(1), Float16(4.5), Float32(4.1))
(1.0f0, 4.5f0, 4.1f0)

julia> promote_type(Int8, Float16, Float32)
Float32

julia> reduce(Base.promote_typejoin, (Int8, Float16, Float32))
Real

julia> promote(1, "x")
ERROR: promotion of types Int64 and String failed to change any arguments
[...]

julia> promote_type(Int, String)
Any

oftype(x, y)

Konvertiere y in den Typ von x, d.h. convert(typeof(x), y).

Beispiele

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

widen(x)

Wenn x ein Typ ist, gibt es einen "größeren" Typ zurück, der so definiert ist, dass arithmetische Operationen + und - garantiert nicht überlaufen oder an Präzision verlieren für jede Kombination von Werten, die der Typ x halten kann.

Für ganzzahlige Typen mit fester Größe, die weniger als 128 Bit haben, gibt widen einen Typ mit der doppelten Anzahl von Bits zurück.

Wenn x ein Wert ist, wird er in widen(typeof(x)) umgewandelt.

Beispiele

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

Die Identitätsfunktion. Gibt ihr Argument zurück.

Siehe auch: one, oneunit und LinearAlgebra's I.

Beispiele

julia> identity("Well, what did you expect?")
"Well, what did you expect?"

WeakRef(x)

w = WeakRef(x) erstellt eine schwache Referenz auf den Julia-Wert x: obwohl w eine Referenz auf x enthält, verhindert es nicht, dass x vom Garbage Collector gesammelt wird. w.value ist entweder x (wenn x noch nicht garbage-collected wurde) oder nothing (wenn x garbage-collected wurde).

julia> x = "a string"
"a string"

julia> w = WeakRef(x)
WeakRef("a string")

julia> GC.gc()

julia> w           # eine Referenz wird über `x` aufrechterhalten
WeakRef("a string")

julia> x = nothing # Referenz löschen

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::DataType)

Gibt den Supertyp des Datentyps T zurück.

Beispiele

julia> supertype(Int32)
Signed

Core.Type{T}

Core.Type ist ein abstrakter Typ, der alle Typobjekte als seine Instanzen hat. Die einzige Instanz des Singleton-Typs Core.Type{T} ist das Objekt T.

Beispiele

julia> isa(Type{Float64}, Type)
true

julia> isa(Float64, Type)
true

julia> isa(Real, Type{Float64})
false

julia> isa(Real, Type{Real})
true

DataType <: Type{T}

DataType repräsentiert explizit deklarierte Typen, die Namen, explizit deklarierte Supertypen und optional Parameter haben. Jeder konkrete Wert im System ist eine Instanz eines DataType.

Beispiele

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

<:(T1, T2)

Subtypoperator: gibt true zurück, wenn und nur wenn alle Werte des Typs T1 auch vom Typ T2 sind.

Beispiele

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}
false

>:(T1, T2)

Supertyp-Operator, äquivalent zu T2 <: T1.

typejoin(T, S, ...)

Gibt den nächsten gemeinsamen Vorfahren der Typen T und S zurück, d.h. den engsten Typ, von dem sie beide erben. Rekursiert über zusätzliche varargs.

Beispiele

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number

typeintersect(T::Type, S::Type)

Berechne einen Typ, der die Schnittmenge von T und S enthält. Normalerweise wird dies der kleinste solche Typ oder einer, der ihm nahe kommt, sein.

Ein Sonderfall, in dem das genaue Verhalten garantiert ist: wenn T <: S, dann gilt typeintersect(S, T) == T == typeintersect(T, S).

promote_type(type1, type2, ...)

Die Promotion bezieht sich auf die Umwandlung von Werten gemischter Typen in einen einzigen gemeinsamen Typ. promote_type stellt das Standard-Promotionsverhalten in Julia dar, wenn Operatoren (in der Regel mathematische) Argumente unterschiedlicher Typen erhalten. promote_type versucht im Allgemeinen, einen Typ zurückzugeben, der zumindest die meisten Werte eines der Eingabetypen ohne übermäßige Erweiterung annähern kann. Ein gewisser Verlust wird toleriert; zum Beispiel gibt promote_type(Int64, Float64) Float64 zurück, obwohl streng genommen nicht alle Int64-Werte genau als Float64-Werte dargestellt werden können.

Siehe auch: promote, promote_typejoin, promote_rule.

Beispiele

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia> promote_type(Int16, Float16)
Float16

julia> promote_type(Int64, Float16)
Float16

julia> promote_type(Int8, UInt16)
UInt16

```

promote_rule(type1, type2)

Spezifiziert, welcher Typ von promote verwendet werden sollte, wenn Werte der Typen type1 und type2 gegeben sind. Diese Funktion sollte nicht direkt aufgerufen werden, sondern es sollten bei Bedarf Definitionen für neue Typen hinzugefügt werden.

promote_typejoin(T, S)

Berechne einen Typ, der sowohl T als auch S enthält, der entweder ein Elternteil beider Typen sein könnte oder ein Union, wenn es angemessen ist. Fällt zurück auf typejoin.

Siehe auch promote, promote_type.

Beispiele

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64

isdispatchtuple(T)

Bestimmen Sie, ob der Typ T ein "Blatttyp"-Tupel ist, was bedeutet, dass er als Typsignatur in der Dispatch erscheinen könnte und keine Subtypen (oder Supertypen) hat, die in einem Aufruf erscheinen könnten. Wenn T kein Typ ist, geben Sie false zurück.

ismutable(v) -> Bool

Gibt true zurück, wenn und nur wenn der Wert v veränderlich ist. Siehe Mutable Composite Types für eine Diskussion über Unveränderlichkeit. Beachten Sie, dass diese Funktion auf Werten arbeitet, sodass sie Ihnen sagt, dass ein Wert des Typs veränderlich ist, wenn Sie ihr einen DataType geben.

!!! Hinweis Aus technischen Gründen gibt ismutable true für Werte bestimmter spezieller Typen zurück (zum Beispiel String und Symbol), obwohl sie nicht auf erlaubte Weise verändert werden können.

Siehe auch isbits, isstructtype.

Beispiele

julia> ismutable(1)
false

julia> ismutable([1,2])
true

```

isimmutable(v) -> Bool

Gibt true zurück, wenn der Wert v unveränderlich ist. Siehe Mutable Composite Types für eine Diskussion über Unveränderlichkeit. Beachten Sie, dass diese Funktion auf Werten arbeitet, sodass sie Ihnen sagt, dass ein Wert von DataType veränderlich ist, wenn Sie ihr einen Typ geben.

Beispiele

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

ismutabletype(T) -> Bool

Bestimmen Sie, ob der Typ T als ein veränderlicher Typ deklariert wurde (d.h. unter Verwendung des Schlüsselworts mutable struct). Wenn T kein Typ ist, geben Sie false zurück.

isabstracttype(T)

Bestimmen Sie, ob der Typ T als abstrakter Typ deklariert wurde (d.h. unter Verwendung der abstract type-Syntax). Beachten Sie, dass dies nicht die Negation von isconcretetype(T) ist. Wenn T kein Typ ist, geben Sie false zurück.

Beispiele

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

Bestimmen Sie, ob der Typ T als primitiver Typ deklariert wurde (d.h. unter Verwendung der primitive type-Syntax). Wenn T kein Typ ist, geben Sie false zurück.

Base.issingletontype(T)

Bestimmen Sie, ob der Typ T genau eine mögliche Instanz hat; zum Beispiel ein Strukturtyp ohne Felder außer anderen Singleton-Werten. Wenn T kein konkreter Typ ist, geben Sie false zurück.

isstructtype(T) -> Bool

Bestimmen Sie, ob der Typ T als Strukturtyp deklariert wurde (d.h. unter Verwendung des Schlüsselworts struct oder mutable struct). Wenn T kein Typ ist, geben Sie false zurück.

nameof(t::DataType) -> Symbol

Holen Sie sich den Namen eines (möglicherweise UnionAll-umhüllten) DataType (ohne sein übergeordnetes Modul) als Symbol.

Beispiele

julia> module Foo
           struct S{T}
           end
       end
Foo

julia> nameof(Foo.S{T} where T)
:S

fieldnames(x::DataType)

Erhalten Sie ein Tupel mit den Namen der Felder eines DataType.

Siehe auch propertynames, hasfield.

Beispiele

julia> fieldnames(Rational)
(:num, :den)

julia> fieldnames(typeof(1+im))
(:re, :im)

fieldname(x::DataType, i::Integer)

Erhalte den Namen des Feldes i eines DataType.

Beispiele

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

fieldtype(T, name::Symbol | index::Int)

Bestimmen Sie den deklarierten Typ eines Feldes (angegeben durch Namen oder Index) in einem zusammengesetzten Datentyp T.

Beispiele

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

Die deklarierten Typen aller Felder in einem zusammengesetzten Datentyp T als ein Tupel.

Beispiele

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

Ermittelt die Anzahl der Felder, die eine Instanz des angegebenen Typs hätte. Ein Fehler wird ausgelöst, wenn der Typ zu abstrakt ist, um dies zu bestimmen.

hasfield(T::Type, name::Symbol)

Gibt einen Booleschen Wert zurück, der angibt, ob T name als eines seiner eigenen Felder hat.

Siehe auch fieldnames, fieldcount, hasproperty.

Beispiele

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false

nfields(x) -> Int

Erhalte die Anzahl der Felder im gegebenen Objekt.

Beispiele

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("Ich habe etwas Schlimmes getan");

julia> nfields(ex)
1

In diesen Beispielen ist a ein Rational, das zwei Felder hat. b ist ein Int, das ein primitiver Bittyp ohne Felder ist. ex ist eine ErrorException, die ein Feld hat.

isconst(m::Module, s::Symbol) -> Bool

Bestimmen Sie, ob eine globale Variable in einem gegebenen Modul m als const deklariert ist.

isconst(t::DataType, s::Union{Int,Symbol}) -> Bool

Bestimmen Sie, ob ein Feld s in einem gegebenen Typ t als const deklariert ist.

isfieldatomic(t::DataType, s::Union{Int,Symbol}) -> Bool

Bestimmen Sie, ob ein Feld s in einem gegebenen Typ t als @atomic deklariert ist.

sizeof(T::DataType)
sizeof(obj)

Größe in Bytes der kanonischen binären Darstellung des gegebenen DataType T, falls vorhanden. Oder die Größe in Bytes des Objekts obj, wenn es kein DataType ist.

Siehe auch Base.summarysize.

Beispiele

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof(collect(1.0:10.0))
80

julia> struct StructWithPadding
           x::Int64
           flag::Bool
       end

julia> sizeof(StructWithPadding) # nicht die Summe von `sizeof` der Felder aufgrund von Padding
16

julia> sizeof(Int64) + sizeof(Bool) # anders als oben
9

Wenn DataType T keine spezifische Größe hat, wird ein Fehler ausgelöst.

julia> sizeof(AbstractArray)
ERROR: Abstrakte Typ AbstractArray hat keine bestimmte Größe.
Stacktrace:
[...]

isconcretetype(T)

Bestimmen Sie, ob der Typ T ein konkreter Typ ist, was bedeutet, dass er direkte Instanzen haben könnte (Werte x, sodass typeof(x) === T). Beachten Sie, dass dies nicht die Negation von isabstracttype(T) ist. Wenn T kein Typ ist, geben Sie false zurück.

Siehe auch: isbits, isabstracttype, issingletontype.

Beispiele

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

julia> isconcretetype(Vector{Complex{Float32}})
true

julia> isconcretetype(Union{})
false

julia> isconcretetype(Union{Int,String})
false

isbits(x)

Gibt true zurück, wenn x eine Instanz eines isbitstype Typs ist.

isbitstype(T)

Gibt true zurück, wenn der Typ T ein "einfacher Datentyp" ist, was bedeutet, dass er unveränderlich ist und keine Verweise auf andere Werte enthält, sondern nur primitive Typen und andere isbitstype Typen. Typische Beispiele sind numerische Typen wie UInt8, Float64 und Complex{Float64}. Diese Kategorie von Typen ist bedeutend, da sie als Typparameter gültig sind, möglicherweise den Status isdefined / isassigned nicht verfolgen und ein definiertes Layout haben, das mit C kompatibel ist. Wenn T kein Typ ist, wird false zurückgegeben.

Siehe auch isbits, isprimitivetype, ismutable.

Beispiele

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

fieldoffset(type, i)

Der Byte-Offset des Feldes i eines Typs relativ zum Datenstart. Zum Beispiel könnten wir es auf folgende Weise verwenden, um Informationen über eine Struktur zusammenzufassen:

julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:fieldcount(T)];

julia> structinfo(Base.Filesystem.StatStruct)
13-element Vector{Tuple{UInt64, Symbol, Type}}:
 (0x0000000000000000, :desc, Union{RawFD, String})
 (0x0000000000000008, :device, UInt64)
 (0x0000000000000010, :inode, UInt64)
 (0x0000000000000018, :mode, UInt64)
 (0x0000000000000020, :nlink, Int64)
 (0x0000000000000028, :uid, UInt64)
 (0x0000000000000030, :gid, UInt64)
 (0x0000000000000038, :rdev, UInt64)
 (0x0000000000000040, :size, Int64)
 (0x0000000000000048, :blksize, Int64)
 (0x0000000000000050, :blocks, Int64)
 (0x0000000000000058, :mtime, Float64)
 (0x0000000000000060, :ctime, Float64)

Base.datatype_alignment(dt::DataType) -> Int

Minimale Ausrichtung der Speicherzuweisung für Instanzen dieses Typs. Kann für jeden isconcretetype aufgerufen werden, obwohl es für Memory die Ausrichtung der Elemente und nicht des gesamten Objekts zurückgibt.

Base.datatype_haspadding(dt::DataType) -> Bool

Gibt zurück, ob die Felder von Instanzen dieses Typs im Speicher gepackt sind, ohne dazwischenliegende Padding-Bits (definiert als Bits, deren Wert den Egal-Test, wenn er auf die Strukturfelder angewendet wird, nicht eindeutig beeinflusst). Kann auf jeden isconcretetype aufgerufen werden.

Base.datatype_pointerfree(dt::DataType) -> Bool

Gibt zurück, ob Instanzen dieses Typs Verweise auf vom GC verwalteten Speicher enthalten können. Kann auf jedem isconcretetype aufgerufen werden.

typemin(T)

Der niedrigste darstellbare Wert des angegebenen (reellen) Datentyps T.

Siehe auch: floatmin, typemax, eps.

Beispiele

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # kleinste endliche Float32-Gleitkommazahl
-3.4028235f38

typemax(T)

Der höchste Wert, der durch den gegebenen (reellen) numerischen DataType darstellbar ist.

Siehe auch: floatmax, typemin, eps.

Beispiele

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # größter endlicher Float32-Gleitkommawert
3.4028235f38

floatmin(T = Float64)

Gibt die kleinste positive normale Zahl zurück, die durch den Fließkommatyp T darstellbar ist.

Beispiele

julia> floatmin(Float16)
Float16(6.104e-5)

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T = Float64)

Gibt die größte darstellbare endliche Zahl des Fließkommatyps T zurück.

Siehe auch: typemax, floatmin, eps.

Beispiele

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf

maxintfloat(T=Float64)

Die größte aufeinanderfolgende ganzzahlige Fließkommazahl, die genau im gegebenen Fließkommatyp T (der standardmäßig auf Float64 gesetzt ist) dargestellt wird.

Das heißt, maxintfloat gibt die kleinste positive ganzzahlige Fließkommazahl n zurück, so dass n+1 nicht genau im Typ T darstellbar ist.

Wenn ein Wert vom Typ Integer benötigt wird, verwenden Sie Integer(maxintfloat(T)).

maxintfloat(T, S)

Die größte aufeinanderfolgende ganze Zahl, die im gegebenen Fließkommatyp T darstellbar ist und die auch nicht die maximale ganze Zahl überschreitet, die vom ganzzahligen Typ S darstellbar ist. Äquivalent dazu ist es das Minimum von maxintfloat(T) und typemax(S).

eps(::Type{T}) where T<:AbstractFloat
eps()

Gibt die Maschinen-Epsilon des Fließkommatyps T zurück (T = Float64 standardmäßig). Dies ist definiert als der Abstand zwischen 1 und dem nächstgrößeren Wert, der durch typeof(one(T)) darstellbar ist, und entspricht eps(one(T)). (Da eps(T) eine Schranke für den relativen Fehler von T ist, handelt es sich um eine "dimensionslose" Größe wie one.)

Beispiele

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0

eps(x::AbstractFloat)

Gibt die Einheit im letzten Platz (ulp) von x zurück. Dies ist der Abstand zwischen aufeinanderfolgenden darstellbaren Gleitkommawerten bei x. In den meisten Fällen, wenn der Abstand auf beiden Seiten von x unterschiedlich ist, wird der größere der beiden genommen, das heißt

eps(x) == max(x-prevfloat(x), nextfloat(x)-x)

Die Ausnahmen von dieser Regel sind die kleinsten und größten endlichen Werte (z. B. nextfloat(-Inf) und prevfloat(Inf) für Float64), die auf den kleineren der Werte gerundet werden.

Die Begründung für dieses Verhalten ist, dass eps den Gleitkomma-Rundungsfehler begrenzt. Im Standard-Rundungsmodus RoundNearest, wenn $y$ eine reelle Zahl ist und $x$ die nächstgelegene Gleitkommazahl zu $y$ ist, dann gilt

\[|y-x| \leq \operatorname{eps}(x)/2.\]

Siehe auch: nextfloat, issubnormal, floatmax.

Beispiele

julia> eps(1.0)
2.220446049250313e-16

julia> eps(prevfloat(2.0))
2.220446049250313e-16

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # größter endlicher Float64
1.7976931348623157e308

julia> x + eps(x)/2            # rundet auf
Inf

julia> x + prevfloat(eps(x)/2) # rundet ab
1.7976931348623157e308

instances(T::Type)

Gibt eine Sammlung aller Instanzen des angegebenen Typs zurück, falls zutreffend. Wird hauptsächlich für enumerierte Typen verwendet (siehe @enum).

Beispiele

julia> @enum Color red blue green

julia> instances(Color)
(red, blue, green)

Any::Datentyp

Any ist die Vereinigung aller Typen. Es hat die definierende Eigenschaft isa(x, Any) == true für jedes x. Any beschreibt daher das gesamte Universum möglicher Werte. Zum Beispiel ist Integer eine Teilmenge von Any, die Int, Int8 und andere Ganzzahltypen umfasst.

Union{Typen...}

Ein Union-Typ ist ein abstrakter Typ, der alle Instanzen seiner Argumenttypen umfasst. Das bedeutet, dass T <: Union{T,S} und S <: Union{T,S}.

Wie andere abstrakte Typen kann er nicht instanziiert werden, selbst wenn alle seine Argumente nicht abstrakt sind.

Beispiele

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 isa IntOrString # Instanz von Int ist im Union enthalten
true

julia> "Hello!" isa IntOrString # String ist ebenfalls enthalten
true

julia> 1.0 isa IntOrString # Float64 ist nicht enthalten, da es weder Int noch AbstractString ist
false

Erweiterte Hilfe

Im Gegensatz zu den meisten anderen parametrischen Typen sind Unions in ihren Parametern kovariant. Zum Beispiel ist Union{Real, String} ein Subtyp von Union{Number, AbstractString}.

Die leere Union Union{} ist der unterste Typ von Julia.

Union{}

Union{}, der leere Union von Typen, ist der Typ, der keine Werte hat. Das heißt, es hat die definierende Eigenschaft isa(x, Union{}) == false für jedes x. Base.Bottom ist als sein Alias definiert und der Typ von Union{} ist Core.TypeofBottom.

Beispiele

julia> isa(nothing, Union{})
false

UnionAll

Eine Vereinigung von Typen über alle Werte eines Typparameters. UnionAll wird verwendet, um parametrische Typen zu beschreiben, bei denen die Werte einiger Parameter nicht bekannt sind. Siehe den Handbuchabschnitt über UnionAll Types.

Beispiele

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

Ein Tupel ist ein Container fester Länge, der beliebige Werte unterschiedlicher Typen halten kann, aber nicht modifiziert werden kann (es ist unveränderlich). Die Werte können über Indizes zugegriffen werden. Tupel-Literale werden mit Kommas und Klammern geschrieben:

julia> (1, 1+1)
(1, 2)

julia> (1,)
(1,)

julia> x = (0.0, "hello", 6*7)
(0.0, "hello", 42)

julia> x[2]
"hello"

julia> typeof(x)
Tuple{Float64, String, Int64}

Ein Tupel der Länge 1 muss mit einem Komma geschrieben werden, (1,), da (1) nur einen in Klammern gesetzten Wert darstellen würde. () repräsentiert das leere (Länge-0) Tupel.

Ein Tupel kann aus einem Iterator konstruiert werden, indem ein Tuple-Typ als Konstruktor verwendet wird:

julia> Tuple(["a", 1])
("a", 1)

julia> Tuple{String, Float64}(["a", 1])
("a", 1.0)

Tupeltypen sind in ihren Parametern kovariant: Tuple{Int} ist ein Subtyp von Tuple{Any}. Daher wird Tuple{Any} als abstrakter Typ betrachtet, und Tupeltypen sind nur konkret, wenn ihre Parameter es sind. Tupel haben keine Feldnamen; Felder werden nur über Indizes zugegriffen. Tupeltypen können beliebig viele Parameter haben.

Siehe den Handbuchabschnitt über Tuple Types.

Siehe auch Vararg, NTuple, ntuple, tuple, NamedTuple.

NTuple{N, T}

Eine kompakte Möglichkeit, den Typ für ein Tupel der Länge N darzustellen, bei dem alle Elemente vom Typ T sind.

Beispiele

julia> isa((1, 2, 3, 4, 5, 6), NTuple{6, Int})
true

Siehe auch ntuple.

NamedTuple

NamedTuples sind, wie der Name schon sagt, benannte Tuples. Das heißt, sie sind eine tuple-ähnliche Sammlung von Werten, bei der jeder Eintrag einen eindeutigen Namen hat, der als Symbol dargestellt wird. Wie Tuples sind NamedTuples unveränderlich; weder die Namen noch die Werte können nach der Konstruktion vor Ort geändert werden.

Ein benanntes Tupel kann als Tupel-Literal mit Schlüsseln erstellt werden, z.B. (a=1, b=2), oder als Tupel-Literal mit Semikolon nach der öffnenden Klammer, z.B. (; a=1, b=2) (diese Form akzeptiert auch programmgenerierte Namen, wie unten beschrieben), oder unter Verwendung eines NamedTuple-Typs als Konstruktor, z.B. NamedTuple{(:a, :b)}((1,2)).

Der Zugriff auf den Wert, der mit einem Namen in einem benannten Tupel verknüpft ist, kann mit der Feldzugriffs-Syntax erfolgen, z.B. x.a, oder unter Verwendung von getindex, z.B. x[:a] oder x[(:a, :b)]. Ein Tupel der Namen kann mit keys erhalten werden, und ein Tupel der Werte kann mit values erhalten werden.

Das @NamedTuple Makro kann verwendet werden, um NamedTuple-Typen bequem zu deklarieren.

Beispiele

julia> x = (a=1, b=2)
(a = 1, b = 2)

julia> x.a
1

julia> x[:a]
1

julia> x[(:a,)]
(a = 1,)

julia> keys(x)
(:a, :b)

julia> values(x)
(1, 2)

julia> collect(x)
2-element Vector{Int64}:
 1
 2

julia> collect(pairs(x))
2-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2

In ähnlicher Weise, wie man Schlüsselwortargumente programmgesteuert definieren kann, kann ein benanntes Tupel erstellt werden, indem man Paare name::Symbol => value nach einem Semikolon innerhalb eines Tupel-Literals angibt. Diese und die name=value-Syntax können gemischt werden:

julia> (; :a => 1, :b => 2, c=3)
(a = 1, b = 2, c = 3)

Die Name-Wert-Paare können auch bereitgestellt werden, indem ein benanntes Tupel oder ein beliebiger Iterator, der zweiwertige Sammlungen mit jeweils einem Symbol als erstem Wert erzeugt, gesplattet wird:

julia> keys = (:a, :b, :c); values = (1, 2, 3);

julia> NamedTuple{keys}(values)
(a = 1, b = 2, c = 3)

julia> (; (keys .=> values)...)
(a = 1, b = 2, c = 3)

julia> nt1 = (a=1, b=2);

julia> nt2 = (c=3, d=4);

julia> (; nt1..., nt2..., b=20) # das finale b überschreibt den Wert von nt1
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zip erzeugt Tupel wie (:a, 1)
(a = 1, b = 2, c = 3)

Wie bei Schlüsselwortargumenten implizieren Bezeichner und Punkt-Ausdrücke Namen:

julia> x = 0
0

julia> t = (; x)
(x = 0,)

julia> (; t.x)
(x = 0,)

@NamedTuple{key1::Type1, key2::Type2, ...}
@NamedTuple begin key1::Type1; key2::Type2; ...; end

Dieses Makro bietet eine bequemere Syntax zur Deklaration von NamedTuple-Typen. Es gibt einen NamedTuple-Typ mit den angegebenen Schlüsseln und Typen zurück, der äquivalent zu NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}} ist. Wenn die ::Type-Deklaration weggelassen wird, wird sie als Any betrachtet. Die begin ... end-Form ermöglicht es, die Deklarationen über mehrere Zeilen zu verteilen (ähnlich einer struct-Deklaration), ist aber ansonsten äquivalent. Das NamedTuple-Makro wird verwendet, wenn NamedTuple-Typen z.B. im REPL ausgegeben werden.

Zum Beispiel hat das Tupel (a=3.1, b="hello") einen Typ NamedTuple{(:a, :b), Tuple{Float64, String}}, der auch über @NamedTuple wie folgt deklariert werden kann:

julia> @NamedTuple{a::Float64, b::String}
@NamedTuple{a::Float64, b::String}

julia> @NamedTuple begin
           a::Float64
           b::String
       end
@NamedTuple{a::Float64, b::String}

@Kwargs{key1::Type1, key2::Type2, ...}

Dieses Makro bietet eine bequeme Möglichkeit, die Typdarstellung von Schlüsselwortargumenten aus derselben Syntax wie @NamedTuple zu erstellen. Zum Beispiel, wenn wir einen Funktionsaufruf wie func([positional arguments]; kw1=1.0, kw2="2") haben, können wir dieses Makro verwenden, um die interne Typdarstellung der Schlüsselwortargumente als @Kwargs{kw1::Float64, kw2::String} zu konstruieren. Die Makrosyntax ist speziell darauf ausgelegt, den Signaturtyp einer Schlüsselwortmethode zu vereinfachen, wenn sie in der Stack-Trace-Ansicht gedruckt wird.

julia> @Kwargs{init::Int} # die interne Darstellung von Schlüsselwortargumenten
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: kein passender Methode für +(::Char, ::Char) gefunden
Die Funktion `+` existiert, aber keine Methode ist für diese Kombination von Argumenttypen definiert.

Nächste Kandidaten sind:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) wo T<:AbstractChar
   @ Base char.jl:237

Stacktrace:
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [inlined]
  [3] _foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, init::Int64, itr::String)
    @ Base ./reduce.jl:62
  [4] foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, nt::Int64, itr::String)
    @ Base ./reduce.jl:48 [inlined]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [inlined]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [inlined]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [inlined]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [inlined]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [inlined]
 [10] top-level scope
    @ REPL[12]:1

Val(c)

Gibt Val{c}() zurück, das keine Laufzeitdaten enthält. Typen wie dieser können verwendet werden, um Informationen zwischen Funktionen durch den Wert c zu übergeben, der ein isbits-Wert oder ein Symbol sein muss. Der Zweck dieser Konstruktion ist es, direkt (zur Compile-Zeit) auf Konstanten zu dispatchen, ohne den Wert der Konstanten zur Laufzeit testen zu müssen.

Beispiele

julia> f(::Val{true}) = "Gut"
f (generische Funktion mit 1 Methode)

julia> f(::Val{false}) = "Schlecht"
f (generische Funktion mit 2 Methoden)

julia> f(Val(true))
"Gut"

Vararg{T,N}

Der letzte Parameter eines Tupeltyps Tuple kann der spezielle Wert Vararg sein, der eine beliebige Anzahl von nachfolgenden Elementen bezeichnet. Vararg{T,N} entspricht genau N Elementen des Typs T. Schließlich entspricht Vararg{T} null oder mehr Elementen des Typs T. Vararg Tupeltypen werden verwendet, um die Argumente darzustellen, die von varargs-Methoden akzeptiert werden (siehe den Abschnitt über Varargs-Funktionen im Handbuch.)

Siehe auch NTuple.

Beispiele

julia> mytupletype = Tuple{AbstractString, Vararg{Int}}
Tuple{AbstractString, Vararg{Int64}}

julia> isa(("1",), mytupletype)
true

julia> isa(("1",1), mytupletype)
true

julia> isa(("1",1,2), mytupletype)
true

julia> isa(("1",1,2,3.0), mytupletype)
false

Nichts

Ein Typ ohne Felder, der der Typ von nothing ist.

Siehe auch: isnothing, Some, Missing.

isnothing(x)

Gibt true zurück, wenn x === nothing ist, und gibt false zurück, wenn nicht.

Siehe auch something, Base.notnothing, ismissing.

notnothing(x)

Wirft einen Fehler, wenn x === nothing und gibt x zurück, wenn nicht.

Some{T}

Ein Wrapper-Typ, der in Union{Some{T}, Nothing} verwendet wird, um zwischen der Abwesenheit eines Wertes (nothing) und der Anwesenheit eines nothing-Wertes (d.h. Some(nothing)) zu unterscheiden.

Verwenden Sie something, um auf den Wert zuzugreifen, der von einem Some-Objekt umschlossen ist.

something(x...)

Gibt den ersten Wert in den Argumenten zurück, der nicht gleich nothing ist, falls vorhanden. Andernfalls wird ein Fehler ausgelöst. Argumente vom Typ Some werden entpackt.

Siehe auch coalesce, skipmissing, @something.

Beispiele

julia> something(nothing, 1)
1

julia> something(Some(1), nothing)
1

julia> something(Some(nothing), 2) === nothing
true

julia> something(missing, nothing)
missing

julia> something(nothing, nothing)
ERROR: ArgumentError: Keine Wertargumente vorhanden

@something(x...)

Kurzschlussversion von something.

Beispiele

julia> f(x) = (println("f($x)"); nothing);

julia> a = 1;

julia> a = @something a f(2) f(3) error("Standardwert für `a` nicht gefunden")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("Standardwert für `b` nicht gefunden")
f(2)
f(3)
ERROR: Standardwert für `b` nicht gefunden
[...]

julia> b = @something b f(2) f(3) Some(nothing)
f(2)
f(3)

julia> b === nothing
true

Enum{T<:Integer}

Der abstrakte Supertyp aller enumerierten Typen, die mit @enum definiert sind.

@enum EnumName[::BaseType] value1[=x] value2[=y]

Erstellt einen Enum{BaseType}-Untertyp mit dem Namen EnumName und den Enum-Mitgliedswerten value1 und value2 mit optional zugewiesenen Werten x und y. EnumName kann wie andere Typen verwendet werden und Enum-Mitgliedswerte als reguläre Werte, wie zum Beispiel

Beispiele

julia> @enum Fruit apple=1 orange=2 kiwi=3

julia> f(x::Fruit) = "Ich bin ein Fruit mit dem Wert: $(Int(x))"
f (generische Funktion mit 1 Methode)

julia> f(apple)
"Ich bin ein Fruit mit dem Wert: 1"

julia> Fruit(1)
apple::Fruit = 1

Werte können auch innerhalb eines begin-Blocks angegeben werden, z.B.

@enum EnumName begin
    value1
    value2
end

BaseType, das standardmäßig Int32 ist, muss ein primitiver Untertyp von Integer sein. Mitgliedswerte können zwischen dem Enum-Typ und BaseType konvertiert werden. read und write führen diese Konvertierungen automatisch durch. Falls das Enum mit einem nicht standardmäßigen BaseType erstellt wird, gibt Integer(value1) den ganzzahligen value1 mit dem Typ BaseType zurück.

Um alle Instanzen eines Enums aufzulisten, verwenden Sie instances, z.B.

julia> instances(Fruit)
(apple, orange, kiwi)

Es ist möglich, ein Symbol aus einer Enum-Instanz zu konstruieren:

julia> Symbol(apple)
:apple

Expr(head::Symbol, args...)

Ein Typ, der zusammengesetzte Ausdrücke im geparsten Julia-Code (ASTs) darstellt. Jeder Ausdruck besteht aus einem head Symbol, das angibt, um welche Art von Ausdruck es sich handelt (z. B. einen Aufruf, eine Schleife, eine bedingte Anweisung usw.), und Unterausdrücken (z. B. die Argumente eines Aufrufs). Die Unterausdrücke werden in einem Vector{Any}-Feld namens args gespeichert.

Siehe das Handbuchkapitel über Metaprogrammierung und die Entwicklermokumentation Julia ASTs.

Beispiele

julia> Expr(:call, :+, 1, 2)
:(1 + 2)

julia> dump(:(a ? b : c))
Expr
  head: Symbol if
  args: Array{Any}((3,))
    1: Symbol a
    2: Symbol b
    3: Symbol c

Symbol

Der Typ des Objekts, das verwendet wird, um Bezeichner in geparstem Julia-Code (ASTs) darzustellen. Wird auch oft als Name oder Etikett verwendet, um eine Entität zu identifizieren (z. B. als Schlüssel in einem Wörterbuch). Symbols können mit dem :-Zitatoperator eingegeben werden:

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

Symbols können auch aus Zeichenfolgen oder anderen Werten konstruiert werden, indem der Konstruktor Symbol(x...) aufgerufen wird.

Symbols sind unveränderlich und ihre Implementierung verwendet dasselbe Objekt für alle Symbols mit demselben Namen.

Im Gegensatz zu Zeichenfolgen sind Symbols "atomare" oder "skalare" Entitäten, die keine Iteration über Zeichen unterstützen.

Symbol(x...) -> Symbol

Erstellen Sie ein Symbol, indem Sie die String-Darstellungen der Argumente zusammenfügen.

Beispiele

julia> Symbol("my", "name")
:myname

julia> Symbol("day", 4)
:day4

Modul

Ein Modul ist ein separater globaler Variablenarbeitsbereich. Siehe module und den Handbuchabschnitt über Module für Details.

Module(name::Symbol=:anonymous, std_imports=true, default_names=true)

Gibt ein Modul mit dem angegebenen Namen zurück. Ein baremodule entspricht Module(:ModuleName, false)

Ein leeres Modul, das überhaupt keine Namen enthält, kann mit Module(:ModuleName, false, false) erstellt werden. Dieses Modul importiert weder Base noch Core und enthält keinen Verweis auf sich selbst.

Funktion

Abstrakter Typ aller Funktionen.

Beispiele

julia> isa(+, Funktion)
true

julia> typeof(sin)
typeof(sin) (Singleton-Typ der Funktion sin, Untertyp von Funktion)

julia> ans <: Funktion
true

hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=get_world_counter()) -> Bool

Bestimmen Sie, ob die gegebene generische Funktion eine Methode hat, die mit dem gegebenen Tuple von Argumenttypen übereinstimmt, wobei die obere Grenze des Weltalters durch world angegeben wird.

Wenn ein Tuple von Namen der Schlüsselwortargumente kwnames bereitgestellt wird, wird auch überprüft, ob die Methode von f, die mit t übereinstimmt, die gegebenen Namen der Schlüsselwortargumente hat. Wenn die übereinstimmende Methode eine variable Anzahl von Schlüsselwortargumenten akzeptiert, z. B. mit kwargs..., werden alle in kwnames angegebenen Namen als gültig betrachtet. Andernfalls müssen die bereitgestellten Namen eine Teilmenge der Schlüsselwortargumente der Methode sein.

Siehe auch applicable.

Beispiele

julia> hasmethod(length, Tuple{Array})
true

julia> f(; oranges=0) = oranges;

julia> hasmethod(f, Tuple{}, (:oranges,))
true

julia> hasmethod(f, Tuple{}, (:apples, :bananas))
false

julia> g(; xs...) = 4;

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g akzeptiert beliebige kwargs
true

applicable(f, args...) -> Bool

Bestimmen Sie, ob die gegebene generische Funktion eine Methode hat, die auf die gegebenen Argumente anwendbar ist.

Siehe auch hasmethod.

Beispiele

julia> function f(x, y)
           x + y
       end;

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

Base.isambiguous(m1, m2; ambiguous_bottom=false) -> Bool

Bestimmen Sie, ob zwei Methoden m1 und m2 für eine bestimmte Aufrufsignatur mehrdeutig sein könnten. Dieser Test wird im Kontext anderer Methoden derselben Funktion durchgeführt; isoliert könnten m1 und m2 mehrdeutig sein, aber wenn eine dritte Methode, die die Mehrdeutigkeit auflöst, definiert wurde, gibt dies false zurück. Alternativ könnten m1 und m2 isoliert geordnet sein, aber wenn eine dritte Methode nicht mit ihnen sortiert werden kann, könnten sie zusammen eine Mehrdeutigkeit verursachen.

Für parametrische Typen steuert das Schlüsselwortargument ambiguous_bottom, ob Union{} als mehrdeutige Schnittmenge von Typparametern zählt – wenn true, wird es als mehrdeutig betrachtet, wenn false, dann nicht.

Beispiele

julia> foo(x::Complex{<:Integer}) = 1
foo (generische Funktion mit 1 Methode)

julia> foo(x::Complex{<:Rational}) = 2
foo (generische Funktion mit 2 Methoden)

julia> m1, m2 = collect(methods(foo));

julia> typeintersect(m1.sig, m2.sig)
Tuple{typeof(foo), Complex{Union{}}}

julia> Base.isambiguous(m1, m2, ambiguous_bottom=true)
true

julia> Base.isambiguous(m1, m2, ambiguous_bottom=false)
false

invoke(f, argtypes::Type, args...; kwargs...)

Ruft eine Methode für die gegebene generische Funktion f auf, die den angegebenen Typen argtypes für die angegebenen Argumente args entspricht und die Schlüsselwortargumente kwargs übergibt. Die Argumente args müssen den angegebenen Typen in argtypes entsprechen, d.h. eine Umwandlung wird nicht automatisch durchgeführt. Diese Methode ermöglicht das Aufrufen einer Methode, die nicht die spezifischste übereinstimmende Methode ist, was nützlich ist, wenn das Verhalten einer allgemeineren Definition ausdrücklich benötigt wird (oft als Teil der Implementierung einer spezifischeren Methode derselben Funktion).

Seien Sie vorsichtig, wenn Sie invoke für Funktionen verwenden, die Sie nicht selbst geschrieben haben. Welche Definition für die gegebenen argtypes verwendet wird, ist ein Implementierungsdetail, es sei denn, die Funktion gibt ausdrücklich an, dass das Aufrufen mit bestimmten argtypes Teil der öffentlichen API ist. Zum Beispiel wird der Wechsel zwischen f1 und f2 im folgenden Beispiel normalerweise als kompatibel angesehen, da die Änderung für den Aufrufer bei einem normalen (nicht-invoke) Aufruf unsichtbar ist. Die Änderung ist jedoch sichtbar, wenn Sie invoke verwenden.

Beispiele

julia> f(x::Real) = x^2;

julia> f(x::Integer) = 1 + invoke(f, Tuple{Real}, x);

julia> f(2)
5

julia> f1(::Integer) = Integer
       f1(::Real) = Real;

julia> f2(x::Real) = _f2(x)
       _f2(::Integer) = Integer
       _f2(_) = Real;

julia> f1(1)
Integer

julia> f2(1)
Integer

julia> invoke(f1, Tuple{Real}, 1)
Real

julia> invoke(f2, Tuple{Real}, 1)
Integer

@invoke f(arg::T, ...; kwargs...)

Bietet eine bequeme Möglichkeit, invoke aufzurufen, indem @invoke f(arg1::T1, arg2::T2; kwargs...) auf invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...) erweitert wird. Wenn die Typannotation eines Arguments weggelassen wird, wird sie durch Core.Typeof dieses Arguments ersetzt. Um eine Methode aufzurufen, bei der ein Argument untypisiert oder explizit als Any typisiert ist, annotiere das Argument mit ::Any.

Es unterstützt auch die folgende Syntax:

• @invoke (x::X).f wird zu invoke(getproperty, Tuple{X,Symbol}, x, :f) erweitert
• @invoke (x::X).f = v::V wird zu invoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v) erweitert
• @invoke (xs::Xs)[i::I] wird zu invoke(getindex, Tuple{Xs,I}, xs, i) erweitert
• @invoke (xs::Xs)[i::I] = v::V wird zu invoke(setindex!, Tuple{Xs,V,I}, xs, v, i) erweitert

Beispiele

julia> @macroexpand @invoke f(x::T, y)
:(Core.invoke(f, Tuple{T, Core.Typeof(y)}, x, y))

julia> @invoke 420::Integer % Unsigned
0x00000000000001a4

julia> @macroexpand @invoke (x::X).f
:(Core.invoke(Base.getproperty, Tuple{X, Core.Typeof(:f)}, x, :f))

julia> @macroexpand @invoke (x::X).f = v::V
:(Core.invoke(Base.setproperty!, Tuple{X, Core.Typeof(:f), V}, x, :f, v))

julia> @macroexpand @invoke (xs::Xs)[i::I]
:(Core.invoke(Base.getindex, Tuple{Xs, I}, xs, i))

julia> @macroexpand @invoke (xs::Xs)[i::I] = v::V
:(Core.invoke(Base.setindex!, Tuple{Xs, V, I}, xs, v, i))

invokelatest(f, args...; kwargs...)

Ruft f(args...; kwargs...) auf, garantiert jedoch, dass die aktuellste Methode von f ausgeführt wird. Dies ist in speziellen Umständen nützlich, z. B. in langlaufenden Ereignisschleifen oder Rückruffunktionen, die veraltete Versionen einer Funktion f aufrufen können. (Der Nachteil ist, dass invokelatest etwas langsamer ist als der direkte Aufruf von f, und der Typ des Ergebnisses kann vom Compiler nicht abgeleitet werden.)

@invokelatest f(args...; kwargs...)

Bietet eine bequeme Möglichkeit, invokelatest aufzurufen. @invokelatest f(args...; kwargs...) wird einfach in Base.invokelatest(f, args...; kwargs...) umgewandelt.

Es unterstützt auch die folgende Syntax:

• @invokelatest x.f wird zu Base.invokelatest(getproperty, x, :f) umgewandelt
• @invokelatest x.f = v wird zu Base.invokelatest(setproperty!, x, :f, v) umgewandelt
• @invokelatest xs[i] wird zu Base.invokelatest(getindex, xs, i) umgewandelt
• @invokelatest xs[i] = v wird zu Base.invokelatest(setindex!, xs, v, i) umgewandelt

julia> @macroexpand @invokelatest f(x; kw=kwv)
:(Base.invokelatest(f, x; kw = kwv))

julia> @macroexpand @invokelatest x.f
:(Base.invokelatest(Base.getproperty, x, :f))

julia> @macroexpand @invokelatest x.f = v
:(Base.invokelatest(Base.setproperty!, x, :f, v))

julia> @macroexpand @invokelatest xs[i]
:(Base.invokelatest(Base.getindex, xs, i))

julia> @macroexpand @invokelatest xs[i] = v
:(Base.invokelatest(Base.setindex!, xs, v, i))

new, oder new{A,B,...}

Spezialfunktion, die inneren Konstruktoren zur Verfügung steht und ein neues Objekt des Typs erstellt. Die Form new{A,B,...} gibt explizit Werte für Parameter für parametrische Typen an. Siehe den Handbuchabschnitt über Inner Constructor Methods für weitere Informationen.

|>(x, f)

Infix-Operator, der die Funktion f auf das Argument x anwendet. Dies ermöglicht es, f(g(x)) als x |> g |> f zu schreiben. Bei der Verwendung mit anonymen Funktionen sind normalerweise Klammern um die Definition erforderlich, um die beabsichtigte Kette zu erhalten.

Beispiele

julia> 4 |> inv
0.25

julia> [2, 3, 5] |> sum |> inv
0.1

julia> [0 1; 2 3] .|> (x -> x^2) |> sum
14

f ∘ g

Funktionen zusammensetzen: d.h. (f ∘ g)(args...; kwargs...) bedeutet f(g(args...; kwargs...)). Das Symbol ∘ kann im Julia REPL (und in den meisten entsprechend konfigurierten Editoren) eingegeben werden, indem man \circ<tab> tippt.

Die Funktionskomposition funktioniert auch in Präfixform: ∘(f, g) ist dasselbe wie f ∘ g. Die Präfixform unterstützt die Komposition mehrerer Funktionen: ∘(f, g, h) = f ∘ g ∘ h und das Splatting ∘(fs...) zur Komposition einer iterierbaren Sammlung von Funktionen. Das letzte Argument von ∘ wird zuerst ausgeführt.

Beispiele

julia> map(uppercase∘first, ["apple", "banana", "carrot"])
3-element Vector{Char}:
 'A': ASCII/Unicode U+0041 (Kategorie Lu: Buchstabe, Großbuchstabe)
 'B': ASCII/Unicode U+0042 (Kategorie Lu: Buchstabe, Großbuchstabe)
 'C': ASCII/Unicode U+0043 (Kategorie Lu: Buchstabe, Großbuchstabe)

julia> (==(6)∘length).(["apple", "banana", "carrot"])
3-element BitVector:
 0
 1
 1

julia> fs = [
           x -> 2x
           x -> x-1
           x -> x/2
           x -> x+1
       ];

julia> ∘(fs...)(3)
2.0

Siehe auch ComposedFunction, !f::Function.

ComposedFunction{Outer,Inner} <: Funktion

Stellt die Komposition von zwei aufrufbaren Objekten outer::Outer und inner::Inner dar. Das heißt

ComposedFunction(outer, inner)(args...; kw...) === outer(inner(args...; kw...))

Die bevorzugte Methode zur Konstruktion einer Instanz von ComposedFunction ist die Verwendung des Kompositionsoperators ∘:

julia> sin ∘ cos === ComposedFunction(sin, cos)
true

julia> typeof(sin∘cos)
ComposedFunction{typeof(sin), typeof(cos)}

Die zusammengesetzten Teile werden in den Feldern von ComposedFunction gespeichert und können wie folgt abgerufen werden:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true

Siehe auch ∘.

splat(f)

Entspricht

    my_splat(f) = args->f(args...)

d.h. gegeben eine Funktion gibt es eine neue Funktion zurück, die ein Argument annimmt und es in die ursprüngliche Funktion splat. Dies ist nützlich als Adapter, um eine Funktion mit mehreren Argumenten in einem Kontext zu übergeben, der ein einzelnes Argument erwartet, aber ein Tupel als dieses einzelne Argument übergibt.

Beispiele

julia> map(splat(+), zip(1:3,4:6))
3-element Vector{Int64}:
 5
 7
 9

julia> my_add = splat(+)
splat(+)

julia> my_add((1,2,3))
6

Fix1(f, x)

Ein Typ, der eine teilweise angewendete Version der zweiarigen Funktion f darstellt, wobei das erste Argument auf den Wert "x" festgelegt ist. Mit anderen Worten, Fix1(f, x) verhält sich ähnlich wie y->f(x, y).

Siehe auch Fix2.

Fix2(f, x)

Ein Typ, der eine teilweise angewendete Version der zwei-Argumente-Funktion f darstellt, wobei das zweite Argument auf den Wert "x" festgelegt ist. Mit anderen Worten, Fix2(f, x) verhält sich ähnlich wie y->f(y, x).

Core.eval(m::Module, expr)

Bewerte einen Ausdruck im gegebenen Modul und gib das Ergebnis zurück.

eval(expr)

Bewerte einen Ausdruck im globalen Geltungsbereich des enthaltenen Moduls. Jedes Module (außer denjenigen, die mit baremodule definiert sind) hat seine eigene 1-Argument-Definition von eval, die Ausdrücke in diesem Modul bewertet.

@eval [mod,] ex

Bewerten Sie einen Ausdruck mit interpolierten Werten, indem Sie eval verwenden. Wenn zwei Argumente angegeben sind, ist das erste das Modul, in dem bewertet werden soll.

evalfile(path::AbstractString, args::Vector{String}=String[])

Lädt die Datei in ein anonymes Modul mit include, bewertet alle Ausdrücke und gibt den Wert des letzten Ausdrucks zurück. Das optionale Argument args kann verwendet werden, um die Eingabeargumente des Skripts festzulegen (d.h. die globale ARGS-Variable). Beachten Sie, dass Definitionen (z.B. Methoden, globale Variablen) im anonymen Modul ausgewertet werden und das aktuelle Modul nicht beeinflussen.

Beispiele

julia> write("testfile.jl", """
           @show ARGS
           1 + 1
       """);

julia> x = evalfile("testfile.jl", ["ARG1", "ARG2"]);
ARGS = ["ARG1", "ARG2"]

julia> x
2

julia> rm("testfile.jl")

esc(e)

Nur im Kontext eines Expr, der von einem Makro zurückgegeben wird, gültig. Verhindert, dass der Hygienepass des Makros eingebettete Variablen in Gensym-Variablen umwandelt. Siehe den Abschnitt Makros im Kapitel zur Metaprogrammierung des Handbuchs für weitere Details und Beispiele.

@inbounds(blk)

Eliminiert die Überprüfung der Array-Grenzen innerhalb von Ausdrücken.

Im folgenden Beispiel wird die Überprüfung, ob der Index i des Arrays A im gültigen Bereich liegt, übersprungen, um die Leistung zu verbessern.

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i in eachindex(A)
        @inbounds r += A[i]
    end
    return r
end

@boundscheck(blk)

Annotiert den Ausdruck blk als einen Bereichsprüfblock, der durch @inbounds ausgelassen werden kann.

Beispiele

julia> @inline function g(A, i)
           @boundscheck checkbounds(A, i)
           return "accessing ($A)[$i]"
       end;

julia> f1() = return g(1:2, -1);

julia> f2() = @inbounds return g(1:2, -1);

julia> f1()
ERROR: BoundsError: Versuch, auf 2-elementigen UnitRange{Int64} bei Index [-1] zuzugreifen
Stacktrace:
 [1] throw_boundserror(::UnitRange{Int64}, ::Tuple{Int64}) at ./abstractarray.jl:455
 [2] checkbounds at ./abstractarray.jl:420 [inlined]
 [3] g at ./none:2 [inlined]
 [4] f1() at ./none:1
 [5] top-level scope

julia> f2()
"accessing (1:2)[-1]"

@propagate_inbounds

Sagt dem Compiler, eine Funktion inline zu setzen, während der Inbounds-Kontext des Aufrufers beibehalten wird.

@inline

Gibt dem Compiler einen Hinweis, dass diese Funktion es wert ist, inline zu sein.

Kleine Funktionen benötigen typischerweise nicht die @inline-Annotation, da der Compiler dies automatisch erledigt. Durch die Verwendung von @inline bei größeren Funktionen kann dem Compiler ein zusätzlicher Anstoß gegeben werden, sie inline zu machen.

@inline kann unmittelbar vor einer Funktionsdefinition oder innerhalb eines Funktionskörpers angewendet werden.

# annotiere lange Definition
@inline function longdef(x)
    ...
end

# annotiere kurze Definition
@inline shortdef(x) = ...

# annotiere anonyme Funktion, die ein `do`-Block erstellt
f() do
    @inline
    ...
end

@inline block

Gibt dem Compiler einen Hinweis, dass Aufrufe innerhalb von block es wert sind, inline zu sein.

# Der Compiler wird versuchen, `f` inline zu machen
@inline f(...)

# Der Compiler wird versuchen, `f`, `g` und `+` inline zu machen
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # Körper
end

let
    @inline explicit_noinline(args...) # wird inline gemacht
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # der Compiler wird versuchen, diesen Aufruf inline zu machen
    b = f(b0)          # der Compiler wird diesen Aufruf NICHT inline machen
    return a, b
end

@noinline

Gibt dem Compiler einen Hinweis, dass er eine Funktion nicht inline setzen soll.

Kleine Funktionen werden typischerweise automatisch inline gesetzt. Durch die Verwendung von @noinline bei kleinen Funktionen kann das automatische Inlining verhindert werden.

@noinline kann unmittelbar vor einer Funktionsdefinition oder innerhalb eines Funktionskörpers angewendet werden.

# annotiere lange Definition
@noinline function longdef(x)
    ...
end

# annotiere kurze Definition
@noinline shortdef(x) = ...

# annotiere anonyme Funktion, die ein `do`-Block erstellt
f() do
    @noinline
    ...
end

@noinline block

Gibt dem Compiler einen Hinweis, dass er die Aufrufe innerhalb von block nicht inline setzen soll.

# Der Compiler wird versuchen, `f` nicht inline zu setzen
@noinline f(...)

# Der Compiler wird versuchen, `f`, `g` und `+` nicht inline zu setzen
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # Körper
end

let
    @noinline explicit_inline(args...) # wird nicht inline gesetzt
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # der Compiler wird NICHT versuchen, diesen Aufruf inline zu setzen
    b = f(b0)            # der Compiler wird versuchen, diesen Aufruf inline zu setzen
    return a, b
end

@nospecialize

Angewendet auf einen Funktionsargumentnamen weist der Compiler darauf hin, dass die Implementierung der Methode nicht für verschiedene Typen dieses Arguments spezialisiert werden sollte, sondern stattdessen den deklarierten Typ für dieses Argument verwendet werden soll. Es kann auf ein Argument innerhalb einer formalen Argumentliste oder im Funktionskörper angewendet werden. Wenn es auf ein Argument angewendet wird, muss das Makro den gesamten Argumentausdruck umschließen, z. B. @nospecialize(x::Real) oder @nospecialize(i::Integer...), anstatt nur den Argumentnamen zu umschließen. Wenn es im Funktionskörper verwendet wird, muss das Makro an einer Anweisungstelle und vor jeglichem Code auftreten.

Wenn es ohne Argumente verwendet wird, gilt es für alle Argumente des übergeordneten Bereichs. Im lokalen Bereich bedeutet dies alle Argumente der umschließenden Funktion. Im globalen (obersten) Bereich bedeutet dies alle Methoden, die anschließend im aktuellen Modul definiert werden.

Die Spezialisierung kann durch die Verwendung von @specialize auf den Standard zurückgesetzt werden.

function example_function(@nospecialize x)
    ...
end

function example_function(x, @nospecialize(y = 1))
    ...
end

function example_function(x, y, z)
    @nospecialize x y
    ...
end

@nospecialize
f(y) = [x for x in y]
@specialize

!!! Hinweis @nospecialize beeinflusst die Codegenerierung, jedoch nicht die Inferenz: Es begrenzt die Vielfalt des resultierenden nativen Codes, auferlegt jedoch keine Einschränkungen (über die Standardbeschränkungen hinaus) bei der Typinferenz. Verwenden Sie Base.@nospecializeinfer zusammen mit @nospecialize, um zusätzlich die Inferenz zu unterdrücken.

Beispiele

julia> f(A::AbstractArray) = g(A)
f (generische Funktion mit 1 Methode)

julia> @noinline g(@nospecialize(A::AbstractArray)) = A[1]
g (generische Funktion mit 1 Methode)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Float64
└──      return %1
) => Float64

Hier führt die Annotation @nospecialize zum Äquivalent von

f(A::AbstractArray) = invoke(g, Tuple{AbstractArray}, A)

was sicherstellt, dass nur eine Version des nativen Codes für g generiert wird, die generisch für jedes AbstractArray ist. Der spezifische Rückgabewert wird jedoch weiterhin sowohl für g als auch für f abgeleitet, und dies wird weiterhin zur Optimierung der Aufrufer von f und g verwendet.

@specialize

Setzt den Spezialisierungshinweis für ein Argument auf den Standardwert zurück. Für Details siehe @nospecialize.

Base.@nospecializeinfer function f(args...)
    @nospecialize ...
    ...
end
Base.@nospecializeinfer f(@nospecialize args...) = ...

Weist dem Compiler an, f unter Verwendung der deklarierten Typen der @nospecialized-Argumente zu inferieren. Dies kann verwendet werden, um die Anzahl der vom Compiler generierten Spezialisierungen während der Inferenz zu begrenzen.

Beispiele

julia> f(A::AbstractArray) = g(A)
f (generische Funktion mit 1 Methode)

julia> @noinline Base.@nospecializeinfer g(@nospecialize(A::AbstractArray)) = A[1]
g (generische Funktion mit 1 Methode)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Any
└──      return %1
) => Any

In diesem Beispiel wird f für jeden spezifischen Typ von A inferiert, aber g wird nur einmal mit dem deklarierten Argumenttyp A::AbstractArray inferiert, was bedeutet, dass der Compiler wahrscheinlich die übermäßige Inferenzzeit dafür nicht sehen wird, während er den konkreten Rückgabetyp davon nicht inferieren kann. Ohne das @nospecializeinfer würde f([1.0]) den Rückgabetyp von g als Float64 inferieren, was darauf hinweist, dass die Inferenz für g(::Vector{Float64}) lief, trotz des Verbots der spezialisierten Codegenerierung.

Base.@constprop Einstellung [ex]

Steuern Sie den Modus der interprozeduralen konstanten Propagation für die annotierte Funktion.

Zwei Einstellungen werden unterstützt:

• Base.@constprop :aggressive [ex]: wendet die konstante Propagation aggressiv an. Für eine Methode, bei der der Rückgabewert vom Wert der Argumente abhängt, kann dies verbesserte Inferenzresultate auf Kosten zusätzlicher Kompilierzeit liefern.
• Base.@constprop :none [ex]: deaktiviert die konstante Propagation. Dies kann die Kompilierzeiten für Funktionen reduzieren, die Julia andernfalls für konstanten Propagation als wertvoll erachten könnte. Häufige Fälle sind Funktionen mit Bool- oder Symbol-wertigen Argumenten oder Schlüsselwortargumenten.

Base.@constprop kann unmittelbar vor einer Funktionsdefinition oder innerhalb eines Funktionskörpers angewendet werden.

# annotiere Langformdefinition
Base.@constprop :aggressive function longdef(x)
    ...
end

# annotiere Kurzformdefinition
Base.@constprop :aggressive shortdef(x) = ...

# annotiere anonyme Funktion, die ein `do`-Block erstellt
f() do
    Base.@constprop :aggressive
    ...
end

gensym([tag])

Generiert ein Symbol, das nicht mit anderen Variablennamen (im selben Modul) in Konflikt steht.

@gensym

Generiert ein gensym-Symbol für eine Variable. Zum Beispiel wird @gensym x y in x = gensym("x"); y = gensym("y") umgewandelt.

var

Die Syntax var"#example#" bezieht sich auf eine Variable mit dem Namen Symbol("#example#"), obwohl #example# kein gültiger Julia-Identifikator ist.

Dies kann nützlich sein für die Interoperabilität mit Programmiersprachen, die unterschiedliche Regeln für die Konstruktion gültiger Identifikatoren haben. Zum Beispiel, um auf die R-Variable draw.segments zu verweisen, können Sie var"draw.segments" in Ihrem Julia-Code verwenden.

Es wird auch verwendet, um den Julia-Quellcode anzuzeigen, der durch Makro-Hygiene gegangen ist oder anderweitig Variablennamen enthält, die nicht normal geparst werden können.

Beachten Sie, dass diese Syntax Parser-Unterstützung erfordert, sodass sie direkt vom Parser erweitert wird, anstatt als normales String-Makro @var_str implementiert zu werden.

@goto name

@goto name springt bedingungslos zu der Anweisung an der Stelle @label name.

@label und @goto können keine Sprünge zu verschiedenen Top-Level-Anweisungen erstellen. Versuche führen zu einem Fehler. Um @goto dennoch zu verwenden, schließe @label und @goto in einen Block ein.

@label name

Kennzeichnet eine Aussage mit dem symbolischen Label name. Das Label markiert den Endpunkt eines bedingungslosen Sprungs mit @goto name.

@simd

Annotieren Sie eine for-Schleife, um dem Compiler zusätzliche Freiheiten zu ermöglichen, um die Schleifenreihenfolge zu ändern.

Das Objekt, über das in einer @simd for-Schleife iteriert wird, sollte ein eindimensionaler Bereich sein. Durch die Verwendung von @simd bestätigen Sie mehrere Eigenschaften der Schleife:

• Es ist sicher, Iterationen in beliebiger oder überlappender Reihenfolge auszuführen, wobei besondere Überlegungen für Reduktionsvariablen angestellt werden.
• Gleitkommaoperationen auf Reduktionsvariablen können umsortiert oder zusammengefasst werden, was möglicherweise andere Ergebnisse als ohne @simd zur Folge hat.

In vielen Fällen kann Julia innere for-Schleifen automatisch vektorisieren, ohne @simd zu verwenden. Die Verwendung von @simd gibt dem Compiler ein wenig zusätzlichen Spielraum, um dies in mehr Situationen zu ermöglichen. In jedem Fall sollte Ihre innere Schleife die folgenden Eigenschaften aufweisen, um die Vektorisierung zu ermöglichen:

• Die Schleife muss eine innerste Schleife sein.
• Der Schleifeninhalt muss aus geradlinigem Code bestehen. Daher ist @inbounds derzeit für alle Array-Zugriffe erforderlich. Der Compiler kann manchmal kurze &&, || und ?:-Ausdrücke in geradlinigen Code umwandeln, wenn es sicher ist, alle Operanden bedingungslos auszuwerten. Ziehen Sie in Betracht, die ifelse-Funktion anstelle von ?: in der Schleife zu verwenden, wenn es sicher ist, dies zu tun.
• Zugriffe müssen ein Sprungmuster haben und dürfen keine "Gathers" (Zugriffe mit zufälligen Indizes) oder "Scatters" (Schreibzugriffe mit zufälligen Indizes) sein.
• Der Sprung sollte ein Einheitssprung sein.

• Es gibt keine speicherabhängigen Abhängigkeiten.
• Keine Iteration wartet jemals auf eine vorherige Iteration, um Fortschritte zu machen.

@polly

Sagt dem Compiler, dass der polyhedrale Optimierer Polly auf eine Funktion angewendet werden soll.

@generated f

@generated wird verwendet, um eine Funktion zu kennzeichnen, die generiert wird. Im Körper der generierten Funktion können nur die Typen der Argumente gelesen werden (nicht die Werte). Die Funktion gibt einen zitierten Ausdruck zurück, der ausgewertet wird, wenn die Funktion aufgerufen wird. Das @generated-Makro sollte nicht auf Funktionen angewendet werden, die den globalen Bereich verändern oder von veränderlichen Elementen abhängen.

Siehe Metaprogramming für weitere Details.

Beispiele

julia> @generated function bar(x)
           if x <: Integer
               return :(x ^ 2)
           else
               return :(x)
           end
       end
bar (generische Funktion mit 1 Methode)

julia> bar(4)
16

julia> bar("baz")
"baz"

Base.@assume_effects Einstellung... [ex]

Überschreiben Sie das Effektmodell des Compilers. Dieses Makro kann in mehreren Kontexten verwendet werden:

1. Unmittelbar vor einer Methodendefinition, um das gesamte Effektmodell der angewendeten Methode zu überschreiben.
2. Innerhalb eines Funktionskörpers ohne Argumente, um das gesamte Effektmodell der umschließenden Methode zu überschreiben.
3. Auf einen Codeblock angewendet, um das lokale Effektmodell des angewendeten Codeblocks zu überschreiben.

Beispiele

julia> Base.@assume_effects :terminates_locally function fact(x)
           # Verwendung 1:
           # dieses :terminates_locally erlaubt es, `fact` konstant zu falten
           res = 1
           0 ≤ x < 20 || error("schlechte fakt")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (generische Funktion mit 1 Methode)

julia> code_typed() do
           fact(12)
       end |> only
CodeInfo(
1 ─     return 479001600
) => Int64

julia> code_typed() do
           map((2,3,4)) do x
               # Verwendung 2:
               # dieses :terminates_locally erlaubt es, diese anonyme Funktion konstant zu falten
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("schlechte fakt")
               while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

julia> code_typed() do
           map((2,3,4)) do x
               res = 1
               0 ≤ x < 20 || error("schlechte fakt")
               # Verwendung 3:
               # mit dieser :terminates_locally Annotation überspringt der Compiler das Tainting
               # des `:terminates` Effekts innerhalb dieses `while` Blocks, was es der übergeordneten
               # anonymen Funktion ermöglicht, konstant gefaltet zu werden
               Base.@assume_effects :terminates_locally while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

Im Allgemeinen macht jeder setting Wert eine Behauptung über das Verhalten der Funktion, ohne dass der Compiler beweisen muss, dass dieses Verhalten tatsächlich wahr ist. Diese Behauptungen gelten für alle Weltalter. Es ist daher ratsam, die Verwendung generischer Funktionen zu begrenzen, die später erweitert werden könnten, um die Annahme zu ungültig zu machen (was zu undefiniertem Verhalten führen würde).

Die folgenden settings werden unterstützt.

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :terminates_locally
• :notaskstate
• :inaccessiblememonly
• :noub
• :noub_if_noinbounds
• :nortcall
• :foldable
• :removable
• :total

Erweiterte Hilfe

:consistent

Die :consistent Einstellung behauptet, dass für gleichwertige (===) Eingaben:

• Die Art der Beendigung (Rückgabewert, Ausnahme, Nichtbeendigung) immer gleich sein wird.
• Wenn die Methode zurückgibt, werden die Ergebnisse immer gleichwertig sein.

:effect_free

Die :effect_free Einstellung behauptet, dass die Methode frei von extern sichtbar semantischen Nebenwirkungen ist. Die folgende Liste ist unvollständig und umfasst extern sichtbar semantische Nebenwirkungen:

• Ändern des Wertes einer globalen Variablen.
• Mutieren des Heaps (z. B. eines Arrays oder veränderlichen Wertes), es sei denn, wie unten angegeben.
• Ändern der Methodentabelle (z. B. durch Aufrufe von eval).
• Datei-/Netzwerk-/usw. I/O.
• Aufgabenwechsel.

Es sind jedoch die folgenden explizit nicht semantisch sichtbar, auch wenn sie beobachtbar sein können:

• Speicherzuweisungen (sowohl veränderlich als auch unveränderlich).
• Verstrichene Zeit.
• Garbage Collection.
• Heap-Mutationen von Objekten, deren Lebensdauer die Methode nicht überschreitet (d. h. die in der Methode zugewiesen wurden und nicht entkommen).
• Der zurückgegebene Wert (der extern sichtbar ist, aber keine Nebenwirkung darstellt).

Die Faustregel hier ist, dass eine extern sichtbare Nebenwirkung alles ist, was die Ausführung des Rests des Programms beeinflussen würde, wenn die Funktion nicht ausgeführt wird.

:nothrow

Die :nothrow Einstellungen behaupten, dass diese Methode keine Ausnahme auslöst (d. h. entweder immer einen Wert zurückgibt oder niemals zurückgibt).

:terminates_globally

Die :terminates_globally Einstellungen behaupten, dass diese Methode schließlich beendet wird (entweder normal oder abnormal), d. h. nicht unendlich schleifen wird.

:terminates_locally

Die :terminates_locally Einstellung ist wie :terminates_globally, außer dass sie nur auf den syntaktischen Kontrollfluss innerhalb der annotierten Methode angewendet wird. Es ist daher eine viel schwächere (und damit sicherere) Behauptung, die die Möglichkeit der Nichtbeendigung zulässt, wenn die Methode eine andere Methode aufruft, die nicht beendet.

:notaskstate

Die :notaskstate Einstellung behauptet, dass die Methode den lokalen Aufgabenstatus (task local storage, RNG-Zustand usw.) nicht verwendet oder ändert und daher sicher zwischen Aufgaben verschoben werden kann, ohne beobachtbare Ergebnisse.

:inaccessiblememonly

Die :inaccessiblememonly Einstellung behauptet, dass die Methode keinen extern zugänglichen veränderlichen Speicher verwendet oder ändert. Das bedeutet, dass die Methode auf veränderlichen Speicher für neu zugewiesene Objekte zugreifen oder diesen ändern kann, der von anderen Methoden oder der obersten Ausführung vor der Rückkehr aus der Methode nicht zugänglich ist, aber sie kann keinen veränderlichen globalen Zustand oder veränderlichen Speicher, auf den durch ihre Argumente verwiesen wird, verwenden oder ändern.

:noub

Die :noub Einstellung behauptet, dass die Methode kein undefiniertes Verhalten ausführen wird (für irgendeine Eingabe). Beachten Sie, dass undefiniertes Verhalten technisch die Methode dazu bringen kann, gegen andere Effektbehauptungen (wie :consistent oder :effect_free) zu verstoßen, aber wir modellieren dies nicht, und sie setzen das Fehlen von undefiniertem Verhalten voraus.

:nortcall

Die :nortcall Einstellung behauptet, dass die Methode Core.Compiler.return_type nicht aufruft und dass auch keine anderen Methoden, die diese Methode aufrufen könnte, Core.Compiler.return_type aufrufen.

:foldable

Diese Einstellung ist eine praktische Abkürzung für die Menge von Effekten, die der Compiler garantieren muss, um einen Aufruf zur Compile-Zeit konstant zu falten. Sie ist derzeit äquivalent zu den folgenden settings:

• :consistent
• :effect_free
• :terminates_globally
• :noub
• :nortcall

:removable

Diese Einstellung ist eine praktische Abkürzung für die Menge von Effekten, die der Compiler garantieren muss, um einen Aufruf, dessen Ergebnis zur Compile-Zeit nicht verwendet wird, zu löschen. Sie ist derzeit äquivalent zu den folgenden settings:

• :effect_free
• :nothrow
• :terminates_globally

:total

Diese setting ist die maximal mögliche Menge von Effekten. Sie impliziert derzeit die folgenden anderen settings:

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :notaskstate
• :inaccessiblememonly
• :noub
• :nortcall

Negierte Effekte

Effektnamen können mit ! vorangestellt werden, um anzuzeigen, dass der Effekt aus einem früheren Metaeffekt entfernt werden sollte. Zum Beispiel bedeutet :total !:nothrow, dass der Aufruf im Allgemeinen total ist, er jedoch möglicherweise eine Ausnahme auslöst.

@deprecate old new [export_old=true]

Veraltet die Methode old und gibt den Ersatzaufruf new an, indem ein neuer Methode old mit der angegebenen Signatur im Prozess definiert wird.

Um zu verhindern, dass old exportiert wird, setzen Sie export_old auf false.

Siehe auch Base.depwarn().

Beispiele

julia> @deprecate old(x) new(x)
old (generische Funktion mit 1 Methode)

julia> @deprecate old(x) new(x) false
old (generische Funktion mit 1 Methode)

Aufrufe von @deprecate ohne explizite Typannotationen definieren veraltete Methoden, die eine beliebige Anzahl von Positions- und Schlüsselwortargumenten vom Typ Any akzeptieren.

Um die Veraltung auf eine bestimmte Signatur zu beschränken, annotieren Sie die Argumente von old. Zum Beispiel,

julia> new(x::Int) = x;

julia> new(x::Float64) = 2x;

julia> @deprecate old(x::Int) new(x);

julia> methods(old)
# 1 Methode für die generische Funktion "old" aus Main:
 [1] old(x::Int64)
     @ deprecated.jl:94

wird eine Methode old(x::Int) definieren und veralten, die new(x::Int) spiegelt, aber die Methode old(x::Float64) weder definiert noch veraltet.

Base.depwarn(msg::String, funcsym::Symbol; force=false)

Drucke msg als eine Abwärtskompatibilitätswarnung. Das Symbol funcsym sollte der Name der aufrufenden Funktion sein, die verwendet wird, um sicherzustellen, dass die Abwärtskompatibilitätswarnung nur beim ersten Mal für jeden Aufrufort gedruckt wird. Setze force=true, um die Warnung immer anzuzeigen, selbst wenn Julia mit --depwarn=no (dem Standard) gestartet wurde.

Siehe auch @deprecate.

Beispiele

function deprecated_func()
    Base.depwarn("Verwende nicht `deprecated_func()`!", :deprecated_func)

    1 + 1
end

Fehlend

Ein Typ ohne Felder, dessen Singleton-Instanz missing verwendet wird, um fehlende Werte darzustellen.

Siehe auch: skipmissing, nonmissingtype, Nothing.

missing

Die Singleton-Instanz des Typs Missing, die einen fehlenden Wert darstellt.

Siehe auch: NaN, skipmissing, nonmissingtype.

coalesce(x...)

Gibt den ersten Wert in den Argumenten zurück, der nicht gleich missing ist, falls vorhanden. Andernfalls wird missing zurückgegeben.

Siehe auch skipmissing, something, @coalesce.

Beispiele

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # gibt `nothing` zurück

julia> coalesce(missing, missing)
missing

@coalesce(x...)

Kurzschlussversion von coalesce.

Beispiele

julia> f(x) = (println("f($x)"); missing);

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` ist immer noch fehlend")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` ist immer noch fehlend")
f(2)
f(3)
ERROR: `b` ist immer noch fehlend
[...]

ismissing(x)

Gibt an, ob x missing ist.

Siehe auch: skipmissing, isnothing, isnan.

skipmissing(itr)

Gibt einen Iterator über die Elemente in itr zurück, der missing Werte überspringt. Das zurückgegebene Objekt kann mit Indizes von itr indiziert werden, wenn letzterer indizierbar ist. Indizes, die entsprechenden fehlenden Werten zugeordnet sind, sind nicht gültig: Sie werden von keys und eachindex übersprungen, und eine MissingException wird ausgelöst, wenn versucht wird, sie zu verwenden.

Verwenden Sie collect, um ein Array zu erhalten, das die nicht-missing Werte in itr enthält. Beachten Sie, dass das Ergebnis immer ein Vector sein wird, selbst wenn itr ein mehrdimensionales Array ist, da es nicht möglich ist, fehlende Werte zu entfernen und gleichzeitig die Dimensionen des Eingangs zu erhalten.

Siehe auch coalesce, ismissing, something.

Beispiele

julia> x = skipmissing([1, missing, 2])
skipmissing(Union{Missing, Int64}[1, missing, 2])

julia> sum(x)
3

julia> x[1]
1

julia> x[2]
ERROR: MissingException: der Wert an Index (2,) ist fehlend
[...]

julia> argmax(x)
3

julia> collect(keys(x))
2-element Vector{Int64}:
 1
 3

julia> collect(skipmissing([1, missing, 2]))
2-element Vector{Int64}:
 1
 2

julia> collect(skipmissing([1 missing; 2 missing]))
2-element Vector{Int64}:
 1
 2

nonmissingtype(T::Type)

Wenn T eine Vereinigung von Typen ist, die Missing enthalten, gibt es einen neuen Typ zurück, bei dem Missing entfernt wurde.

Beispiele

julia> nonmissingtype(Union{Int64,Missing})
Int64

julia> nonmissingtype(Any)
Any

run(command, args...; wait::Bool = true)

Führen Sie ein Befehlsobjekt aus, das mit Backticks erstellt wurde (siehe den Abschnitt Ausführen externer Programme im Handbuch). Wirft einen Fehler, wenn etwas schiefgeht, einschließlich des Prozesses, der mit einem Status ungleich null beendet wird (wenn wait wahr ist).

Die args... ermöglichen es Ihnen, Dateideskriptoren an den Befehl weiterzugeben, und sind wie reguläre Unix-Dateideskriptoren angeordnet (z. B. stdin, stdout, stderr, FD(3), FD(4)...).

Wenn wait falsch ist, läuft der Prozess asynchron. Sie können später darauf warten und seinen Exit-Status überprüfen, indem Sie success auf dem zurückgegebenen Prozessobjekt aufrufen.

Wenn wait falsch ist, werden die I/O-Streams des Prozesses an devnull geleitet. Wenn wait wahr ist, werden die I/O-Streams mit dem übergeordneten Prozess geteilt. Verwenden Sie pipeline, um die I/O-Umleitung zu steuern.

devnull

Wird in einer Stream-Umleitung verwendet, um alle Daten, die in ihn geschrieben werden, zu verwerfen. Entspricht im Wesentlichen /dev/null unter Unix oder NUL unter Windows. Verwendung:

run(pipeline(`cat test.txt`, devnull))

success(command)

Führen Sie ein Befehlsobjekt aus, das mit Backticks erstellt wurde (siehe den Abschnitt Ausführen externer Programme im Handbuch), und geben Sie an, ob es erfolgreich war (mit einem Code von 0 beendet). Eine Ausnahme wird ausgelöst, wenn der Prozess nicht gestartet werden kann.

process_running(p::Process)

Bestimmen Sie, ob ein Prozess derzeit ausgeführt wird.

process_exited(p::Process)

Bestimmen, ob ein Prozess beendet wurde.

kill(p::Process, signum=Base.SIGTERM)

Sendet ein Signal an einen Prozess. Der Standardwert ist, den Prozess zu beenden. Gibt erfolgreich zurück, wenn der Prozess bereits beendet wurde, wirft jedoch einen Fehler, wenn das Beenden des Prozesses aus anderen Gründen fehlgeschlagen ist (z. B. unzureichende Berechtigungen).

Sys.set_process_title(title::AbstractString)

Setzen Sie den Prozessnamen. Keine Operation auf einigen Betriebssystemen.

Sys.get_process_title()

Holen Sie sich den Prozessnamen. In einigen Systemen wird immer eine leere Zeichenfolge zurückgegeben.

ignorestatus(command)

Markiere ein Befehlsobjekt so, dass das Ausführen nicht zu einem Fehler führt, wenn der Ergebniscode ungleich null ist.

detach(command)

Markieren Sie ein Befehlsobjekt, damit es in einer neuen Prozessgruppe ausgeführt wird, wodurch es die Julia-Prozess überdauern kann und keine Ctrl-C-Interrupts an es weitergegeben werden.

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)
Cmd(exec::Vector{String})

Konstruiere ein neues Cmd-Objekt, das ein externes Programm und Argumente aus cmd darstellt, während die Einstellungen der optionalen Schlüsselwortargumente geändert werden:

• ignorestatus::Bool: Wenn true (Standardwert ist false), wird der Cmd keinen Fehler auslösen, wenn der Rückgabecode ungleich null ist.
• detach::Bool: Wenn true (Standardwert ist false), wird der Cmd in einer neuen Prozessgruppe ausgeführt, sodass er länger als der julia-Prozess lebt und kein Ctrl-C an ihn weitergegeben wird.
• windows_verbatim::Bool: Wenn true (Standardwert ist false), sendet der Cmd unter Windows eine Befehlszeilenzeichenfolge an den Prozess, ohne Argumente zu zitieren oder zu escapen, selbst Argumente, die Leerzeichen enthalten. (Unter Windows werden Argumente als eine einzige "Befehlszeilen"-Zeichenfolge an ein Programm gesendet, und Programme sind dafür verantwortlich, sie in Argumente zu parsen. Standardmäßig werden leere Argumente und Argumente mit Leerzeichen oder Tabs in der Befehlszeile mit doppelten Anführungszeichen " zitiert, und \ oder " werden mit Backslashes vorangestellt. windows_verbatim=true ist nützlich, um Programme zu starten, die ihre Befehlszeile auf nicht standardmäßige Weise parsen.) Hat keine Auswirkungen auf Nicht-Windows-Systeme.
• windows_hide::Bool: Wenn true (Standardwert ist false), wird unter Windows kein neues Konsolenfenster angezeigt, wenn der Cmd ausgeführt wird. Dies hat keine Auswirkungen, wenn bereits ein Konsolenfenster geöffnet ist oder auf Nicht-Windows-Systemen.
• env: Setze Umgebungsvariablen, die beim Ausführen des Cmd verwendet werden sollen. env ist entweder ein Wörterbuch, das Strings auf Strings abbildet, ein Array von Strings der Form "var=val", ein Array oder Tupel von "var"=>val-Paaren. Um die bestehende Umgebung zu modifizieren (anstatt sie zu ersetzen), initialisiere env mit copy(ENV) und setze dann env["var"]=val nach Bedarf. Um einem Umgebungsblock innerhalb eines Cmd-Objekts hinzuzufügen, ohne alle Elemente zu ersetzen, verwende addenv(), das ein Cmd-Objekt mit der aktualisierten Umgebung zurückgibt.
• dir::AbstractString: Gib ein Arbeitsverzeichnis für den Befehl an (anstatt des aktuellen Verzeichnisses).

Für alle nicht angegebenen Schlüsselwörter werden die aktuellen Einstellungen von cmd verwendet.

Beachte, dass der Cmd(exec)-Konstruktor keine Kopie von exec erstellt. Alle nachfolgenden Änderungen an exec werden im Cmd-Objekt widergespiegelt.

Die gebräuchlichste Methode zur Konstruktion eines Cmd-Objekts erfolgt mit Befehlsliteralen (Backticks), z. B.

`ls -l`

Dies kann dann an den Cmd-Konstruktor übergeben werden, um seine Einstellungen zu ändern, z. B.

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)

setenv(command::Cmd, env; dir)

Setzen Sie Umgebungsvariablen, die beim Ausführen des angegebenen command verwendet werden sollen. env ist entweder ein Wörterbuch, das Strings auf Strings abbildet, ein Array von Strings der Form "var=val" oder null oder mehr "var"=>val Paarargumente. Um die vorhandene Umgebung zu ändern (anstatt sie zu ersetzen), erstellen Sie env durch copy(ENV) und setzen dann env["var"]=val nach Bedarf oder verwenden Sie addenv.

Das Schlüsselwortargument dir kann verwendet werden, um ein Arbeitsverzeichnis für den Befehl anzugeben. dir hat standardmäßig das aktuell festgelegte dir für command (das das aktuelle Arbeitsverzeichnis ist, wenn nicht bereits angegeben).

Siehe auch Cmd, addenv, ENV, pwd.

addenv(command::Cmd, env...; inherit::Bool = true)

Fügen Sie neue Umgebungszuordnungen in das gegebene Cmd Objekt ein und geben Sie ein neues Cmd Objekt zurück. Doppelte Schlüssel werden ersetzt. Wenn command keine Umgebungswerte enthält, die bereits festgelegt sind, erbt es die aktuelle Umgebung zum Zeitpunkt des addenv() Aufrufs, wenn inherit true ist. Schlüssel mit dem Wert nothing werden aus der Umgebung gelöscht.

Siehe auch Cmd, setenv, ENV.

withenv(f, kv::Pair...)

Führen Sie f in einer Umgebung aus, die vorübergehend modifiziert (nicht ersetzt wie in setenv) wird durch null oder mehr "var"=>val Argumente kv. withenv wird allgemein über die Syntax withenv(kv...) do ... end verwendet. Ein Wert von nothing kann verwendet werden, um eine Umgebungsvariable vorübergehend zu deaktivieren (wenn sie gesetzt ist). Wenn withenv zurückkehrt, wurde die ursprüngliche Umgebung wiederhergestellt.

setcpuaffinity(original_command::Cmd, cpus) -> command::Cmd

Setzen Sie die CPU-Affinität des command durch eine Liste von CPU-IDs (1-basiert) cpus. Das Übergeben von cpus = nothing bedeutet, die CPU-Affinität zurückzusetzen, wenn der original_command eine hat.

Diese Funktion wird nur in Linux und Windows unterstützt. Sie wird in macOS nicht unterstützt, da libuv die Einstellung der Affinität nicht unterstützt.

Beispiele

In Linux kann das Kommandozeilenprogramm taskset verwendet werden, um zu sehen, wie setcpuaffinity funktioniert.

julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13

Beachten Sie, dass der Maskenwert 13 widerspiegelt, dass das erste, zweite und das fünfte Bit (gezählt von der am wenigsten signifikanten Position) eingeschaltet sind:

julia> 0b010011
0x13

pipeline(from, to, ...)

Erstellen Sie eine Pipeline von einer Datenquelle zu einem Ziel. Die Quelle und das Ziel können Befehle, I/O-Streams, Zeichenfolgen oder Ergebnisse anderer pipeline-Aufrufe sein. Mindestens ein Argument muss ein Befehl sein. Zeichenfolgen beziehen sich auf Dateinamen. Wenn mehr als zwei Argumente übergeben werden, werden sie von links nach rechts verkettet. Zum Beispiel ist pipeline(a,b,c) äquivalent zu pipeline(pipeline(a,b),c). Dies bietet eine prägnantere Möglichkeit, mehrstufige Pipelines anzugeben.

Beispiele:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))

pipeline(command; stdin, stdout, stderr, append=false)

Leitet I/O zu oder von dem angegebenen command um. Schlüsselwortargumente geben an, welche der Streams des Befehls umgeleitet werden sollen. append steuert, ob die Dateiausgabe an die Datei angehängt wird. Dies ist eine allgemeinere Version der 2-Argumente pipeline-Funktion. pipeline(from, to) ist äquivalent zu pipeline(from, stdout=to), wenn from ein Befehl ist, und zu pipeline(to, stdin=from), wenn from eine andere Art von Datenquelle ist.

Beispiele:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))

gethostname() -> String

Holen Sie sich den Hostnamen des lokalen Computers.

getpid() -> Int32

Holen Sie sich die Prozess-ID von Julia.

getpid(prozess) -> Int32

Erhalte die Kindprozess-ID, falls sie noch existiert.

time() -> Float64

Holen Sie sich die Systemzeit in Sekunden seit der Epoche, mit ziemlich hoher (typischerweise Mikrosekunden) Auflösung.

time_ns() -> UInt64

Holen Sie sich die Zeit in Nanosekunden. Die Zeit, die 0 entspricht, ist undefiniert und wiederholt sich alle 5,8 Jahre.

@time expr
@time "beschreibung" expr

Ein Makro zur Ausführung eines Ausdrucks, das die Zeit, die zur Ausführung benötigt wurde, die Anzahl der Allokationen und die Gesamtzahl der Bytes, die durch die Ausführung allokiert wurden, ausgibt, bevor der Wert des Ausdrucks zurückgegeben wird. Jegliche Zeit, die mit der Müllsammlung (gc), dem Kompilieren neuer Codes oder dem Re-Kompilieren ungültiger Codes verbracht wurde, wird als Prozentsatz angezeigt. Jegliche Lock-Konflikte, bei denen ein ReentrantLock warten musste, werden als Anzahl angezeigt.

Optional kann eine Beschreibung als String angegeben werden, die vor dem Zeitbericht ausgegeben wird.

In einigen Fällen wird das System innerhalb des @time-Ausdrucks nachsehen und einen Teil des aufgerufenen Codes vor der Ausführung des obersten Ausdrucks kompilieren. Wenn das passiert, wird einige Kompilierungszeit nicht gezählt. Um diese Zeit einzuschließen, können Sie @time @eval ... ausführen.

Siehe auch @showtime, @timev, @timed, @elapsed, @allocated und @allocations.

!!! Hinweis Für ernsthafteres Benchmarking ziehen Sie das @btime-Makro aus dem BenchmarkTools.jl-Paket in Betracht, das unter anderem die Funktion mehrfach auswertet, um Rauschen zu reduzieren.

!!! Kompatibilität "Julia 1.8" Die Option, eine Beschreibung hinzuzufügen, wurde in Julia 1.8 eingeführt.

Die separate Anzeige der Re-Kompilierungszeit von der Kompilierungszeit wurde in Julia 1.8 eingeführt.

!!! Kompatibilität "Julia 1.11" Die Berichterstattung über Lock-Konflikte wurde in Julia 1.11 hinzugefügt.

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 Sekunden (2.19 M Allokationen: 116.555 MiB, 3.75% gc Zeit, 99.94% Kompilierungszeit)

julia> @time x * x;
  0.000009 Sekunden (1 Allokation: 896 Bytes)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 Sekunden (8 Allokationen: 336 Bytes)
2

julia> @time "Ein einsekündiger Schlaf" sleep(1)
Ein einsekündiger Schlaf: 1.005750 Sekunden (5 Allokationen: 144 Bytes)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 Sekunden (5 Allokationen: 144 Bytes)
2: 1.001263 Sekunden (5 Allokationen: 144 Bytes)
3: 1.003676 Sekunden (5 Allokationen: 144 Bytes)

@showtime expr

Wie @time, aber druckt auch den auszuwertenden Ausdruck zur Referenz.

Siehe auch @time.

julia> @showtime sleep(1)
sleep(1): 1.002164 Sekunden (4 Zuweisungen: 128 Bytes)

@timev expr
@timev "beschreibung" expr

Dies ist eine ausführliche Version des @time Makros. Es druckt zuerst die gleichen Informationen wie @time, dann alle nicht-null Speicherzuweisungszähler und gibt dann den Wert des Ausdrucks zurück.

Optional kann eine Beschreibung als Zeichenfolge angegeben werden, die vor dem Zeitbericht ausgegeben wird.

Siehe auch @time, @timed, @elapsed, @allocated und @allocations.

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 Sekunden (2.20 M Zuweisungen: 116.632 MiB, 4.23% gc Zeit, 99.94% Kompilierungszeit)
verstrichene Zeit (ns): 546769547
gc Zeit (ns):          23115606
zugewiesene Bytes:     122297811
Pool-Zuweisungen:      2197930
nicht-Pool GC-Zuweisungen: 1327
malloc() Aufrufe:      36
realloc() Aufrufe:     5
GC Pausen:            3

julia> @timev x * x;
  0.000010 Sekunden (1 Zuweisung: 896 Bytes)
verstrichene Zeit (ns): 9848
zugewiesene Bytes:     896
Pool-Zuweisungen:      1

@timed

Eine Makro, um einen Ausdruck auszuführen und den Wert des Ausdrucks, die verstrichene Zeit in Sekunden, die insgesamt zugewiesenen Bytes, die Zeit der Müllsammlung, ein Objekt mit verschiedenen Zählern für die Speicherzuweisung, die Kompilierungszeit in Sekunden und die Rekompilierungszeit in Sekunden zurückzugeben. Alle Sperrkonflikte, bei denen ein ReentrantLock warten musste, werden als Zähler angezeigt.

In einigen Fällen wird das System innerhalb des @timed-Ausdrucks nachsehen und einen Teil des aufgerufenen Codes vor der Ausführung des obersten Ausdrucks kompilieren. Wenn das passiert, wird einige Kompilierungszeit nicht gezählt. Um diese Zeit einzuschließen, können Sie @timed @eval ... ausführen.

Siehe auch @time, @timev, @elapsed, @allocated, @allocations und @lock_conflicts.

julia> stats = @timed rand(10^6);

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

julia> propertynames(stats.gcstats)
(:allocd, :malloc, :realloc, :poolalloc, :bigalloc, :freecall, :total_time, :pause, :full_sweep)

julia> stats.gcstats.total_time
5576500

julia> stats.compile_time
0.0

julia> stats.recompile_time
0.0

@elapsed

Ein Makro zur Auswertung eines Ausdrucks, wobei der resultierende Wert verworfen wird, stattdessen wird die Anzahl der Sekunden zurückgegeben, die zur Ausführung benötigt wurden, als Fließkommazahl.

In einigen Fällen wird das System innerhalb des @elapsed-Ausdrucks nachsehen und einen Teil des aufgerufenen Codes vor der Ausführung des obersten Ausdrucks kompilieren. Wenn das passiert, wird einige Kompilierungszeit nicht gezählt. Um diese Zeit einzuschließen, können Sie @elapsed @eval ... ausführen.

Siehe auch @time, @timev, @timed, @allocated und @allocations.

julia> @elapsed sleep(0.3)
0.301391426

@allocated

Ein Makro zur Auswertung eines Ausdrucks, das den resultierenden Wert verwirft und stattdessen die Gesamtanzahl der während der Auswertung des Ausdrucks zugewiesenen Bytes zurückgibt.

Siehe auch @allocations, @time, @timev, @timed und @elapsed.

julia> @allocated rand(10^6)
8000080

@allocations

Ein Makro, um einen Ausdruck auszuwerten, den resultierenden Wert zu verwerfen und stattdessen die Gesamtzahl der Allokationen während der Auswertung des Ausdrucks zurückzugeben.

Siehe auch @allocated, @time, @timev, @timed und @elapsed.

julia> @allocations rand(10^6)
2

@lock_conflicts

Ein Makro zur Auswertung eines Ausdrucks, das den resultierenden Wert verwirft und stattdessen die Gesamtzahl der Lock-Konflikte während der Auswertung zurückgibt, wobei ein Lock-Versuch auf einem ReentrantLock zu einem Warten führte, weil der Lock bereits gehalten wurde.

Siehe auch @time, @timev und @timed.

julia> @lock_conflicts begin
    l = ReentrantLock()
    Threads.@threads for i in 1:Threads.nthreads()
        lock(l) do
        sleep(1)
        end
    end
end
5

EnvDict() -> EnvDict

Ein Singleton dieses Typs bietet eine Hash-Tabellen-Schnittstelle zu Umgebungsvariablen.

ENV

Verweis auf das Singleton EnvDict, das eine Dictionary-Schnittstelle zu Systemumgebungsvariablen bereitstellt.

(Unter Windows sind Systemumgebungsvariablen nicht groß-/kleinschreibungssensitiv, und ENV konvertiert entsprechend alle Schlüssel in Großbuchstaben zur Anzeige, Iteration und Kopie. Tragfähiger Code sollte sich nicht auf die Fähigkeit verlassen, Variablen durch Groß- und Kleinschreibung zu unterscheiden, und sollte vorsichtig sein, dass das Setzen einer scheinbar kleingeschriebenen Variablen zu einem Großbuchstaben-ENV-Schlüssel führen kann.)

Beispiele

julia> ENV
Base.EnvDict mit "50" Einträgen:
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "benutzername"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

Siehe auch: withenv, addenv.

Sys.STDLIB::String

Ein String, der den vollständigen Pfad zum Verzeichnis enthält, das die stdlib-Pakete enthält.

Sys.isunix([os])

Prädikat zum Testen, ob das Betriebssystem eine Unix-ähnliche Schnittstelle bereitstellt. Siehe Dokumentation in Handling Operating System Variation.

Sys.isapple([os])

Prädikat zum Testen, ob das Betriebssystem ein Derivat von Apple Macintosh OS X oder Darwin ist. Siehe Dokumentation in Handling Operating System Variation.

Sys.islinux([os])

Prädikat zum Testen, ob das Betriebssystem eine Abwandlung von Linux ist. Siehe Dokumentation in Handling Operating System Variation.

Sys.isbsd([os])

Prädikat zum Testen, ob das Betriebssystem ein Derivat von BSD ist. Siehe Dokumentation in Handling Operating System Variation.

!!! Hinweis Der Darwin-Kernel stammt von BSD ab, was bedeutet, dass Sys.isbsd() auf macOS-Systemen true ist. Um macOS von einem Prädikat auszuschließen, verwenden Sie Sys.isbsd() && !Sys.isapple().

Sys.isfreebsd([os])

Prädikat zum Testen, ob das Betriebssystem ein Derivat von FreeBSD ist. Siehe Dokumentation in Handling Operating System Variation.

!!! Hinweis Nicht zu verwechseln mit Sys.isbsd(), das true auf FreeBSD, aber auch auf anderen BSD-basierten Systemen ist. Sys.isfreebsd() bezieht sich nur auf FreeBSD.

!!! Kompatibilität "Julia 1.1" Diese Funktion erfordert mindestens Julia 1.1.

Sys.isopenbsd([os])

Prädikat zum Testen, ob das Betriebssystem ein Derivat von OpenBSD ist. Siehe Dokumentation in Handling Operating System Variation.

Sys.isnetbsd([os])

Prädikat zum Testen, ob das Betriebssystem ein Derivat von NetBSD ist. Siehe Dokumentation in Handling Operating System Variation.

!!! Hinweis Nicht zu verwechseln mit Sys.isbsd(), das auf NetBSD, aber auch auf anderen BSD-basierten Systemen true ist. Sys.isnetbsd() bezieht sich nur auf NetBSD.

!!! Kompatibilität "Julia 1.1" Diese Funktion erfordert mindestens Julia 1.1.

Sys.isdragonfly([os])

Prädikat zum Testen, ob das Betriebssystem eine Abspaltung von DragonFly BSD ist. Siehe Dokumentation in Handling Operating System Variation.

!!! Hinweis Nicht zu verwechseln mit Sys.isbsd(), das true auf DragonFly, aber auch auf anderen BSD-basierten Systemen ist. Sys.isdragonfly() bezieht sich nur auf DragonFly.

Sys.iswindows([os])

Prädikat zum Testen, ob das Betriebssystem eine Abwandlung von Microsoft Windows NT ist. Siehe Dokumentation in Handling Operating System Variation.

Sys.windows_version()

Gibt die Versionsnummer des Windows NT-Kernels als VersionNumber zurück, d.h. v"major.minor.build", oder v"0.0.0", wenn dies nicht unter Windows ausgeführt wird.

Sys.free_memory()

Holen Sie sich den gesamten freien Speicher im RAM in Bytes.

Sys.total_memory()

Holen Sie den gesamten Speicher im RAM (einschließlich des derzeit verwendeten) in Bytes. Dieser Betrag kann eingeschränkt sein, z. B. durch Linux-Control-Gruppen. Für den uneingeschränkten Betrag siehe Sys.total_physical_memory().

Sys.free_physical_memory()

Holen Sie sich den freien Speicher des Systems in Bytes. Der gesamte Betrag ist möglicherweise nicht für den aktuellen Prozess verfügbar; verwenden Sie Sys.free_memory(), um den tatsächlich verfügbaren Betrag zu erhalten.

Sys.total_physical_memory()

Holen Sie den gesamten Speicher im RAM (einschließlich des aktuell verwendeten) in Bytes. Der gesamte Betrag steht möglicherweise nicht dem aktuellen Prozess zur Verfügung; siehe Sys.total_memory().

Sys.uptime()

Erhält die aktuelle Systemlaufzeit in Sekunden.

Sys.isjsvm([os])

Prädikat zum Testen, ob Julia in einer JavaScript-VM (JSVM) läuft, einschließlich z.B. einer WebAssembly-JavaScript-Einbettung in einem Webbrowser.

Sys.loadavg()

Holen Sie sich den Lastdurchschnitt. Siehe: https://en.wikipedia.org/wiki/Load_(computing).

isexecutable(path::String)

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

Siehe auch ispath, isreadable, iswritable.

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

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

Sys.username() -> String

Gibt den Benutzernamen des aktuellen Benutzers zurück. Wenn der Benutzername nicht bestimmt werden kann oder leer ist, wirft diese Funktion einen Fehler.

Um einen Benutzernamen abzurufen, der über eine Umgebungsvariable überschreibbar ist, z. B. USER, sollten Sie Folgendes verwenden:

user = get(Sys.username, ENV, "USER")

Siehe auch homedir.

@static

Teile eine Ausdruck zur Parse-Zeit aus.

Zum Beispiel wird @static Sys.iswindows() ? foo : bar Sys.iswindows() auswerten und entweder foo oder bar in den Ausdruck einfügen. Dies ist nützlich in Fällen, in denen eine Konstruktion auf anderen Plattformen ungültig wäre, wie ein ccall zu einer nicht existierenden Funktion. @static if Sys.isapple() foo end und @static foo <&&,||> bar sind ebenfalls gültige Syntax.

VersionNumber

Versionsnummerntyp, der den Spezifikationen von semantischer Versionierung (semver) folgt, bestehend aus Haupt-, Neben- und Patch-Zahlen, gefolgt von Vorab- und Build-alphanumerischen Anmerkungen.

VersionNumber-Objekte können mit allen Standardvergleichsoperatoren (==, <, <= usw.) verglichen werden, wobei das Ergebnis den semver-Regeln folgt.

VersionNumber hat die folgenden öffentlichen Felder:

• v.major::Integer
• v.minor::Integer
• v.patch::Integer
• v.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}
• v.build::Tuple{Vararg{Union{Integer, AbstractString}}}

Siehe auch @v_str, um VersionNumber-Objekte effizient aus semver-formatierten Literalzeichenfolgen zu erstellen, VERSION für die VersionNumber von Julia selbst und Versionsnummern-Literale im Handbuch.

Beispiele

julia> a = VersionNumber(1, 2, 3)
v"1.2.3"

julia> a >= v"1.2"
true

julia> b = VersionNumber("2.0.1-rc1")
v"2.0.1-rc1"

julia> b >= v"2.0.1"
false

@v_str

String-Makro, die verwendet wird, um einen String in eine VersionNumber zu parsen.

Beispiele

julia> v"1.2.3"
v"1.2.3"

julia> v"2.0.1-rc1"
v"2.0.1-rc1"

error(message::AbstractString)

Löst eine ErrorException mit der angegebenen Nachricht aus.

error(msg...)

Löst eine ErrorException mit einer Nachricht aus, die durch string(msg...) erstellt wird.

throw(e)

Wirf ein Objekt als Ausnahme.

Siehe auch: rethrow, error.

rethrow()

Wirft die aktuelle Ausnahme innerhalb eines catch-Blocks erneut. Die erneut geworfene Ausnahme wird weiterhin propagiert, als ob sie nicht abgefangen worden wäre.

!!! Hinweis Die alternative Form rethrow(e) ermöglicht es Ihnen, ein alternatives Ausnahmeobjekt e mit dem aktuellen Backtrace zu verknüpfen. Dies stellt jedoch den Programmzustand zum Zeitpunkt des Fehlers falsch dar, weshalb Sie stattdessen ermutigt werden, eine neue Ausnahme mit throw(e) zu werfen. In Julia 1.1 und höher wird durch die Verwendung von throw(e) die ursprüngliche Ausnahmeursache im Stack beibehalten, wie in current_exceptions beschrieben.

backtrace()

Holen Sie sich ein Backtrace-Objekt für den aktuellen Programm-Punkt.

catch_backtrace()

Holen Sie sich den Backtrace der aktuellen Ausnahme zur Verwendung innerhalb von catch-Blöcken.

current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

Holen Sie den Stapel der derzeit behandelten Ausnahmen ab. Bei geschachtelten Catch-Blöcken kann es mehr als eine aktuelle Ausnahme geben, wobei die zuletzt geworfene Ausnahme zuletzt im Stapel steht. Der Stapel wird als ExceptionStack zurückgegeben, das ein AbstractVector von benannten Tupeln (exception,backtrace) ist. Wenn backtrace falsch ist, wird der Backtrace in jedem Paar auf nothing gesetzt.

Das explizite Übergeben von task gibt den aktuellen Ausnahme-Stapel für eine beliebige Aufgabe zurück. Dies ist nützlich, um Aufgaben zu inspizieren, die aufgrund von nicht behandelten Ausnahmen fehlgeschlagen sind.

@assert cond [text]

Wirft einen AssertionError, wenn cond false ist. Dies ist die bevorzugte Syntax zum Schreiben von Assertions, die Bedingungen sind, von denen angenommen wird, dass sie wahr sind, die der Benutzer jedoch trotzdem überprüfen könnte, um beim Debuggen zu helfen, falls sie fehlschlagen. Die optionale Nachricht text wird bei einem Assertion-Fehler angezeigt.

Beispiele

julia> @assert iseven(3) "3 ist eine ungerade Zahl!"
ERROR: AssertionError: 3 ist eine ungerade Zahl!

julia> @assert isodd(3) "Was sind gerade Zahlen?"

Experimental.register_error_hint(handler, exceptiontype)

Registrieren Sie eine "Hinweis"-Funktion handler(io, exception), die potenzielle Möglichkeiten vorschlagen kann, wie Benutzer Fehler umgehen können. handler sollte exception untersuchen, um festzustellen, ob die Bedingungen für einen Hinweis erfüllt sind, und falls ja, Ausgaben an io generieren. Pakete sollten register_error_hint innerhalb ihrer __init__-Funktion aufrufen.

Für spezifische Ausnahmetypen ist es erforderlich, dass handler zusätzliche Argumente akzeptiert:

• MethodError: Stellen Sie handler(io, exc::MethodError, argtypes, kwargs) bereit, das die kombinierten Argumente in Positions- und Schlüsselwortargumente aufteilt.

Beim Ausgeben eines Hinweises sollte die Ausgabe typischerweise mit \n beginnen.

Wenn Sie benutzerdefinierte Ausnahmetypen definieren, kann Ihre showerror-Methode Hinweise unterstützen, indem sie Experimental.show_error_hints aufruft.

Beispiele

julia> module Hinter

       only_int(x::Int)      = 1
       any_number(x::Number) = 2

       function __init__()
           Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
               if exc.f == only_int
                    # Farbe ist nicht notwendig, dies dient nur dazu, zu zeigen, dass es möglich ist.
                    print(io, "\nMeinten Sie, ")
                    printstyled(io, "`any_number` zu rufen?", color=:cyan)
               end
           end
       end

       end

Wenn Sie dann Hinter.only_int mit etwas aufrufen, das kein Int ist (und damit einen MethodError auslöst), gibt es den Hinweis aus:

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
Die Funktion `only_int` existiert, aber keine Methode ist für diese Kombination von Argumenttypen definiert.
Meinten Sie, `any_number` zu rufen?
Nächste Kandidaten sind:
    ...

Experimental.show_error_hints(io, ex, args...)

Ruft alle Handler von Experimental.register_error_hint für den bestimmten Ausnahmetyp typeof(ex) auf. args muss alle anderen Argumente enthalten, die vom Handler für diesen Typ erwartet werden.

ArgumentError(msg)

Die übergebenen Argumente an eine Funktion sind ungültig. msg ist eine beschreibende Fehlermeldung.

AssertionError([msg])

Die behauptete Bedingung wurde nicht als true ausgewertet. Das optionale Argument msg ist eine beschreibende Fehlermeldung.

Beispiele

julia> @assert false "this is not true"
ERROR: AssertionError: this is not true

AssertionError wird normalerweise von @assert ausgelöst.

BoundsError([a],[i])

Ein Indexierungsoperation in ein Array, a, versuchte, auf ein Element außerhalb der Grenzen am Index i zuzugreifen.

Beispiele

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: Versuch, auf 7-element Vector{Float64} am Index [8] zuzugreifen


julia> B = fill(1.0, (2,3));

julia> B[2, 4]
ERROR: BoundsError: Versuch, auf 2×3 Matrix{Float64} am Index [2, 4] zuzugreifen


julia> B[9]
ERROR: BoundsError: Versuch, auf 2×3 Matrix{Float64} am Index [9] zuzugreifen

CompositeException

Wickeln Sie einen Vector von Ausnahmen, die von einer Task ausgelöst wurden (z. B. generiert von einem Remote-Arbeiter über einen Kanal oder einem asynchron ausgeführten lokalen I/O-Schreibvorgang oder einem Remote-Arbeiter unter pmap), mit Informationen über die Reihe von Ausnahmen. Wenn beispielsweise eine Gruppe von Arbeitern mehrere Aufgaben ausführt und mehrere Arbeiter fehlschlagen, enthält die resultierende CompositeException ein "Bündel" von Informationen von jedem Arbeiter, das angibt, wo und warum die Ausnahme(n) aufgetreten sind.

DimensionMismatch([msg])

Die aufgerufenen Objekte haben keine übereinstimmende Dimensionalität. Das optionale Argument msg ist eine beschreibende Fehlermeldung.

DivideError()

Es wurde eine ganzzahlige Division mit einem Nennerwert von 0 versucht.

Beispiele

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: ganzzahlige Division Fehler
Stacktrace:
[...]

DomainError(val)
DomainError(val, msg)

Das Argument val für eine Funktion oder einen Konstruktor liegt außerhalb des gültigen Bereichs.

Beispiele

julia> sqrt(-1)
ERROR: DomainError mit -1.0:
sqrt wurde mit einem negativen reellen Argument aufgerufen, gibt jedoch nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuchen Sie sqrt(Complex(x)).
Stacktrace:
[...]

EOFError()

Es waren keine weiteren Daten zum Lesen aus einer Datei oder einem Stream verfügbar.

ErrorException(msg)

Generischer Fehlertyp. Die Fehlermeldung im Feld .msg kann spezifischere Details liefern.

Beispiele

julia> ex = ErrorException("Ich habe etwas Schlechtes getan");

julia> ex.msg
"Ich habe etwas Schlechtes getan"

InexactError(name::Symbol, T, val)

Kann val nicht genau in den Typ T in einer Methode der Funktion name umwandeln.

Beispiele

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]

InterruptException()

Der Prozess wurde durch ein Terminal-Interrupt (CTRL+C) gestoppt.

Beachten Sie, dass in einem Julia-Skript, das ohne die Option -i (interaktiv) gestartet wurde, InterruptException standardmäßig nicht ausgelöst wird. Das Aufrufen von Base.exit_on_sigint(false) im Skript kann das Verhalten der REPL wiederherstellen. Alternativ kann ein Julia-Skript mit

julia -e "include(popfirst!(ARGS))" script.jl

gestart werden, um zuzulassen, dass InterruptException während der Ausführung durch CTRL+C ausgelöst wird.

KeyError(key)

Eine Indexierungsoperation in ein AbstractDict (Dict) oder Set ähnliches Objekt hat versucht, auf ein nicht vorhandenes Element zuzugreifen oder es zu löschen.

LoadError(file::AbstractString, line::Int, error)

Ein Fehler ist aufgetreten beim include, require oder using einer Datei. Die Einzelheiten des Fehlers sollten im Feld .error verfügbar sein.

MethodError(f, args)

Eine Methode mit der erforderlichen Typsignatur existiert nicht in der gegebenen generischen Funktion. Alternativ gibt es keine eindeutige spezifischste Methode.

MissingException(msg)

Ausnahme, die ausgelöst wird, wenn ein missing Wert in einer Situation auftritt, in der er nicht unterstützt wird. Die Fehlermeldung im Feld msg kann spezifischere Details liefern.

OutOfMemoryError()

Eine Operation hat zu viel Speicher für das System oder den Garbage Collector zugewiesen, um ihn ordnungsgemäß zu verarbeiten.

ReadOnlyMemoryError()

Eine Operation hat versucht, in den Speicher zu schreiben, der schreibgeschützt ist.

OverflowError(msg)

Das Ergebnis eines Ausdrucks ist zu groß für den angegebenen Typ und führt zu einem Überlauf.

ProcessFailedException

Zeigt den problematischen Exit-Status eines Prozesses an. Beim Ausführen von Befehlen oder Pipelines wird dies ausgelöst, um anzuzeigen, dass ein nicht null Exit-Code zurückgegeben wurde (d.h. dass der aufgerufene Prozess fehlgeschlagen ist).

TaskFailedException

Diese Ausnahme wird von einem wait(t) Aufruf ausgelöst, wenn die Aufgabe t fehlschlägt. TaskFailedException umschließt die fehlgeschlagene Aufgabe t.

StackOverflowError()

Der Funktionsaufruf wuchs über die Größe des Aufrufstapels hinaus. Dies geschieht normalerweise, wenn ein Aufruf unendlich rekursiv ist.

SystemError(prefix::AbstractString, [errno::Int32])

Ein Systemaufruf ist mit einem Fehlercode fehlgeschlagen (im globalen errno-Variablen).

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

Ein Typassertionsfehler oder das Aufrufen einer intrinsischen Funktion mit einem falschen Argumenttyp.

UndefKeywordError(var::Symbol)

Das erforderliche Schlüsselwortargument var wurde bei einem Funktionsaufruf nicht zugewiesen.

Beispiele

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generische Funktion mit 1 Methode)

julia> my_func()
FEHLER: UndefKeywordError: Schlüsselwortargument `my_arg` nicht zugewiesen
Stacktrace:
 [1] my_func() bei ./REPL[1]:2
 [2] oberste Ebene bei REPL[2]:1

UndefRefError()

Das Element oder Feld ist für das gegebene Objekt nicht definiert.

Beispiele

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: Zugriff auf undefinierten Verweis
Stacktrace:
[...]

UndefVarError(var::Symbol, [scope])

Ein Symbol im aktuellen Gültigkeitsbereich ist nicht definiert.

Beispiele

julia> a
ERROR: UndefVarError: `a` nicht definiert in `Main`

julia> a = 1;

julia> a
1

StringIndexError(str, i)

Ein Fehler ist aufgetreten, als versucht wurde, auf str an einem ungültigen Index i zuzugreifen.

InitError(mod::Symbol, error)

Ein Fehler ist aufgetreten, als die __init__-Funktion eines Moduls ausgeführt wurde. Der tatsächliche Fehler, der ausgelöst wurde, ist im Feld .error verfügbar.

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Funktion

Gibt eine anonyme Funktion zurück, die die Funktion f aufruft. Wenn eine Ausnahme auftritt, wird f wiederholt aufgerufen, jedes Mal, wenn check true zurückgibt, nachdem die Anzahl der Sekunden gewartet wurde, die in delays angegeben sind. check sollte den aktuellen Zustand von delays und die Exception eingeben.

Beispiele

retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, IOError))(io, 128; all=false)

ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)

Ein Float64 Iterator der Länge n, dessen Elemente exponentiell mit einer Rate im Intervall factor * (1 ± jitter) zunehmen. Das erste Element ist first_delay und alle Elemente sind auf max_delay begrenzt.