Interactive Utilities

apropos([io::IO=stdout], pattern::Union{AbstractString,Regex})

Durchsuchen Sie die verfügbaren Dokumentationszeichenfolgen nach Einträgen, die pattern enthalten.

Wenn pattern eine Zeichenfolge ist, wird die Groß- und Kleinschreibung ignoriert. Die Ergebnisse werden an io ausgegeben.

apropos kann im Hilfemodus im REPL aufgerufen werden, indem die Abfrage in doppelte Anführungszeichen gesetzt wird:

help?> "pattern"

varinfo(m::Module=Main, pattern::Regex=r""; all=false, imported=false, recursive=false, sortby::Symbol=:name, minsize::Int=0)

Geben Sie eine Markdown-Tabelle zurück, die Informationen über öffentliche globale Variablen in einem Modul bereitstellt, optional beschränkt auf diejenigen, die mit pattern übereinstimmen.

Die Schätzung des Speicherverbrauchs ist eine ungefähre Untergrenze für die Größe der internen Struktur des Objekts.

• all : listet auch nicht-öffentliche Objekte auf, die im Modul definiert sind, veraltete Objekte und vom Compiler generierte Objekte.
• imported : listet auch Objekte auf, die explizit aus anderen Modulen importiert wurden.
• recursive : schließt rekursiv Objekte in Untermodulen ein und beachtet dabei die gleichen Einstellungen in jedem.
• sortby : die Spalte, nach der die Ergebnisse sortiert werden sollen. Optionen sind :name (Standard), :size und :summary.
• minsize : schließt nur Objekte mit einer Größe von mindestens minsize Bytes ein. Standardmäßig 0.

Die Ausgabe von varinfo ist nur für Anzeigezwecke gedacht. Siehe auch names, um ein Array von Symbolen zu erhalten, die in einem Modul definiert sind und für allgemeinere Manipulationen geeignet sind.

versioninfo(io::IO=stdout; verbose::Bool=false)

Gibt Informationen über die verwendete Version von Julia aus. Die Ausgabe wird mit booleschen Schlüsselwortargumenten gesteuert:

• verbose: alle zusätzlichen Informationen ausgeben

Siehe auch: VERSION.

methodswith(typ[, Modul oder Funktion]; Supertypen::Bool=false])

Gibt ein Array von Methoden mit einem Argument des Typs typ zurück.

Das optionale zweite Argument beschränkt die Suche auf ein bestimmtes Modul oder eine bestimmte Funktion (der Standardwert sind alle obersten Module).

Wenn das Schlüsselwort Supertypen auf true gesetzt ist, werden auch Argumente mit einem übergeordneten Typ von typ zurückgegeben, wobei der Typ Any ausgeschlossen ist.

Siehe auch: methods.

subtypen(T::DataType)

Gibt eine Liste der unmittelbaren Subtypen des DataType T zurück. Beachten Sie, dass alle derzeit geladenen Subtypen enthalten sind, einschließlich derjenigen, die im aktuellen Modul nicht sichtbar sind.

Siehe auch supertype, supertypes, methodswith.

Beispiele

julia> subtypen(Integer)
3-element Vector{Any}:
 Bool
 Signed
 Unsigned

supertypes(T::Type)

Gibt ein Tupel (T, ..., Any) von T und all seinen Supertypen zurück, wie durch aufeinanderfolgende Aufrufe der supertype Funktion bestimmt, aufgelistet in der Reihenfolge von <: und beendet mit Any.

Siehe auch subtypes.

Beispiele

julia> supertypes(Int)
(Int64, Signed, Integer, Real, Number, Any)

edit(path::AbstractString, line::Integer=0, column::Integer=0)

Bearbeiten Sie eine Datei oder ein Verzeichnis und geben Sie optional eine Zeilennummer an, um die Datei an dieser Stelle zu bearbeiten. Kehren Sie zum julia-Prompt zurück, wenn Sie den Editor verlassen. Der Editor kann geändert werden, indem JULIA_EDITOR, VISUAL oder EDITOR als Umgebungsvariable festgelegt wird.

Siehe auch InteractiveUtils.define_editor.

edit(function, [types])
edit(module)

Bearbeiten Sie die Definition einer Funktion und geben Sie optional ein Tupel von Typen an, um anzugeben, welche Methode bearbeitet werden soll. Für Module öffnen Sie die Hauptquelldatei. Das Modul muss zuerst mit using oder import geladen werden.

Um sicherzustellen, dass die Datei an der angegebenen Zeile geöffnet werden kann, müssen Sie möglicherweise zuerst InteractiveUtils.define_editor aufrufen.

@edit

Bewertet die Argumente des Funktions- oder Makroaufrufs, bestimmt deren Typen und ruft die edit Funktion auf dem resultierenden Ausdruck auf.

Siehe auch: @less, @which.

define_editor(fn, pattern; wait=false)

Definiere einen neuen Editor, der dem pattern entspricht und verwendet werden kann, um eine Datei (möglicherweise an einer bestimmten Zeilennummer) mit fn zu öffnen.

Das Argument fn ist eine Funktion, die bestimmt, wie eine Datei mit dem gegebenen Editor geöffnet werden soll. Es sollte vier Argumente annehmen, wie folgt:

• cmd - ein Basisbefehl-Objekt für den Editor
• path - der Pfad zur zu öffnenden Quelldatei
• line - die Zeilennummer, an der der Editor geöffnet werden soll
• column - die Spaltennummer, an der der Editor geöffnet werden soll

Editoren, die nicht zu einer bestimmten Zeile mit einem Befehl oder einer bestimmten Spalte öffnen können, dürfen das Argument line und/oder column ignorieren. Der fn-Callback muss entweder ein passendes Cmd-Objekt zurückgeben, um eine Datei zu öffnen, oder nothing, um anzuzeigen, dass sie diese Datei nicht bearbeiten können. Verwende nothing, um anzuzeigen, dass dieser Editor für die aktuelle Umgebung nicht geeignet ist und ein anderer Editor versucht werden sollte. Es ist möglich, allgemeinere Bearbeitungs-Hooks hinzuzufügen, die keine externen Befehle auslösen müssen, indem ein Callback direkt in den Vektor EDITOR_CALLBACKS eingefügt wird.

Das Argument pattern ist eine Zeichenkette, ein regulärer Ausdruck oder ein Array von Zeichenfolgen und regulären Ausdrücken. Damit fn aufgerufen wird, muss eines der Muster mit dem Wert von EDITOR, VISUAL oder JULIA_EDITOR übereinstimmen. Bei Zeichenfolgen muss die Zeichenfolge dem basename des ersten Wortes des Editorbefehls entsprechen, wobei die Erweiterung, falls vorhanden, entfernt wird. Zum Beispiel passt "vi" nicht zu "vim -g", aber zu "/usr/bin/vi -m"; es passt auch zu vi.exe. Wenn pattern ein Regex ist, wird es gegen den gesamten Editorbefehl als shell-escaped Zeichenfolge abgeglichen. Ein Array-Muster passt, wenn eines seiner Elemente übereinstimmt. Wenn mehrere Editoren übereinstimmen, wird der zuletzt hinzugefügte verwendet.

Standardmäßig wartet Julia nicht darauf, dass der Editor schließt, und führt ihn im Hintergrund aus. Wenn der Editor jedoch terminalbasiert ist, möchtest du wahrscheinlich wait=true setzen, und Julia wartet darauf, dass der Editor schließt, bevor es fortfährt.

Wenn eine der Editor-Umgebungsvariablen gesetzt ist, aber kein Editor-Eintrag übereinstimmt, wird der Standard-Editor-Eintrag aufgerufen:

(cmd, path, line, column) -> `$cmd $path`

Beachte, dass viele Editoren bereits definiert sind. Alle folgenden Befehle sollten bereits funktionieren:

• emacs
• emacsclient
• vim
• nvim
• nano
• micro
• kak
• helix
• textmate
• mate
• kate
• subl
• atom
• notepad++
• Visual Studio Code
• open
• pycharm
• bbedit

Beispiele

Das folgende definiert die Verwendung von terminalbasiertem emacs:

define_editor(
    r"\bemacs\b.*\s(-nw|--no-window-system)\b", wait=true) do cmd, path, line
    `$cmd +$line $path`
end

less(file::AbstractString, [line::Integer])

Zeigt eine Datei mit dem Standard-Pager an, wobei optional eine Startzeilennummer angegeben werden kann. Kehren Sie zum julia-Prompt zurück, wenn Sie den Pager beenden.

less(function, [types])

Zeigt die Definition einer Funktion mit dem Standard-Pager an, wobei optional ein Tupel von Typen angegeben werden kann, um anzugeben, welche Methode angezeigt werden soll.

@less

Bewertet die Argumente des Funktions- oder Makroaufrufs, bestimmt deren Typen und ruft die less Funktion auf dem resultierenden Ausdruck auf.

Siehe auch: @edit, @which, @code_lowered.

@which

Angewendet auf einen Funktions- oder Makroaufruf bewertet es die Argumente des angegebenen Aufrufs und gibt das Method-Objekt für die Methode zurück, die für diese Argumente aufgerufen werden würde. Wird es auf eine Variable angewendet, gibt es das Modul zurück, in dem die Variable gebunden wurde. Es ruft die which-Funktion auf.

Siehe auch: @less, @edit.

@functionloc

Angewendet auf einen Funktions- oder Makroaufruf, bewertet es die Argumente des angegebenen Aufrufs und gibt ein Tupel (dateiname,zeile) zurück, das den Standort der Methode angibt, die für diese Argumente aufgerufen werden würde. Es ruft die functionloc Funktion auf.

@code_lowered

Bewertet die Argumente des Funktions- oder Makroaufrufs, bestimmt deren Typen und ruft code_lowered auf dem resultierenden Ausdruck auf.

Siehe auch: code_lowered, @code_warntype, @code_typed, @code_llvm, @code_native.

@code_typed

Bewertet die Argumente des Funktions- oder Makroaufrufs, bestimmt deren Typen und ruft code_typed auf dem resultierenden Ausdruck auf. Verwenden Sie das optionale Argument optimize mit

@code_typed optimize=true foo(x)

um zu steuern, ob zusätzliche Optimierungen, wie Inlining, ebenfalls angewendet werden.

Siehe auch: code_typed, @code_warntype, @code_lowered, @code_llvm, @code_native.

code_warntype([io::IO], f, types; debuginfo=:default)

Gibt die gesenkten und typ-inferierten ASTs für die Methoden aus, die der gegebenen generischen Funktion und dem Typsignatur zu io entsprechen, das standardmäßig auf stdout gesetzt ist. Die ASTs sind so annotiert, dass "nicht-blatt" Typen, die problematisch für die Leistung sein könnten, hervorgehoben werden (wenn Farbe verfügbar ist, in rot angezeigt). Dies dient als Warnung vor potenzieller Typinstabilität.

Nicht alle nicht-blatt Typen sind besonders problematisch für die Leistung, und die Leistungsmerkmale eines bestimmten Typs sind ein Implementierungsdetail des Compilers. code_warntype wird dazu neigen, Typen rot zu färben, wenn sie ein Leistungsproblem darstellen könnten, sodass einige Typen rot gefärbt sein können, auch wenn sie die Leistung nicht beeinträchtigen. Kleine Vereinigungen konkreter Typen sind normalerweise kein Problem, daher werden diese in gelb hervorgehoben.

Das Schlüsselwort-Argument debuginfo kann entweder :source oder :none (Standard) sein, um die Ausführlichkeit der Code-Kommentare anzugeben.

Siehe den Abschnitt @code_warntype auf der Seite mit den Leistungstipps im Handbuch für weitere Informationen.

Siehe auch: @code_warntype, code_typed, code_lowered, code_llvm, code_native.

@code_warntype

Bewertet die Argumente des Funktions- oder Makroaufrufs, bestimmt deren Typen und ruft code_warntype auf dem resultierenden Ausdruck auf.

Siehe auch: code_warntype, @code_typed, @code_lowered, @code_llvm, @code_native.

code_llvm([io=stdout,], f, types; raw=false, dump_module=false, optimize=true, debuginfo=:default)

Gibt die LLVM-Bitcodes aus, die für die Ausführung der Methode generiert wurden, die der gegebenen generischen Funktion und dem Typsignatur entspricht, an io.

Wenn das Schlüsselwort optimize nicht gesetzt ist, wird der Code vor den LLVM-Optimierungen angezeigt. Alle Metadaten und dbg.*-Aufrufe werden aus dem gedruckten Bitcode entfernt. Für das vollständige IR setzen Sie das Schlüsselwort raw auf true. Um das gesamte Modul, das die Funktion kapselt (mit Deklarationen), auszugeben, setzen Sie das Schlüsselwort dump_module auf true. Das Schlüsselwort debuginfo kann entweder source (Standard) oder none sein, um die Ausführlichkeit der Codekommentare anzugeben.

Siehe auch: @code_llvm, code_warntype, code_typed, code_lowered, code_native.

@code_llvm

Bewertet die Argumente des Funktions- oder Makroaufrufs, bestimmt deren Typen und ruft code_llvm auf dem resultierenden Ausdruck auf. Setzen Sie die optionalen Schlüsselwortargumente raw, dump_module, debuginfo, optimize, indem Sie sie und ihren Wert vor dem Funktionsaufruf angeben, wie folgt:

@code_llvm raw=true dump_module=true debuginfo=:default f(x)
@code_llvm optimize=false f(x)

optimize steuert, ob zusätzliche Optimierungen, wie Inlining, ebenfalls angewendet werden. raw macht alle Metadaten und dbg.*-Aufrufe sichtbar. debuginfo kann entweder :source (Standard) oder :none sein, um die Ausführlichkeit der Codekommentare anzugeben. dump_module druckt das gesamte Modul, das die Funktion kapselt.

Siehe auch: code_llvm, @code_warntype, @code_typed, @code_lowered, @code_native.

code_native([io=stdout,], f, types; syntax=:intel, debuginfo=:default, binary=false, dump_module=true)

Gibt die nativen Assemblieranweisungen aus, die für die Ausführung der Methode generiert werden, die der angegebenen generischen Funktion und dem Typsignatur entspricht, an io.

• Setzen Sie die Assemblersyntax, indem Sie syntax auf :intel (Standard) für die Intel-Syntax oder :att für die AT&T-Syntax setzen.
• Geben Sie die Ausführlichkeit der Codekommentare an, indem Sie debuginfo auf :source (Standard) oder :none setzen.
• Wenn binary auf true gesetzt ist, drucken Sie auch den binären Maschinencode für jede Anweisung, die von einer abgekürzten Adresse vorangestellt wird.
• Wenn dump_module auf false gesetzt ist, drucken Sie keine Metadaten wie rodata oder Direktiven.
• Wenn raw auf false gesetzt ist, werden uninteressante Anweisungen (wie das Prolog der Safepoint-Funktion) weggelassen.

Siehe auch: @code_native, code_warntype, code_typed, code_lowered, code_llvm.

@code_native

Bewertet die Argumente des Funktions- oder Makroaufrufs, bestimmt deren Typen und ruft code_native auf dem resultierenden Ausdruck auf.

Setzen Sie beliebige optionale Schlüsselwortargumente syntax, debuginfo, binary oder dump_module, indem Sie sie vor dem Funktionsaufruf angeben, wie folgt:

@code_native syntax=:intel debuginfo=:default binary=true dump_module=false f(x)

• Setzen Sie die Assemblersyntax, indem Sie syntax auf :intel (Standard) für Intel-Syntax oder :att für AT&T-Syntax setzen.
• Geben Sie die Ausführlichkeit der Codekommentare an, indem Sie debuginfo auf :source (Standard) oder :none setzen.
• Wenn binary true ist, drucken Sie auch den binären Maschinencode für jede Anweisung, die von einer abgekürzten Adresse vorangestellt wird.
• Wenn dump_module false ist, drucken Sie keine Metadaten wie rodata oder Direktiven.

Siehe auch: code_native, @code_warntype, @code_typed, @code_lowered, @code_llvm.

@time_imports

Ein Makro, um einen Ausdruck auszuführen und einen Bericht über die gesamte Zeit zu erstellen, die für das Importieren von Paketen und deren Abhängigkeiten aufgewendet wurde. Jegliche Kompilierungszeit wird als Prozentsatz angegeben, sowie wie viel davon eine Rekompilierung war, falls vorhanden.

Pro Paket oder Paket-Erweiterung wird eine Zeile ausgegeben. Die angezeigte Dauer ist die Zeit, die benötigt wird, um dieses Paket selbst zu importieren, ohne die Zeit für das Laden seiner Abhängigkeiten einzubeziehen.

In Julia 1.9+ werden Paket-Erweiterungen als Parent → Extension angezeigt.

!!! Hinweis Während des Ladeprozesses importiert ein Paket nacheinander alle seine Abhängigkeiten, nicht nur seine direkten Abhängigkeiten.

julia> @time_imports using CSV
     50.7 ms  Parsers 17.52% Kompilierungszeit
      0.2 ms  DataValueInterfaces
      1.6 ms  DataAPI
      0.1 ms  IteratorInterfaceExtensions
      0.1 ms  TableTraits
     17.5 ms  Tables
     26.8 ms  PooledArrays
    193.7 ms  SentinelArrays 75.12% Kompilierungszeit
      8.6 ms  InlineStrings
     20.3 ms  WeakRefStrings
      2.0 ms  TranscodingStreams
      1.4 ms  Zlib_jll
      1.8 ms  CodecZlib
      0.8 ms  Compat
     13.1 ms  FilePathsBase 28.39% Kompilierungszeit
   1681.2 ms  CSV 92.40% Kompilierungszeit

clipboard(x)

Sendet eine gedruckte Form von x an die Zwischenablage des Betriebssystems ("kopieren").

clipboard() -> String

Gibt einen String mit dem Inhalt der Zwischenablage des Betriebssystems zurück ("einfügen").