Essentials

exit(code=0)

Arrêtez le programme avec un code de sortie. Le code de sortie par défaut est zéro, indiquant que le programme s'est terminé avec succès. Dans une session interactive, exit() peut être appelé avec le raccourci clavier ^D.

atexit(f)

Enregistre une fonction f() à zéro ou un argument qui sera appelée à la sortie du processus. Les hooks atexit() sont appelés dans l'ordre dernier entré, premier sorti (LIFO) et s'exécutent avant les finaliseurs d'objet.

Si f a une méthode définie pour un argument entier, elle sera appelée comme f(n::Int32), où n est le code de sortie actuel, sinon elle sera appelée comme f().

Les hooks de sortie sont autorisés à appeler exit(n), auquel cas Julia sortira avec le code de sortie n (au lieu du code de sortie original). Si plus d'un hook de sortie appelle exit(n), alors Julia sortira avec le code de sortie correspondant au dernier hook de sortie appelé qui appelle exit(n). (Parce que les hooks de sortie sont appelés dans l'ordre LIFO, "dernier appelé" est équivalent à "premier enregistré".)

Remarque : Une fois que tous les hooks de sortie ont été appelés, aucun autre hook de sortie ne peut être enregistré, et tout appel à atexit(f) après que tous les hooks ont été complétés lancera une exception. Cette situation peut se produire si vous enregistrez des hooks de sortie à partir de Tâches en arrière-plan qui peuvent encore s'exécuter de manière concurrente pendant l'arrêt.

isinteractive() -> Bool

Déterminez si Julia s'exécute dans une session interactive.

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

Calcule la quantité de mémoire, en octets, utilisée par tous les objets uniques accessibles à partir de l'argument.

Arguments Clés

• exclude : spécifie les types d'objets à exclure de la traversée.
• chargeall : spécifie les types d'objets pour lesquels il faut toujours prendre en compte la taille de tous leurs champs, même si ces champs seraient normalement exclus.

Voir aussi sizeof.

Exemples

julia> Base.summarysize(1.0)
8

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

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

__precompile__(isprecompilable::Bool)

Spécifiez si le fichier appelant cette fonction est précompilable, par défaut true. Si un module ou un fichier n'est pas sûr de pouvoir être précompilé, il doit appeler __precompile__(false) afin de générer une erreur si Julia tente de le précompiler.

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

Évalue le contenu du fichier source d'entrée dans le scope global du module m. Chaque module (sauf ceux définis avec baremodule) a sa propre définition de include omettant l'argument m, qui évalue le fichier dans ce module. Renvoie le résultat de la dernière expression évaluée du fichier d'entrée. Lors de l'inclusion, un chemin d'inclusion local à la tâche est défini sur le répertoire contenant le fichier. Les appels imbriqués à include rechercheront par rapport à ce chemin. Cette fonction est généralement utilisée pour charger le code source de manière interactive, ou pour combiner des fichiers dans des packages qui sont divisés en plusieurs fichiers source.

L'argument optionnel mapexpr peut être utilisé pour transformer le code inclus avant qu'il ne soit évalué : pour chaque expression analysée expr dans path, la fonction include évalue en réalité mapexpr(expr). Si elle est omise, mapexpr par défaut à identity.

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

Évalue le contenu du fichier source d'entrée dans le scope global du module contenant. Chaque module (sauf ceux définis avec baremodule) a sa propre définition de include, qui évalue le fichier dans ce module. Renvoie le résultat de la dernière expression évaluée du fichier d'entrée. Lors de l'inclusion, un chemin d'inclusion local à la tâche est défini sur le répertoire contenant le fichier. Les appels imbriqués à include rechercheront par rapport à ce chemin. Cette fonction est généralement utilisée pour charger du code source de manière interactive, ou pour combiner des fichiers dans des packages qui sont divisés en plusieurs fichiers source. L'argument path est normalisé à l'aide de normpath qui résoudra les tokens de chemin relatifs tels que .. et convertira / en le séparateur de chemin approprié.

L'argument optionnel mapexpr peut être utilisé pour transformer le code inclus avant qu'il ne soit évalué : pour chaque expression analysée expr dans path, la fonction include évalue en réalité mapexpr(expr). S'il est omis, mapexpr par défaut à identity.

Utilisez Base.include pour évaluer un fichier dans un autre module.

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

Comme include, sauf qu'il lit le code à partir de la chaîne donnée plutôt qu'à partir d'un fichier.

L'argument optionnel mapexpr peut être utilisé pour transformer le code inclus avant qu'il ne soit évalué : pour chaque expression analysée expr dans code, la fonction include_string évalue en réalité mapexpr(expr). S'il est omis, mapexpr par défaut à identity.

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

Dans un module, déclarez que le fichier, le répertoire ou le lien symbolique spécifié par path (relatif ou absolu) est une dépendance pour la précompilation ; c'est-à-dire que si track_content=true, le module devra être recompilé si le contenu de path change (si path est un répertoire, le contenu équivaut à join(readdir(path))). Si track_content=false, la recompilation est déclenchée lorsque le temps de modification mtime de path change.

Cela n'est nécessaire que si votre module dépend d'un chemin qui n'est pas utilisé via include. Cela n'a aucun effet en dehors de la compilation.

__init__

La fonction __init__() dans un module s'exécute immédiatement après que le module soit chargé à l'exécution pour la première fois. Elle est appelée une fois, après que toutes les autres instructions dans le module ont été exécutées. Comme elle est appelée après l'importation complète du module, les fonctions __init__ des sous-modules seront exécutées en premier. Deux utilisations typiques de __init__ sont l'appel de fonctions d'initialisation à l'exécution de bibliothèques C externes et l'initialisation de constantes globales qui impliquent des pointeurs retournés par des bibliothèques externes. Voir la section du manuel sur les modules pour plus de détails.

Exemples

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

which(f, types)

Renvoie la méthode de f (un objet Method) qui serait appelée pour des arguments des types donnés.

Si types est un type abstrait, alors la méthode qui serait appelée par invoke est renvoyée.

Voir aussi : parentmodule, @which, et @edit.

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

Retourne la table des méthodes pour f.

Si types est spécifié, retourne un tableau de méthodes dont les types correspondent. Si module est spécifié, retourne un tableau de méthodes définies dans ce module. Une liste de modules peut également être spécifiée sous forme de tableau.

Voir aussi : which, @which et methodswith.

@show exs...

Affiche une ou plusieurs expressions, ainsi que leurs résultats, sur stdout, et renvoie le dernier résultat.

Voir aussi : show, @info, println.

Exemples

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

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

ans

Une variable faisant référence à la dernière valeur calculée, importée automatiquement dans l'invite interactive.

err

Une variable faisant référence aux dernières erreurs levées, automatiquement importée dans l'invite interactive. Les erreurs levées sont collectées dans une pile d'exceptions.

active_project()

Renvoie le chemin du fichier Project.toml actif. Voir aussi Base.set_active_project.

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

Définissez le fichier Project.toml actif sur projfile. Voir aussi Base.active_project.

module

module déclare un Module, qui est un espace de travail de variables globales séparé. Dans un module, vous pouvez contrôler quels noms d'autres modules sont visibles (via l'importation) et spécifier lesquels de vos noms sont destinés à être publics (via export et public). Les modules vous permettent de créer des définitions de niveau supérieur sans vous soucier des conflits de noms lorsque votre code est utilisé avec celui de quelqu'un d'autre. Voir la section du manuel sur les modules pour plus de détails.

Exemples

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 est utilisé dans les modules pour indiquer à Julia quels noms doivent être rendus disponibles à l'utilisateur. Par exemple : export foo rend le nom foo disponible lors de l'utilisation du module avec using. Consultez la section du manuel sur les modules pour plus de détails.

public

public est utilisé dans les modules pour indiquer à Julia quels noms font partie de l'API publique du module. Par exemple : public foo indique que le nom foo est public, sans le rendre disponible lors de using du module. Voir la section du manuel sur les modules pour plus de détails.

import

import Foo chargera le module ou le paquet Foo. Les noms du module Foo importé peuvent être accédés avec la syntaxe par point (par exemple, Foo.foo pour accéder au nom foo). Voir la section du manuel sur les modules pour plus de détails.

using

using Foo chargera le module ou le paquet Foo et rendra ses noms exportés disponibles pour une utilisation directe. Les noms peuvent également être utilisés via la syntaxe par point (par exemple Foo.foo pour accéder au nom foo), qu'ils soient exportés ou non. Voir la section du manuel sur les modules pour plus de détails.

as

as est utilisé comme un mot-clé pour renommer un identifiant introduit dans le scope par import ou using, dans le but de contourner les conflits de noms ainsi que pour raccourcir les noms. (En dehors des déclarations import ou using, as n'est pas un mot-clé et peut être utilisé comme un identifiant ordinaire.)

import LinearAlgebra as LA amène la bibliothèque standard LinearAlgebra importée dans le scope sous le nom LA.

import LinearAlgebra: eigen as eig, cholesky as chol amène les méthodes eigen et cholesky de LinearAlgebra dans le scope sous les noms eig et chol respectivement.

as fonctionne avec using uniquement lorsque des identifiants individuels sont introduits dans le scope. Par exemple, using LinearAlgebra: eigen as eig ou using LinearAlgebra: eigen as eig, cholesky as chol fonctionne, mais using LinearAlgebra as LA est une syntaxe invalide, car il est insensé de renommer tous les noms exportés de LinearAlgebra en LA.

baremodule

baremodule déclare un module qui ne contient pas using Base ou des définitions locales de eval et include. Il importe néanmoins Core. En d'autres termes,

module Mod

...

end

est équivalent à

baremodule Mod

using Base

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

...

end

fonction

Les fonctions sont définies avec le mot-clé function :

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

Ou la notation courte :

add(a, b) = a + b

L'utilisation du mot-clé return est exactement la même que dans d'autres langages, mais est souvent optionnelle. Une fonction sans une instruction return explicite renverra la dernière expression dans le corps de la fonction.

macro

macro définit une méthode pour insérer du code généré dans un programme. Un macro associe une séquence d'expressions d'arguments à une expression retournée, et l'expression résultante est substituée directement dans le programme au point où le macro est invoqué. Les macros sont un moyen d'exécuter du code généré sans appeler eval, puisque le code généré devient simplement une partie du programme environnant. Les arguments des macros peuvent inclure des expressions, des valeurs littérales et des symboles. Les macros peuvent être définies pour un nombre variable d'arguments (varargs), mais n'acceptent pas d'arguments de mot-clé. Chaque macro reçoit également implicitement les arguments __source__, qui contient le numéro de ligne et le nom de fichier d'où le macro est appelé, et __module__, qui est le module dans lequel le macro est développé.

Voir la section du manuel sur Metaprogramming pour plus d'informations sur la façon d'écrire un macro.

Exemples

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 fait sortir la fonction englobante plus tôt, en renvoyant la valeur donnée x à son appelant. return tout seul sans valeur est équivalent à return nothing (voir nothing).

function compare(a, b)
    a == b && return "égal à"
    a < b ? "moins que" : "plus que"
end

En général, vous pouvez placer une instruction return n'importe où dans le corps d'une fonction, y compris dans des boucles ou des conditionnelles profondément imbriquées, mais faites attention avec les blocs do. Par exemple :

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

Dans le premier exemple, le retour sort de test1 dès qu'il rencontre un nombre pair, donc test1([5,6,7]) renvoie 12.

Vous pourriez vous attendre à ce que le deuxième exemple se comporte de la même manière, mais en fait le return là ne sort que de la fonction interne (à l'intérieur du bloc do) et renvoie une valeur à map. test2([5,6,7]) renvoie alors [5,12,7].

Lorsqu'il est utilisé dans une expression de niveau supérieur (c'est-à-dire en dehors de toute fonction), return fait que l'ensemble de l'expression de niveau supérieur actuelle se termine plus tôt.

do

Créez une fonction anonyme et passez-la comme premier argument à un appel de fonction. Par exemple :

map(1:10) do x
    2x
end

est équivalent à map(x->2x, 1:10).

Utilisez plusieurs arguments comme ceci :

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

begin

begin...end désigne un bloc de code.

begin
    println("Hello, ")
    println("World!")
end

En général, begin ne sera pas nécessaire, car des mots-clés tels que function et let commencent implicitement des blocs de code. Voir aussi ;.

begin peut également être utilisé lors de l'indexation pour représenter le premier index d'une collection ou le premier index d'une dimension d'un tableau. Par exemple, a[begin] est le premier élément d'un tableau a.

Exemples

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

fin

fin marque la conclusion d'un bloc d'expressions, par exemple module, struct, mutable struct, begin, let, for etc.

fin peut également être utilisé lors de l'indexation pour représenter le dernier index d'une collection ou le dernier index d'une dimension d'un tableau.

Exemples

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

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

let

Les blocs let créent un nouveau scope strict et introduisent éventuellement de nouvelles liaisons locales.

Tout comme les autres constructions de scope, les blocs let définissent le bloc de code où les nouvelles variables locales introduites sont accessibles. De plus, la syntaxe a une signification spéciale pour les affectations séparées par des virgules et les noms de variables qui peuvent éventuellement apparaître sur la même ligne que le let :

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

Les variables introduites sur cette ligne sont locales au bloc let et les affectations sont évaluées dans l'ordre, chaque côté droit étant évalué dans le scope sans tenir compte du nom à gauche. Il est donc logique d'écrire quelque chose comme let x = x, puisque les deux variables x sont distinctes avec le côté gauche masquant localement le x du scope extérieur. Cela peut même être un idiome utile car de nouvelles variables locales sont fraîchement créées chaque fois que des scopes locaux sont entrés, mais cela n'est observable que dans le cas de variables qui survivent à leur scope via des fermetures. Une variable let sans affectation, comme var2 dans l'exemple ci-dessus, déclare une nouvelle variable locale qui n'est pas encore liée à une valeur.

En revanche, les blocs begin regroupent également plusieurs expressions ensemble mais n'introduisent pas de scope ni n'ont la syntaxe d'affectation spéciale.

Exemples

Dans la fonction ci-dessous, il y a un seul x qui est mis à jour de manière itérative trois fois par le map. Les fermetures retournées font toutes référence à ce x à sa valeur finale :

julia> function test_outer_x()
           x = 0
           map(1:3) do _
               x += 1
               return ()->x
           end
       end
test_outer_x (generic function with 1 method)

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

Cependant, si nous ajoutons un bloc let qui introduit une nouvelle variable locale, nous nous retrouverons avec trois variables distinctes capturées (une à chaque itération) même si nous avons choisi d'utiliser (masquer) le même nom.

julia> function test_let_x()
           x = 0
           map(1:3) do _
               x += 1
               let x = x
                   return ()->x
               end
           end
       end
test_let_x (generic function with 1 method)

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

Toutes les constructions de scope qui introduisent de nouvelles variables locales se comportent de cette manière lorsqu'elles sont exécutées plusieurs fois ; la caractéristique distinctive de let est sa capacité à déclarer succinctement de nouveaux locals qui peuvent masquer des variables extérieures du même nom. Par exemple, utiliser directement l'argument de la fonction do capture également trois variables distinctes :

julia> function test_do_x()
           map(1:3) do x
               return ()->x
           end
       end
test_do_x (generic function with 1 method)

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

if/elseif/else

if/elseif/else effectue une évaluation conditionnelle, ce qui permet à des portions de code d'être évaluées ou non en fonction de la valeur d'une expression booléenne. Voici l'anatomie de la syntaxe conditionnelle if/elseif/else :

if x < y
    println("x est inférieur à y")
elseif x > y
    println("x est supérieur à y")
else
    println("x est égal à y")
end

Si l'expression conditionnelle x < y est vraie, alors le bloc correspondant est évalué ; sinon, l'expression conditionnelle x > y est évaluée, et si elle est vraie, le bloc correspondant est évalué ; si aucune des deux expressions n'est vraie, le bloc else est évalué. Les blocs elseif et else sont optionnels, et autant de blocs elseif que désiré peuvent être utilisés.

Contrairement à certains autres langages, les conditions doivent être de type Bool. Il ne suffit pas que les conditions soient convertibles en Bool.

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

pour

pour les boucles évaluent à plusieurs reprises un bloc d'instructions tout en itérant sur une séquence de valeurs.

La variable d'itération est toujours une nouvelle variable, même si une variable du même nom existe dans la portée englobante. Utilisez outer pour réutiliser une variable locale existante pour l'itération.

Exemples

julia> pour i dans [1, 4, 0]
           println(i)
       fin
1
4
0

while

Les boucles while évaluent de manière répétée une expression conditionnelle et continuent d'évaluer le corps de la boucle while tant que l'expression reste vraie. Si l'expression conditionnelle est fausse lorsque la boucle while est atteinte pour la première fois, le corps n'est jamais évalué.

Exemples

julia> i = 1
1

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

break

Sortir immédiatement d'une boucle.

Exemples

julia> i = 0
0

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

continue

Sauter le reste de l'itération actuelle de la boucle.

Exemples

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

try/catch

Une instruction try/catch permet d'intercepter les erreurs (exceptions) lancées par throw afin que l'exécution du programme puisse se poursuivre. Par exemple, le code suivant tente d'écrire un fichier, mais avertit l'utilisateur et continue au lieu de terminer l'exécution si le fichier ne peut pas être écrit :

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "Could not write file."
end

ou, lorsque le fichier ne peut pas être lu dans une variable :

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "File not found."
end

La syntaxe catch e (où e est n'importe quelle variable) assigne l'objet d'exception lancé à la variable donnée dans le bloc catch.

La puissance de la construction try/catch réside dans la capacité de défaire immédiatement un calcul profondément imbriqué à un niveau beaucoup plus élevé dans la pile des fonctions appelantes.

finalement

Exécutez du code lorsqu'un bloc de code donné se termine, peu importe comment il se termine. Par exemple, voici comment nous pouvons garantir qu'un fichier ouvert est fermé :

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

Lorsque le contrôle quitte le bloc try (par exemple, en raison d'un return, ou simplement en se terminant normalement), close(f) sera exécuté. Si le bloc try se termine en raison d'une exception, l'exception continuera à se propager. Un bloc catch peut également être combiné avec try et finally. Dans ce cas, le bloc finally s'exécutera après que catch ait géré l'erreur.

quote

quote crée plusieurs objets d'expression dans un bloc sans utiliser le constructeur explicite Expr. Par exemple :

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

Contrairement aux autres moyens de citation, :( ... ), cette forme introduit des éléments QuoteNode dans l'arbre d'expression, qui doivent être pris en compte lors de la manipulation directe de l'arbre. Pour d'autres usages, :( ... ) et les blocs quote .. end sont traités de manière identique.

local

local introduit une nouvelle variable locale. Voir la section du manuel sur la portée des variables pour plus d'informations.

Exemples

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # introduire un x local à la boucle
               x = i
           end
           x
       end
foo (generic function with 1 method)

julia> foo(10)
0

global

global x fait en sorte que x dans la portée actuelle et ses portées intérieures se réfère à la variable globale de ce nom. Voir la section du manuel sur la portée des variables pour plus d'informations.

Exemples

julia> z = 3
3

julia> function foo()
           global z = 6 # utilise la variable z définie en dehors de foo
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6

pour outer

Réutilisez une variable locale existante pour l'itération dans une boucle for.

Voir la section du manuel sur la portée des variables pour plus d'informations.

Voir aussi for.

Exemples

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

julia> f()
0

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

julia> f()
3

julia> i = 0 # variable globale
       for outer i = 1:3
       end
ERREUR: syntaxe : aucune déclaration de variable locale externe n'existe pour "for outer"
[...]

const

const est utilisé pour déclarer des variables globales dont les valeurs ne changeront pas. Dans presque tout le code (et en particulier dans le code sensible à la performance), les variables globales doivent être déclarées constantes de cette manière.

const x = 5

Plusieurs variables peuvent être déclarées dans un seul const :

const y, z = 7, 11

Notez que const ne s'applique qu'à une seule opération = ; par conséquent, const x = y = 1 déclare x comme constant mais pas y. En revanche, const x = const y = 1 déclare à la fois x et y constants.

Notez que la "constance" ne s'étend pas aux conteneurs mutables ; seule l'association entre une variable et sa valeur est constante. Si x est un tableau ou un dictionnaire (par exemple), vous pouvez toujours modifier, ajouter ou supprimer des éléments.

Dans certains cas, changer la valeur d'une variable const donne un avertissement au lieu d'une erreur. Cependant, cela peut produire un comportement imprévisible ou corrompre l'état de votre programme, et donc cela doit être évité. Cette fonctionnalité est destinée uniquement à la commodité lors de l'utilisation interactive.

struct

Le type le plus couramment utilisé en Julia est un struct, spécifié par un nom et un ensemble de champs.

struct Point
    x
    y
end

Les champs peuvent avoir des restrictions de type, qui peuvent être paramétrées :

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

Un struct peut également déclarer un super type abstrait via la syntaxe <: :

struct Point <: AbstractPoint
    x
    y
end

Les structs sont immuables par défaut ; une instance de l'un de ces types ne peut pas être modifiée après sa construction. Utilisez mutable struct à la place pour déclarer un type dont les instances peuvent être modifiées.

Voir la section du manuel sur Composite Types pour plus de détails, comme la façon de définir des constructeurs.

mutable struct

mutable struct est similaire à struct, mais permet en plus de modifier les champs du type après sa construction.

Les champs individuels d'un mutable struct peuvent être marqués comme const pour les rendre immuables :

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

Consultez la section du manuel sur Composite Types pour plus d'informations.

@kwdef typedef

Ceci est une macro d'aide qui définit automatiquement un constructeur basé sur des mots-clés pour le type déclaré dans l'expression typedef, qui doit être une expression struct ou mutable struct. L'argument par défaut est fourni en déclarant des champs sous la forme field::T = default ou field = default. Si aucun défaut n'est fourni, alors l'argument de mot-clé devient un argument de mot-clé requis dans le constructeur de type résultant.

Des constructeurs internes peuvent toujours être définis, mais au moins un doit accepter des arguments sous la même forme que le constructeur interne par défaut (c'est-à-dire un argument positionnel par champ) afin de fonctionner correctement avec le constructeur externe basé sur des mots-clés.

Exemples

julia> @kwdef struct Foo
           a::Int = 1         # défaut spécifié
           b::String          # mot-clé requis
       end
Foo

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

julia> Foo()
ERROR: UndefKeywordError: argument de mot-clé `b` non assigné
Stacktrace:
[...]

type abstrait

type abstrait déclare un type qui ne peut pas être instancié et sert uniquement de nœud dans le graphe des types, décrivant ainsi des ensembles de types concrets liés : ces types concrets qui en sont les descendants. Les types abstraits forment la hiérarchie conceptuelle qui rend le système de types de Julia plus qu'une simple collection d'implémentations d'objets. Par exemple :

type abstrait Nombre fin
type abstrait Réel <: Nombre fin

Nombre n'a pas de supertype, tandis que Réel est un sous-type abstrait de Nombre.

type primitif

type primitif déclare un type concret dont les données consistent uniquement en une série de bits. Des exemples classiques de types primitifs sont les entiers et les valeurs à virgule flottante. Voici quelques déclarations de types primitifs intégrés en exemple :

type primitif Char 32 fin
type primitif Bool <: Integer 8 fin

Le nombre après le nom indique combien de bits de stockage le type nécessite. Actuellement, seules les tailles qui sont des multiples de 8 bits sont prises en charge. La déclaration Bool montre comment un type primitif peut être déclaré en option comme un sous-type d'un supertype.

où

Le mot-clé où crée un type UnionAll, qui peut être considéré comme une union itérée d'autres types, sur toutes les valeurs d'une certaine variable. Par exemple, Vector{T} où T<:Real inclut tous les Vectors où le type d'élément est une sorte de nombre Real.

La liaison de variable par défaut est Any si elle est omise :

Vector{T} où T    # abréviation pour `où T<:Any`

Les variables peuvent également avoir des bornes inférieures :

Vector{T} où T>:Int
Vector{T} où Int<:T<:Real

Il existe également une syntaxe concise pour les expressions où imbriquées. Par exemple, ceci :

Pair{T, S} où S<:Array{T} où T<:Number

peut être abrégé en :

Pair{T, S} où {T<:Number, S<:Array{T}}

Cette forme se trouve souvent dans les signatures de méthode.

Notez que dans cette forme, les variables sont listées dans l'ordre extérieur d'abord. Cela correspond à l'ordre dans lequel les variables sont substituées lorsque un type est "appliqué" à des valeurs de paramètres en utilisant la syntaxe T{p1, p2, ...}.

L'opérateur "splat", `...`, représente une séquence d'arguments. `...` peut être utilisé dans les définitions de fonction, pour indiquer que la fonction accepte un nombre arbitraire d'arguments. `...` peut également être utilisé pour appliquer une fonction à une séquence d'arguments.

# Exemples

jldoctest julia> add(xs...) = reduce(+, xs) add (generic function with 1 method)

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

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

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

;

; a un rôle similaire en Julia comme dans de nombreux langages de type C, et est utilisé pour délimiter la fin de l'instruction précédente.

; n'est pas nécessaire à la fin d'une ligne, mais peut être utilisé pour séparer des instructions sur une seule ligne ou pour joindre des instructions en une seule expression.

Ajouter ; à la fin d'une ligne dans le REPL supprimera l'impression du résultat de cette expression.

Dans les déclarations de fonction, et optionnellement dans les appels, ; sépare les arguments réguliers des mots-clés.

Dans les littéraux de tableau, les arguments séparés par des points-virgules ont leur contenu concaténé ensemble. Un séparateur composé d'un seul ; concatène verticalement (c'est-à-dire le long de la première dimension), ;; concatène horizontalement (deuxième dimension), ;;; concatène le long de la troisième dimension, etc. Un tel séparateur peut également être utilisé en dernière position dans les crochets pour ajouter des dimensions supplémentaires de longueur 1.

Un ; en première position à l'intérieur de parenthèses peut être utilisé pour construire un tuple nommé. La même syntaxe (; ...) sur le côté gauche d'une affectation permet de déstructurer des propriétés.

Dans le REPL standard, taper ; sur une ligne vide passera en mode shell.

Exemples

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) # sans le ; ou une virgule finale, cela assignerait à x
(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; # définir les variables b et x en utilisant la déstructuration de propriété

julia> b, x
(2, 1)

julia> ; # en tapant ;, l'invite change (sur place) en : shell>
shell> echo hello
hello

=

= est l'opérateur d'assignation.

• Pour la variable a et l'expression b, a = b fait que a fait référence à la valeur de b.
• Pour les fonctions f(x), f(x) = x définit une nouvelle constante de fonction f, ou ajoute une nouvelle méthode à f si f est déjà défini ; cette utilisation est équivalente à function f(x); x; end.
• a[i] = v appelle setindex!(a,v,i).
• a.b = c appelle setproperty!(a,:b,c).
• À l'intérieur d'un appel de fonction, f(a=b) passe b comme la valeur de l'argument clé a.
• À l'intérieur de parenthèses avec des virgules, (a=1,) construit un NamedTuple.

Exemples

L'assignation de a à b ne crée pas une copie de b ; utilisez plutôt copy ou 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

Les collections passées aux fonctions ne sont également pas copiées. Les fonctions peuvent modifier (muter) le contenu des objets auxquels leurs arguments font référence. (Les noms des fonctions qui font cela sont conventionnellement suffixés par '!'.)

julia> function f!(x); x[:] .+= 1; end
f! (generic function with 1 method)

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

L'assignation peut fonctionner sur plusieurs variables en parallèle, prenant des valeurs d'un itérable :

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

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

julia> a, b
(1, 2)

L'assignation peut fonctionner sur plusieurs variables en série, et renverra la valeur de l'expression la plus à droite :

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

L'assignation à des indices hors limites ne fait pas croître une collection. Si la collection est un Vector, elle peut plutôt être agrandie avec push! ou append!.

julia> a = [1, 1]; a[3] = 2
ERROR: BoundsError: attempt to access 2-element Array{Int64, 1} at index [3]
[...]

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

L'assignation de [] n'élimine pas les éléments d'une collection ; utilisez plutôt filter!.

julia> a = collect(1:3); a[a .<= 1] = []
ERROR: DimensionMismatch: tried to assign 0 elements to 1 destinations
[...]

julia> filter!(x -> x > 1, a) # in-place & thus more efficient than a = a[a .> 1]
2-element Array{Int64, 1}:
 2
 3

a ? b : c

Forme courte pour les conditionnels ; se lit "si a, évaluer b sinon évaluer c". Également connu sous le nom de opérateur ternaire.

Cette syntaxe est équivalente à if a; b else c end, mais est souvent utilisée pour mettre en avant la valeur b-ou-c qui est utilisée comme partie d'une expression plus grande, plutôt que les effets secondaires que l'évaluation de b ou c peut avoir.

Voir la section du manuel sur flux de contrôle pour plus de détails.

Exemples

julia> x = 1; y = 2;

julia> x > y ? println("x est plus grand") : println("x n'est pas plus grand")
x n'est pas plus grand

julia> x > y ? "x est plus grand" : x == y ? "x et y sont égaux" : "y est plus grand"
"y est plus grand"

Principal

Principal est le module de niveau supérieur, et Julia commence avec Principal défini comme le module courant. Les variables définies à l'invite vont dans Principal, et varinfo liste les variables dans Principal.

julia> @__MODULE__
Principal

Noyau

Noyau est le module qui contient tous les identifiants considérés comme "intégrés" au langage, c'est-à-dire faisant partie du langage de base et non des bibliothèques. Chaque module spécifie implicitement using Noyau, car vous ne pouvez rien faire sans ces définitions.

Base

La bibliothèque de base de Julia. Base est un module qui contient des fonctionnalités de base (le contenu de base/). Tous les modules contiennent implicitement using Base, car cela est nécessaire dans la grande majorité des cas.

Base.Broadcast

Module contenant l'implémentation de la diffusion.

Docs

Le module Docs fournit la macro @doc qui peut être utilisée pour définir et récupérer des métadonnées de documentation pour les objets Julia.

Veuillez consulter la section du manuel sur documentation pour plus d'informations.

Méthodes pour travailler avec les Itérateurs.

Interface à libc, la bibliothèque standard C.

Fonctions de commodité pour la métaprogrammation.

Outils pour collecter et manipuler les traces de pile. Principalement utilisés pour construire des erreurs.

Fournir des méthodes pour récupérer des informations sur le matériel et le système d'exploitation.

Support de multithreading.

Base.GC

Module avec des utilitaires de collecte des déchets.

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

Déterminez si x et y sont identiques, dans le sens où aucun programme ne pourrait les distinguer. D'abord, les types de x et y sont comparés. Si ceux-ci sont identiques, les objets mutables sont comparés par adresse en mémoire et les objets immuables (comme les nombres) sont comparés par contenu au niveau des bits. Cette fonction est parfois appelée "égal". Elle retourne toujours une valeur Bool.

Exemples

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

julia> a == b
true

julia> a === b
false

julia> a === a
true

isa(x, type) -> Bool

Détermine si x est du type donné type. Peut également être utilisé comme un opérateur infixe, par exemple x isa type.

Exemples

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

Semblable à ==, sauf pour le traitement des nombres à virgule flottante et des valeurs manquantes. isequal considère toutes les valeurs NaN à virgule flottante comme égales entre elles, considère -0.0 comme inégal à 0.0, et missing comme égal à missing. Renvoie toujours une valeur de type Bool.

isequal est une relation d'équivalence - elle est réflexive (=== implique isequal), symétrique (isequal(a, b) implique isequal(b, a)) et transitive (isequal(a, b) et isequal(b, c) implique isequal(a, c)).

Implémentation

L'implémentation par défaut de isequal appelle ==, donc un type qui n'implique pas de valeurs à virgule flottante n'a généralement besoin de définir que ==.

isequal est la fonction de comparaison utilisée par les tables de hachage (Dict). isequal(x,y) doit impliquer que hash(x) == hash(y).

Cela signifie généralement que les types pour lesquels une méthode personnalisée == ou isequal existe doivent implémenter une méthode hash correspondante (et vice versa). Les collections implémentent généralement isequal en appelant isequal de manière récursive sur tous les contenus.

De plus, isequal est lié à isless, et ils travaillent ensemble pour définir un ordre total fixe, où exactement l'un de isequal(x, y), isless(x, y), ou isless(y, x) doit être true (et les deux autres false).

Les types scalaires n'ont généralement pas besoin d'implémenter isequal séparément de ==, à moins qu'ils ne représentent des nombres à virgule flottante susceptibles d'une implémentation plus efficace que celle fournie comme solution générique (basée sur isnan, signbit, et ==).

Exemples

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)

Créez une fonction qui compare son argument à x en utilisant isequal, c'est-à-dire une fonction équivalente à y -> isequal(y, x).

La fonction retournée est de type Base.Fix2{typeof(isequal)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

isless(x, y)

Testez si x est inférieur à y, selon un ordre total fixe (défini avec isequal). isless n'est pas défini pour les paires (x, y) de tous types. Cependant, s'il est défini, il est censé satisfaire les conditions suivantes :

• Si isless(x, y) est défini, alors isless(y, x) et isequal(x, y) le sont aussi, et exactement l'un de ces trois renvoie true.
• La relation définie par isless est transitive, c'est-à-dire que isless(x, y) && isless(y, z) implique isless(x, z).

Les valeurs qui sont normalement non ordonnées, comme NaN, sont ordonnées après les valeurs régulières. Les valeurs missing sont ordonnées en dernier.

C'est la comparaison par défaut utilisée par sort!.

Implémentation

Les types non numériques avec un ordre total devraient implémenter cette fonction. Les types numériques n'ont besoin de l'implémenter que s'ils ont des valeurs spéciales telles que NaN. Les types avec un ordre partiel devraient implémenter <. Consultez la documentation sur Ordres Alternatifs pour savoir comment définir des méthodes d'ordre alternatives qui peuvent être utilisées dans le tri et les fonctions connexes.

Exemples

julia> isless(1, 3)
true

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

isunordered(x)

Retourne true si x est une valeur qui n'est pas ordonnable selon <, comme NaN ou missing.

Les valeurs qui évaluent à true avec ce prédicat peuvent être ordonnables par rapport à d'autres ordres tels que isless.

ifelse(condition::Bool, x, y)

Retourne x si condition est true, sinon retourne y. Cela diffère de ? ou if en ce sens que c'est une fonction ordinaire, donc tous les arguments sont évalués en premier. Dans certains cas, utiliser ifelse au lieu d'une instruction if peut éliminer la branche dans le code généré et fournir de meilleures performances dans des boucles serrées.

Exemples

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

typeassert(x, type)

Lève une TypeError à moins que x isa type. La syntaxe x::type appelle cette fonction.

Exemples

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

typeof(x)

Obtenez le type concret de x.

Voir aussi eltype.

Exemples

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

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

julia> typeof(M)
Matrix{Float64} (alias pour Array{Float64, 2})

tuple(xs...)

Construit un tuple des objets donnés.

Voir aussi Tuple, ntuple, NamedTuple.

Exemples

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

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

julia> Tuple(Real[1, 2, pi])  # prend une collection
(1, 2, π)

ntuple(f, n::Integer)

Crée un tuple de longueur n, en calculant chaque élément comme f(i), où i est l'index de l'élément.

Exemples

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

ntuple(f, ::Val{N})

Crée un tuple de longueur N, en calculant chaque élément comme f(i), où i est l'index de l'élément. En prenant un argument Val(N), il est possible que cette version de ntuple génère un code plus efficace que la version prenant la longueur comme un entier. Mais ntuple(f, N) est préférable à ntuple(f, Val(N)) dans les cas où N ne peut pas être déterminé à la compilation.

Exemples

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

objectid(x) -> UInt

Obtenez une valeur de hachage pour x basée sur l'identité de l'objet.

Si x === y alors objectid(x) == objectid(y), et généralement lorsque x !== y, objectid(x) != objectid(y).

Voir aussi hash, IdDict.

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

Calculez un code de hachage entier tel que isequal(x,y) implique hash(x)==hash(y). L'argument optionnel h est un autre code de hachage à mélanger avec le résultat.

Les nouveaux types doivent implémenter la forme à 2 arguments, généralement en appelant de manière récursive la méthode hash à 2 arguments afin de mélanger les hachages des contenus entre eux (et avec h). En général, tout type qui implémente hash doit également implémenter son propre == (d'où isequal) pour garantir la propriété mentionnée ci-dessus.

La valeur de hachage peut changer lorsqu'un nouveau processus Julia est démarré.

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # n'utilisez que la sortie d'une autre fonction de hachage comme deuxième argument
0xd42bad54a8575b16

Voir aussi : objectid, Dict, Set.

finalizer(f, x)

Enregistre une fonction f(x) à appeler lorsqu'il n'y a plus de références accessibles par le programme à x, et retourne x. Le type de x doit être un mutable struct, sinon la fonction lèvera une exception.

f ne doit pas provoquer de changement de tâche, ce qui exclut la plupart des opérations d'E/S telles que println. Utiliser la macro @async (pour différer le changement de contexte à l'extérieur du finaliseur) ou ccall pour invoquer directement des fonctions d'E/S en C peut être utile à des fins de débogage.

Notez qu'il n'y a pas d'âge de monde garanti pour l'exécution de f. Il peut être appelé dans l'âge de monde dans lequel le finaliseur a été enregistré ou dans un âge de monde ultérieur.

Exemples

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

Un finaliseur peut être enregistré lors de la construction de l'objet. Dans l'exemple suivant, notez que nous comptons implicitement sur le finaliseur retournant le mutable struct nouvellement créé x.

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

finalize(x)

Exécute immédiatement les finaliseurs enregistrés pour l'objet x.

copy(x)

Crée une copie superficielle de x : la structure externe est copiée, mais pas toutes les valeurs internes. Par exemple, copier un tableau produit un nouveau tableau avec des éléments identiques à ceux de l'original.

Voir aussi copy!, copyto!, deepcopy.

deepcopy(x)

Crée une copie profonde de x : tout est copié récursivement, ce qui donne un objet entièrement indépendant. Par exemple, la copie profonde d'un tableau crée des copies profondes de tous les objets qu'il contient et produit un nouveau tableau avec la structure de relation cohérente (par exemple, si les deux premiers éléments sont le même objet dans le tableau original, les deux premiers éléments du nouveau tableau seront également le même objet deepcopyé). Appeler deepcopy sur un objet devrait généralement avoir le même effet que de le sérialiser puis de le désérialiser.

Bien qu'il ne soit normalement pas nécessaire, les types définis par l'utilisateur peuvent remplacer le comportement par défaut de deepcopy en définissant une version spécialisée de la fonction deepcopy_internal(x::T, dict::IdDict) (qui ne devrait pas être utilisée autrement), où T est le type à spécialiser, et dict garde une trace des objets copiés jusqu'à présent dans la récursion. Dans la définition, deepcopy_internal doit être utilisé à la place de deepcopy, et la variable dict doit être mise à jour comme il se doit avant de retourner.

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

La syntaxe a.b appelle getproperty(a, :b). La syntaxe @atomic order a.b appelle getproperty(a, :b, :order) et la syntaxe @atomic a.b appelle getproperty(a, :b, :sequentially_consistent).

Exemples

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

On ne devrait surcharger getproperty que lorsque c'est nécessaire, car cela peut être déroutant si le comportement de la syntaxe obj.f est inhabituel. Notez également que l'utilisation de méthodes est souvent préférable. Voir aussi cette documentation de guide de style pour plus d'informations : Préférer les méthodes exportées à l'accès direct aux champs.

Voir aussi getfield, propertynames et setproperty!.

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

La syntaxe a.b = c appelle setproperty!(a, :b, c). La syntaxe @atomic order a.b = c appelle setproperty!(a, :b, c, :order) et la syntaxe @atomic a.b = c appelle setproperty!(a, :b, c, :sequentially_consistent).

Voir aussi setfield!, propertynames et getproperty.

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

Effectuez une opération de comparaison et d'échange sur x.f de expected à desired, par égal. La syntaxe @atomicreplace x.f expected => desired peut être utilisée à la place de la forme d'appel de fonction.

Voir aussi replacefield! setproperty!, setpropertyonce!.

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

La syntaxe @atomic a.b, _ = c, a.b renvoie (c, swapproperty!(a, :b, c, :sequentially_consistent)), où il doit y avoir une expression getproperty commune aux deux côtés.

Voir aussi swapfield! et setproperty!.

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

La syntaxe @atomic op(x.f, v) (et son équivalent @atomic x.f op v) renvoie modifyproperty!(x, :f, op, v, :sequentially_consistent), où le premier argument doit être une expression getproperty et est modifié de manière atomique.

L'invocation de op(getproperty(x, f), v) doit renvoyer une valeur qui peut être stockée dans le champ f de l'objet x par défaut. En particulier, contrairement au comportement par défaut de setproperty!, la fonction convert n'est pas appelée automatiquement.

Voir aussi modifyfield! et setproperty!.

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

Effectuez une opération de comparaison et d'échange sur x.f pour le définir sur value s'il n'était pas précédemment défini. La syntaxe @atomiconce x.f = value peut être utilisée à la place de la forme d'appel de fonction.

Voir aussi setfieldonce!, setproperty!, replaceproperty!.

propertynames(x, private=false)

Obtenez un tuple ou un vecteur des propriétés (x.property) d'un objet x. Cela correspond généralement à fieldnames(typeof(x)), mais les types qui redéfinissent getproperty devraient généralement redéfinir propertynames également pour obtenir les propriétés d'une instance du type.

propertynames(x) peut ne retourner que les noms de propriétés "publiques" qui font partie de l'interface documentée de x. Si vous souhaitez qu'il retourne également les noms de propriétés "privées" destinées à un usage interne, passez true comme deuxième argument optionnel. La complétion par tabulation dans le REPL sur x. n'affiche que les propriétés private=false.

Voir aussi : hasproperty, hasfield.

hasproperty(x, s::Symbol)

Renvoie un booléen indiquant si l'objet x a s comme l'une de ses propres propriétés.

Voir aussi : propertynames, hasfield.

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

Extraire un champ d'une valeur composite value par nom ou position. En option, un ordre peut être défini pour l'opération. Si le champ a été déclaré @atomic, il est fortement recommandé que la spécification soit compatible avec les stockages à cet emplacement. Sinon, s'il n'est pas déclaré comme @atomic, ce paramètre doit être :not_atomic s'il est spécifié. Voir aussi getproperty et fieldnames.

Exemples

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

Assignez x à un champ nommé dans value de type composite. Le value doit être mutable et x doit être un sous-type de fieldtype(typeof(value), name). De plus, un ordre peut être spécifié pour cette opération. Si le champ a été déclaré @atomic, cette spécification est obligatoire. Sinon, s'il n'est pas déclaré comme @atomic, il doit être :not_atomic s'il est spécifié. Voir aussi setproperty!.

Exemples

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

Effectuer atomiquement les opérations pour obtenir et définir un champ après avoir appliqué la fonction op.

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

Si pris en charge par le matériel (par exemple, incrément atomique), cela peut être optimisé vers l'instruction matérielle appropriée, sinon cela utilisera une boucle.

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)

Effectuer atomiquement les opérations pour obtenir et conditionnellement définir un champ à une valeur donnée.

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

Si pris en charge par le matériel, cela peut être optimisé pour l'instruction matérielle appropriée, sinon cela utilisera une boucle.

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

Effectuer atomiquement les opérations pour obtenir et définir simultanément un champ :

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

Effectuer atomiquement les opérations pour définir un champ à une valeur donnée, uniquement s'il n'a pas été précédemment défini.

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

Teste si une variable globale ou un champ d'objet est défini. Les arguments peuvent être un module et un symbole ou un objet composite et un nom de champ (sous forme de symbole) ou un index. En option, un ordre peut être défini pour l'opération. Si le champ a été déclaré @atomic, il est fortement recommandé que la spécification soit compatible avec les stockages à cet emplacement. Sinon, s'il n'est pas déclaré comme @atomic, ce paramètre doit être :not_atomic s'il est spécifié.

Pour tester si un élément de tableau est défini, utilisez isassigned à la place.

Voir aussi @isdefined.

Exemples

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

Teste si la variable s est définie dans le scope actuel.

Voir aussi isdefined pour les propriétés de champ et isassigned pour les index de tableau ou haskey pour d'autres mappages.

Exemples

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 (generic function with 1 method)

julia> f()
false
true

convert(T, x)

Convertir x en une valeur de type T.

Si T est un type Integer, une InexactError sera levée si x n'est pas représentable par T, par exemple si x n'est pas de valeur entière, ou est en dehors de la plage supportée par T.

Exemples

julia> convert(Int, 3.0)
3

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

Si T est un type AbstractFloat, alors il renverra la valeur la plus proche de x représentable par T. Inf est traité comme un ulp de plus que floatmax(T) pour déterminer le plus proche.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

Si T est un type de collection et x une collection, le résultat de convert(T, x) peut faire référence à tout ou partie de x.

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

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

julia> y === x
true

Voir aussi : round, trunc, oftype, reinterpret.

promote(xs...)

Convertir tous les arguments en un type commun et les retourner tous (sous forme de tuple). Si aucun argument ne peut être converti, une erreur est levée.

Voir aussi : promote_type, promote_rule.

Exemples

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)

Convertir y au type de x, c'est-à-dire convert(typeof(x), y).

Exemples

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

widen(x)

Si x est un type, retourne un type "plus grand", défini de sorte que les opérations arithmétiques + et - ne soient pas garanties de débordement ni de perte de précision pour toute combinaison de valeurs que le type x peut contenir.

Pour les types d'entiers à taille fixe inférieurs à 128 bits, widen retournera un type avec le double du nombre de bits.

Si x est une valeur, elle est convertie en widen(typeof(x)).

Exemples

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

La fonction identité. Renvoie son argument.

Voir aussi : one, oneunit, et I de LinearAlgebra.

Exemples

julia> identity("Eh bien, qu'attendiez-vous?")
"Eh bien, qu'attendiez-vous?"

WeakRef(x)

w = WeakRef(x) construit une référence faible à la valeur Julia x : bien que w contienne une référence à x, cela n'empêche pas x d'être collecté par le ramasse-miettes. w.value est soit x (si x n'a pas encore été collecté), soit nothing (si x a été collecté).

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

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

julia> GC.gc()

julia> w           # une référence est maintenue via `x`
WeakRef("a string")

julia> x = nothing # effacer la référence

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::DataType)

Retourne le supertype du DataType T.

Exemples

julia> supertype(Int32)
Signed

Core.Type{T}

Core.Type est un type abstrait qui a tous les objets de type comme ses instances. La seule instance du type singleton Core.Type{T} est l'objet T.

Exemples

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ésente des types déclarés explicitement qui ont des noms, des supertypes déclarés explicitement et, éventuellement, des paramètres. Chaque valeur concrète dans le système est une instance de quelque DataType.

Exemples

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

<:(T1, T2)

Opérateur de sous-type : renvoie true si et seulement si toutes les valeurs de type T1 sont également de type T2.

Exemples

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

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

>:(T1, T2)

Opérateur de supertype, équivalent à T2 <: T1.

typejoin(T, S, ...)

Renvoie l'ancêtre commun le plus proche des types T et S, c'est-à-dire le type le plus étroit dont ils héritent tous les deux. Récursive sur des varargs supplémentaires.

Exemples

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number

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

Calcule un type qui contient l'intersection de T et S. En général, ce sera le plus petit type de ce type ou un proche de celui-ci.

Un cas spécial où un comportement exact est garanti : lorsque T <: S, typeintersect(S, T) == T == typeintersect(T, S).

promote_type(type1, type2, ...)

La promotion fait référence à la conversion de valeurs de types mixtes en un type commun unique. promote_type représente le comportement de promotion par défaut dans Julia lorsque des opérateurs (généralement mathématiques) reçoivent des arguments de types différents. promote_type essaie généralement de renvoyer un type qui peut au moins approcher la plupart des valeurs de l'un ou l'autre type d'entrée sans élargir excessivement. Une certaine perte est tolérée ; par exemple, promote_type(Int64, Float64) renvoie Float64 même si, strictement, toutes les valeurs Int64 ne peuvent pas être représentées exactement comme des valeurs Float64.

Voir aussi : promote, promote_typejoin, promote_rule.

Exemples

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)

Spécifie quel type doit être utilisé par promote lorsqu'il reçoit des valeurs des types type1 et type2. Cette fonction ne doit pas être appelée directement, mais des définitions doivent y être ajoutées pour de nouveaux types si nécessaire.

promote_typejoin(T, S)

Calcule un type qui contient à la fois T et S, qui pourrait être soit un parent des deux types, soit un Union si approprié. Fait appel à typejoin en cas de besoin.

Voir aussi promote, promote_type.

Exemples

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64

isdispatchtuple(T)

Déterminez si le type T est un "type feuille" de tuple, ce qui signifie qu'il pourrait apparaître comme une signature de type dans le dispatch et n'a pas de sous-types (ou super-types) qui pourraient apparaître dans un appel. Si T n'est pas un type, alors retournez false.

ismutable(v) -> Bool

Retourne true si et seulement si la valeur v est mutable. Voir Types composites mutables pour une discussion sur l'immuabilité. Notez que cette fonction fonctionne sur des valeurs, donc si vous lui donnez un DataType, elle vous dira qu'une valeur de ce type est mutable.

Voir aussi isbits, isstructtype.

Exemples

julia> ismutable(1)
false

julia> ismutable([1,2])
true

isimmutable(v) -> Bool

Retourne true si et seulement si la valeur v est immuable. Voir Mutable Composite Types pour une discussion sur l'immuabilité. Notez que cette fonction fonctionne sur des valeurs, donc si vous lui donnez un type, elle vous dira qu'une valeur de DataType est mutable.

Exemples

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

ismutabletype(T) -> Bool

Déterminez si le type T a été déclaré comme un type mutable (c'est-à-dire en utilisant le mot-clé mutable struct). Si T n'est pas un type, alors renvoyez false.

isabstracttype(T)

Déterminez si le type T a été déclaré comme un type abstrait (c'est-à-dire en utilisant la syntaxe abstract type). Notez que ce n'est pas la négation de isconcretetype(T). Si T n'est pas un type, alors renvoyez false.

Exemples

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

Déterminez si le type T a été déclaré comme un type primitif (c'est-à-dire en utilisant la syntaxe primitive type). Si T n'est pas un type, alors retournez false.

Base.issingletontype(T)

Déterminez si le type T a exactement une instance possible ; par exemple, un type de structure sans champs sauf d'autres valeurs singleton. Si T n'est pas un type concret, alors renvoyez false.

isstructtype(T) -> Bool

Déterminez si le type T a été déclaré comme un type struct (c'est-à-dire en utilisant le mot-clé struct ou mutable struct). Si T n'est pas un type, alors renvoyez false.

nameof(t::DataType) -> Symbol

Obtenez le nom d'un DataType (potentiellement enveloppé dans UnionAll) (sans son module parent) sous forme de symbole.

Exemples

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

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

fieldnames(x::DataType)

Obtenez un tuple avec les noms des champs d'un DataType.

Voir aussi propertynames, hasfield.

Exemples

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

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

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

Obtenez le nom du champ i d'un DataType.

Exemples

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

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

Déterminez le type déclaré d'un champ (spécifié par le nom ou l'index) dans un DataType composite T.

Exemples

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

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

Les types déclarés de tous les champs dans un DataType composite T sous forme de tuple.

Exemples

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

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

Obtenez le nombre de champs qu'une instance du type donné aurait. Une erreur est levée si le type est trop abstrait pour déterminer cela.

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

Renvoie un booléen indiquant si T a name comme l'un de ses propres champs.

Voir aussi fieldnames, fieldcount, hasproperty.

Exemples

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false

nfields(x) -> Int

Obtenez le nombre de champs dans l'objet donné.

Exemples

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("J'ai fait une mauvaise chose");

julia> nfields(ex)
1

Dans ces exemples, a est un Rational, qui a deux champs. b est un Int, qui est un type de bit primitif sans champs du tout. ex est un ErrorException, qui a un champ.

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

Déterminez si une variable globale est déclarée const dans un module donné m.

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

Déterminez si un champ s est déclaré const dans un type donné t.

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

Déterminez si un champ s est déclaré @atomic dans un type donné t.

sizeof(T::DataType)
sizeof(obj)

Taille, en octets, de la représentation binaire canonique du DataType donné T, le cas échéant. Ou la taille, en octets, de l'objet obj s'il n'est pas un DataType.

Voir aussi Base.summarysize.

Exemples

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) # pas la somme de `sizeof` des champs en raison du remplissage
16

julia> sizeof(Int64) + sizeof(Bool) # différent de ci-dessus
9

Si le DataType T n'a pas de taille spécifique, une erreur est levée.

julia> sizeof(AbstractArray)
ERROR: Le type abstrait AbstractArray n'a pas de taille définie.
Stacktrace:
[...]

isconcretetype(T)

Déterminez si le type T est un type concret, ce qui signifie qu'il pourrait avoir des instances directes (valeurs x telles que typeof(x) === T). Notez que ce n'est pas la négation de isabstracttype(T). Si T n'est pas un type, alors renvoyez false.

Voir aussi : isbits, isabstracttype, issingletontype.

Exemples

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)

Retourne true si x est une instance d'un type isbitstype.

isbitstype(T)

Retourne true si le type T est un type de "données simples", ce qui signifie qu'il est immuable et ne contient aucune référence à d'autres valeurs, seulement des types primitifs et d'autres types isbitstype. Des exemples typiques sont les types numériques tels que UInt8, Float64 et Complex{Float64}. Cette catégorie de types est significative car elle est valide en tant que paramètres de type, peut ne pas suivre l'état isdefined / isassigned, et a une disposition définie qui est compatible avec C. Si T n'est pas un type, alors retourne false.

Voir aussi isbits, isprimitivetype, ismutable.

Exemples

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

fieldoffset(type, i)

Le décalage en octets du champ i d'un type par rapport au début des données. Par exemple, nous pourrions l'utiliser de la manière suivante pour résumer des informations sur une structure :

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

Alignement minimum de l'allocation mémoire pour les instances de ce type. Peut être appelé sur tout isconcretetype, bien que pour Memory, il donnera l'alignement des éléments, et non de l'objet entier.

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

Renvoie si les champs des instances de ce type sont regroupés en mémoire, sans bits de remplissage intermédiaires (définis comme des bits dont la valeur n'impacte pas de manière unique le test d'égalité lorsqu'il est appliqué aux champs de la structure). Peut être appelé sur tout isconcretetype.

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

Renvoie si les instances de ce type peuvent contenir des références à la mémoire gérée par le GC. Peut être appelé sur tout isconcretetype.

typemin(T)

La plus basse valeur représentable par le type de données numériques (réel) donné T.

Voir aussi : floatmin, typemax, eps.

Exemples

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # plus petit nombre à virgule flottante Float32 fini
-3.4028235f38

typemax(T)

La valeur la plus élevée représentable par le DataType numérique (réel) donné.

Voir aussi : floatmax, typemin, eps.

Exemples

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # plus grand nombre à virgule flottante Finie Float32
3.4028235f38

floatmin(T = Float64)

Renvoie le plus petit nombre normal positif représentable par le type à virgule flottante T.

Exemples

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

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T = Float64)

Renvoie le plus grand nombre fini représentable par le type à virgule flottante T.

Voir aussi : typemax, floatmin, eps.

Exemples

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf

maxintfloat(T=Float64)

Le plus grand nombre à virgule flottante de valeur entière consécutive qui est exactement représenté dans le type de virgule flottante donné T (qui par défaut est Float64).

C'est-à-dire que maxintfloat renvoie le plus petit nombre à virgule flottante de valeur entière positive n tel que n+1 n'est pas exactement représentable dans le type T.

Lorsqu'une valeur de type Integer est nécessaire, utilisez Integer(maxintfloat(T)).

maxintfloat(T, S)

Le plus grand entier consécutif représentable dans le type de flottant donné T qui ne dépasse pas non plus l'entier maximum représentable par le type entier S. En d'autres termes, c'est le minimum de maxintfloat(T) et de typemax(S).

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

Renvoie le epsilon machine du type à virgule flottante T (T = Float64 par défaut). Cela est défini comme l'écart entre 1 et la valeur suivante la plus grande représentable par typeof(one(T)), et est équivalent à eps(one(T)). (Puisque eps(T) est une limite sur l'erreur relative de T, c'est une quantité "sans dimension" comme one.)

Exemples

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)

Retourne l'unité dans la dernière place (ulp) de x. C'est la distance entre les valeurs flottantes représentables consécutives à x. Dans la plupart des cas, si la distance de chaque côté de x est différente, alors la plus grande des deux est prise, c'est-à-dire

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

Les exceptions à cette règle sont les plus petites et les plus grandes valeurs finies (par exemple, nextfloat(-Inf) et prevfloat(Inf) pour Float64), qui arrondissent à la plus petite des valeurs.

La raison de ce comportement est que eps borne l'erreur d'arrondi en virgule flottante. Sous le mode d'arrondi par défaut RoundNearest, si $y$ est un nombre réel et $x$ est le nombre en virgule flottante le plus proche de $y$, alors

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

Voir aussi : nextfloat, issubnormal, floatmax.

Exemples

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)      # plus grand Float64 fini
1.7976931348623157e308

julia> x + eps(x)/2            # arrondit vers le haut
Inf

julia> x + prevfloat(eps(x)/2) # arrondit vers le bas
1.7976931348623157e308

instances(T::Type)

Renvoie une collection de toutes les instances du type donné, si applicable. Principalement utilisé pour les types énumérés (voir @enum).

Exemples

julia> @enum Color red blue green

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

Any::DataType

Any est l'union de tous les types. Il a la propriété définissante isa(x, Any) == true pour tout x. Any décrit donc l'ensemble de l'univers des valeurs possibles. Par exemple, Integer est un sous-ensemble de Any qui inclut Int, Int8, et d'autres types d'entiers.

Union{Types...}

Un type Union est un type abstrait qui inclut toutes les instances de n'importe lequel de ses types d'argument. Cela signifie que T <: Union{T,S} et S <: Union{T,S}.

Comme d'autres types abstraits, il ne peut pas être instancié, même si tous ses arguments ne sont pas abstraits.

Exemples

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

julia> 1 isa IntOrString # une instance d'Int est incluse dans l'union
true

julia> "Hello!" isa IntOrString # String est également inclus
true

julia> 1.0 isa IntOrString # Float64 n'est pas inclus car il n'est ni Int ni AbstractString
false

Aide Étendue

Contrairement à la plupart des autres types paramétriques, les unions sont covariantes dans leurs paramètres. Par exemple, Union{Real, String} est un sous-type de Union{Number, AbstractString}.

L'union vide Union{} est le type le plus bas de Julia.

Union{}

Union{}, l'Union vide de types, est le type qui n'a pas de valeurs. C'est-à-dire qu'il a la propriété définissante isa(x, Union{}) == false pour tout x. Base.Bottom est défini comme son alias et le type de Union{} est Core.TypeofBottom.

Exemples

julia> isa(nothing, Union{})
false

UnionAll

Une union de types sur toutes les valeurs d'un paramètre de type. UnionAll est utilisé pour décrire des types paramétriques où les valeurs de certains paramètres ne sont pas connues. Voir la section du manuel sur UnionAll Types.

Exemples

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

Un tuple est un conteneur de longueur fixe qui peut contenir des valeurs de différents types, mais ne peut pas être modifié (il est immuable). Les valeurs peuvent être accessibles par indexation. Les littéraux de tuple sont écrits avec des virgules et des parenthèses :

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}

Un tuple de longueur 1 doit être écrit avec une virgule, (1,), car (1) serait simplement une valeur entre parenthèses. () représente le tuple vide (de longueur 0).

Un tuple peut être construit à partir d'un itérateur en utilisant un type Tuple comme constructeur :

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

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

Les types de tuple sont covariants dans leurs paramètres : Tuple{Int} est un sous-type de Tuple{Any}. Par conséquent, Tuple{Any} est considéré comme un type abstrait, et les types de tuple ne sont concrets que si leurs paramètres le sont. Les tuples n'ont pas de noms de champ ; les champs ne sont accessibles que par index. Les types de tuple peuvent avoir n'importe quel nombre de paramètres.

Voir la section du manuel sur Tuple Types.

Voir aussi Vararg, NTuple, ntuple, tuple, NamedTuple.

NTuple{N, T}

Une manière compacte de représenter le type d'un tuple de longueur N où tous les éléments sont de type T.

Exemples

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

Voir aussi ntuple.

NamedTuple

Les NamedTuple sont, comme leur nom l'indique, des Tuple nommés. C'est-à-dire qu'ils constituent une collection de valeurs semblable à un tuple, où chaque entrée a un nom unique, représenté sous la forme d'un Symbol. Comme les Tuple, les NamedTuple sont immuables ; ni les noms ni les valeurs ne peuvent être modifiés sur place après leur construction.

Un tuple nommé peut être créé comme un littéral de tuple avec des clés, par exemple (a=1, b=2), ou comme un littéral de tuple avec un point-virgule après la parenthèse d'ouverture, par exemple (; a=1, b=2) (cette forme accepte également des noms générés par programme comme décrit ci-dessous), ou en utilisant un type NamedTuple comme constructeur, par exemple NamedTuple{(:a, :b)}((1,2)).

L'accès à la valeur associée à un nom dans un tuple nommé peut se faire en utilisant la syntaxe d'accès aux champs, par exemple x.a, ou en utilisant getindex, par exemple x[:a] ou x[(:a, :b)]. Un tuple des noms peut être obtenu en utilisant keys, et un tuple des valeurs peut être obtenu en utilisant values.

Le macro @NamedTuple peut être utilisé pour déclarer commodément des types NamedTuple.

Exemples

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

De la même manière que l'on peut définir des arguments de mots-clés par programme, un tuple nommé peut être créé en donnant des paires name::Symbol => value après un point-virgule à l'intérieur d'un littéral de tuple. Cette syntaxe et la syntaxe name=value peuvent être mélangées :

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

Les paires nom-valeur peuvent également être fournies en splattant un tuple nommé ou tout itérateur qui produit des collections à deux valeurs contenant chacune un symbole comme première valeur :

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) # le dernier b écrase la valeur de nt1
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zip produit des tuples tels que (:a, 1)
(a = 1, b = 2, c = 3)

Comme pour les arguments de mots-clés, les identifiants et les expressions à point indiquent des noms :

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

Cette macro offre une syntaxe plus pratique pour déclarer des types NamedTuple. Elle renvoie un type NamedTuple avec les clés et types donnés, équivalent à NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}}. Si la déclaration ::Type est omise, elle est considérée comme Any. La forme begin ... end permet de répartir les déclarations sur plusieurs lignes (similaire à une déclaration struct), mais est autrement équivalente. La macro NamedTuple est utilisée lors de l'impression des types NamedTuple dans par exemple le REPL.

Par exemple, le tuple (a=3.1, b="hello") a un type NamedTuple{(:a, :b), Tuple{Float64, String}}, qui peut également être déclaré via @NamedTuple comme suit :

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, ...}

Ce macro offre un moyen pratique de construire la représentation de type des arguments de mot-clé à partir de la même syntaxe que @NamedTuple. Par exemple, lorsque nous avons un appel de fonction comme func([arguments positionnels]; kw1=1.0, kw2="2"), nous pouvons utiliser ce macro pour construire la représentation interne de type des arguments de mot-clé comme @Kwargs{kw1::Float64, kw2::String}. La syntaxe du macro est spécifiquement conçue pour simplifier le type de signature d'une méthode de mot-clé lorsqu'elle est imprimée dans la vue de trace de pile.

julia> @Kwargs{init::Int} # la représentation interne des arguments de mot-clé
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
La fonction `+` existe, mais aucune méthode n'est définie pour cette combinaison de types d'arguments.

Les candidats les plus proches sont :
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) où T<:AbstractChar
   @ Base char.jl:237

Trace de la pile :
  [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)

Retourne Val{c}(), qui ne contient aucune donnée d'exécution. Des types comme celui-ci peuvent être utilisés pour passer l'information entre les fonctions à travers la valeur c, qui doit être une valeur isbits ou un Symbol. L'intention de cette construction est de pouvoir dispatcher sur des constantes directement (au moment de la compilation) sans avoir à tester la valeur de la constante à l'exécution.

Exemples

julia> f(::Val{true}) = "Good"
f (generic function with 1 method)

julia> f(::Val{false}) = "Bad"
f (generic function with 2 methods)

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

Vararg{T,N}

Le dernier paramètre d'un type de tuple Tuple peut être la valeur spéciale Vararg, qui désigne un nombre quelconque d'éléments en fin de liste. Vararg{T,N} correspond exactement à N éléments de type T. Enfin, Vararg{T} correspond à zéro ou plusieurs éléments de type T. Les types de tuple Vararg sont utilisés pour représenter les arguments acceptés par les méthodes varargs (voir la section sur Fonctions Varargs dans le manuel.)

Voir aussi NTuple.

Exemples

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

Rien

Un type sans champs qui est le type de nothing.

Voir aussi : isnothing, Some, Missing.

isnothing(x)

Retourne true si x === nothing, et retourne false sinon.

Voir aussi something, Base.notnothing, ismissing.

notnothing(x)

Lance une erreur si x === nothing, et retourne x sinon.

Some{T}

Un type d'enveloppe utilisé dans Union{Some{T}, Nothing} pour distinguer l'absence d'une valeur (nothing) et la présence d'une valeur nothing (c'est-à-dire Some(nothing)).

Utilisez something pour accéder à la valeur enveloppée par un objet Some.

something(x...)

Retourne la première valeur dans les arguments qui n'est pas égale à nothing, le cas échéant. Sinon, lance une erreur. Les arguments de type Some sont déballés.

Voir aussi coalesce, skipmissing, @something.

Exemples

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: No value arguments present

@something(x...)

Version à court-circuit de something.

Exemples

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

julia> a = 1;

julia> a = @something a f(2) f(3) error("Impossible de trouver une valeur par défaut pour `a`")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("Impossible de trouver une valeur par défaut pour `b`")
f(2)
f(3)
ERREUR: Impossible de trouver une valeur par défaut pour `b`
[...]

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

julia> b === nothing
true

Enum{T<:Integer}

Le supertype abstrait de tous les types énumérés définis avec @enum.

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

Créez un sous-type Enum{BaseType} avec le nom EnumName et des valeurs de membre d'énumération value1 et value2 avec des valeurs assignées optionnelles x et y, respectivement. EnumName peut être utilisé comme d'autres types et les valeurs de membre d'énumération comme des valeurs régulières, telles que

Exemples

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

julia> f(x::Fruit) = "Je suis un Fruit avec la valeur : $(Int(x))"
f (fonction générique avec 1 méthode)

julia> f(apple)
"Je suis un Fruit avec la valeur : 1"

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

Les valeurs peuvent également être spécifiées à l'intérieur d'un bloc begin, par exemple

@enum EnumName begin
    value1
    value2
end

BaseType, qui par défaut est Int32, doit être un sous-type primitif de Integer. Les valeurs de membre peuvent être converties entre le type d'énumération et BaseType. read et write effectuent ces conversions automatiquement. Dans le cas où l'énumération est créée avec un BaseType non par défaut, Integer(value1) renverra l'entier value1 avec le type BaseType.

Pour lister toutes les instances d'une énumération, utilisez instances, par exemple

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

Il est possible de construire un symbole à partir d'une instance d'énumération :

julia> Symbol(apple)
:apple

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

Un type représentant des expressions composées dans le code julia analysé (ASTs). Chaque expression se compose d'un head Symbol identifiant quel type d'expression il s'agit (par exemple, un appel, une boucle for, une instruction conditionnelle, etc.), et de sous-expressions (par exemple, les arguments d'un appel). Les sous-expressions sont stockées dans un champ Vector{Any} appelé args.

Voir le chapitre du manuel sur Metaprogramming et la documentation des développeurs Julia ASTs.

Exemples

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

Symbole

Le type d'objet utilisé pour représenter des identifiants dans le code julia analysé (ASTs). Utilisé également souvent comme un nom ou une étiquette pour identifier une entité (par exemple, comme clé de dictionnaire). Les Symbols peuvent être saisis en utilisant l'opérateur de citation : :

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

Les Symbols peuvent également être construits à partir de chaînes de caractères ou d'autres valeurs en appelant le constructeur Symbol(x...).

Les Symbols sont immuables et leur implémentation réutilise le même objet pour tous les Symbols ayant le même nom.

Contrairement aux chaînes de caractères, les Symbols sont des entités "atomiques" ou "scalaires" qui ne prennent pas en charge l'itération sur les caractères.

Symbol(x...) -> Symbol

Créez un Symbol en concaténant les représentations sous forme de chaîne des arguments.

Exemples

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

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

Module

Un Module est un espace de travail de variables globales séparé. Voir module et la section du manuel sur les modules pour plus de détails.

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

Retourne un module avec le nom spécifié. Un baremodule correspond à Module(:ModuleName, false)

Un module vide ne contenant aucun nom peut être créé avec Module(:ModuleName, false, false). Ce module n'importera ni Base ni Core et ne contient pas de référence à lui-même.

Fonction

Type abstrait de toutes les fonctions.

Exemples

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (type singleton de la fonction sin, sous-type de Function)

julia> ans <: Function
true

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

Déterminez si la fonction générique donnée a une méthode correspondant au Tuple des types d'arguments donnés avec la limite supérieure de l'âge du monde donnée par world.

Si un tuple de noms d'arguments de mot-clé kwnames est fourni, cela vérifie également si la méthode de f correspondant à t a les noms d'arguments de mot-clé donnés. Si la méthode correspondante accepte un nombre variable d'arguments de mot-clé, par exemple avec kwargs..., tous les noms donnés dans kwnames sont considérés comme valides. Sinon, les noms fournis doivent être un sous-ensemble des arguments de mot-clé de la méthode.

Voir aussi applicable.

Exemples

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 accepte des kwargs arbitraires
true

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

Déterminez si la fonction générique donnée a une méthode applicable aux arguments donnés.

Voir aussi hasmethod.

Exemples

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

Détermine si deux méthodes m1 et m2 peuvent être ambiguës pour une certaine signature d'appel. Ce test est effectué dans le contexte d'autres méthodes de la même fonction ; isolément, m1 et m2 pourraient être ambiguës, mais si une troisième méthode résolvant l'ambiguïté a été définie, cela retourne false. Alternativement, isolément m1 et m2 pourraient être ordonnées, mais si une troisième méthode ne peut pas être triée avec elles, elles peuvent causer une ambiguïté ensemble.

Pour les types paramétriques, l'argument clé ambiguous_bottom contrôle si Union{} compte comme une intersection ambiguë de paramètres de type – lorsque true, il est considéré comme ambigu, lorsque false, il ne l'est pas.

Exemples

julia> foo(x::Complex{<:Integer}) = 1
foo (generic function with 1 method)

julia> foo(x::Complex{<:Rational}) = 2
foo (generic function with 2 methods)

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

Invoquer une méthode pour la fonction générique donnée f correspondant aux types spécifiés argtypes sur les arguments spécifiés args et en passant les arguments de mot-clé kwargs. Les arguments args doivent être conformes aux types spécifiés dans argtypes, c'est-à-dire que la conversion n'est pas effectuée automatiquement. Cette méthode permet d'invoquer une méthode autre que la méthode la plus spécifique correspondante, ce qui est utile lorsque le comportement d'une définition plus générale est explicitement nécessaire (souvent dans le cadre de l'implémentation d'une méthode plus spécifique de la même fonction).

Soyez prudent lorsque vous utilisez invoke pour des fonctions que vous n'écrivez pas. Quelle définition est utilisée pour les argtypes donnés est un détail d'implémentation à moins que la fonction ne précise explicitement que l'appel avec certains argtypes fait partie de l'API publique. Par exemple, le changement entre f1 et f2 dans l'exemple ci-dessous est généralement considéré comme compatible car le changement est invisible pour l'appelant avec un appel normal (non-invoke). Cependant, le changement est visible si vous utilisez invoke.

Exemples

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

Fournit un moyen pratique d'appeler invoke en développant @invoke f(arg1::T1, arg2::T2; kwargs...) en invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...). Lorsqu'une annotation de type d'argument est omise, elle est remplacée par Core.Typeof de cet argument. Pour invoquer une méthode où un argument n'est pas typé ou est explicitement typé comme Any, annotez l'argument avec ::Any.

Il prend également en charge la syntaxe suivante :

• @invoke (x::X).f se développe en invoke(getproperty, Tuple{X,Symbol}, x, :f)
• @invoke (x::X).f = v::V se développe en invoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v)
• @invoke (xs::Xs)[i::I] se développe en invoke(getindex, Tuple{Xs,I}, xs, i)
• @invoke (xs::Xs)[i::I] = v::V se développe en invoke(setindex!, Tuple{Xs,V,I}, xs, v, i)

Exemples

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

Appelle f(args...; kwargs...), mais garantit que la méthode la plus récente de f sera exécutée. Cela est utile dans des circonstances spécialisées, par exemple dans des boucles d'événements de longue durée ou des fonctions de rappel qui peuvent appeler des versions obsolètes d'une fonction f. (L'inconvénient est que invokelatest est quelque peu plus lent que d'appeler f directement, et le type du résultat ne peut pas être inféré par le compilateur.)

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

Fournit un moyen pratique d'appeler invokelatest. @invokelatest f(args...; kwargs...) sera simplement développé en Base.invokelatest(f, args...; kwargs...).

Il prend également en charge la syntaxe suivante :

• @invokelatest x.f se développe en Base.invokelatest(getproperty, x, :f)
• @invokelatest x.f = v se développe en Base.invokelatest(setproperty!, x, :f, v)
• @invokelatest xs[i] se développe en Base.invokelatest(getindex, xs, i)
• @invokelatest xs[i] = v se développe en Base.invokelatest(setindex!, xs, v, i)

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, ou new{A,B,...}

Fonction spéciale disponible pour les constructeurs internes qui crée un nouvel objet du type. La forme new{A,B,...} spécifie explicitement les valeurs des paramètres pour les types paramétriques. Voir la section du manuel sur Inner Constructor Methods pour plus d'informations.

|>(x, f)

Opérateur infixe qui applique la fonction f à l'argument x. Cela permet d'écrire f(g(x)) sous la forme x |> g |> f. Lorsqu'il est utilisé avec des fonctions anonymes, des parenthèses sont généralement nécessaires autour de la définition pour obtenir la chaîne souhaitée.

Exemples

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

Composer des fonctions : c'est-à-dire que (f ∘ g)(args...; kwargs...) signifie f(g(args...; kwargs...)). Le symbole ∘ peut être saisi dans le REPL Julia (et la plupart des éditeurs, correctement configurés) en tapant \circ<tab>.

La composition de fonctions fonctionne également sous forme préfixe : ∘(f, g) est la même chose que f ∘ g. La forme préfixe prend en charge la composition de plusieurs fonctions : ∘(f, g, h) = f ∘ g ∘ h et le splatting ∘(fs...) pour composer une collection itérable de fonctions. Le dernier argument de ∘ s'exécute en premier.

Exemples

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

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

Voir aussi ComposedFunction, !f::Function.

ComposedFunction{Outer,Inner} <: Function

Représente la composition de deux objets appelables outer::Outer et inner::Inner. C'est-à-dire

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

La manière préférée de construire une instance de ComposedFunction est d'utiliser l'opérateur de composition ∘ :

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

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

Les pièces composées sont stockées dans les champs de ComposedFunction et peuvent être récupérées comme suit :

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true

Voir aussi ∘.

splat(f)

Équivalent à

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

c'est-à-dire qu'étant donné une fonction, cela renvoie une nouvelle fonction qui prend un argument et le décompose dans la fonction originale. Cela est utile comme adaptateur pour passer une fonction à plusieurs arguments dans un contexte qui attend un seul argument, mais passe un tuple comme cet argument unique.

Exemples

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)

Un type représentant une version partiellement appliquée de la fonction à deux arguments f, avec le premier argument fixé à la valeur "x". En d'autres termes, Fix1(f, x) se comporte de manière similaire à y->f(x, y).

Voir aussi Fix2.

Fix2(f, x)

Un type représentant une version partiellement appliquée de la fonction à deux arguments f, avec le deuxième argument fixé à la valeur "x". En d'autres termes, Fix2(f, x) se comporte de manière similaire à y->f(y, x).

Core.eval(m::Module, expr)

Évalue une expression dans le module donné et renvoie le résultat.

eval(expr)

Évalue une expression dans le scope global du module contenant. Chaque Module (sauf ceux définis avec baremodule) a sa propre définition à un argument de eval, qui évalue les expressions dans ce module.

@eval [mod,] ex

Évaluez une expression avec des valeurs interpolées en utilisant eval. Si deux arguments sont fournis, le premier est le module dans lequel évaluer.

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

Charge le fichier dans un module anonyme en utilisant include, évalue toutes les expressions et retourne la valeur de la dernière expression. L'argument optionnel args peut être utilisé pour définir les arguments d'entrée du script (c'est-à-dire la variable globale ARGS). Notez que les définitions (par exemple, méthodes, globales) sont évaluées dans le module anonyme et n'affectent pas le module actuel.

Exemples

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)

Valide uniquement dans le contexte d'un Expr retourné par une macro. Empêche le passage d'hygiène de la macro de transformer les variables intégrées en variables gensym. Voir la section Macros du chapitre sur la Métaprogrammation du manuel pour plus de détails et d'exemples.

@inbounds(blk)

Élimine la vérification des limites de tableau dans les expressions.

Dans l'exemple ci-dessous, la vérification de la plage pour référencer l'élément i du tableau A est ignorée pour améliorer les performances.

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

@boundscheck(blk)

Annotates the expression blk as a bounds checking block, allowing it to be elided by @inbounds.

Exemples

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

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

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

julia> f1()
ERROR: BoundsError: tentative d'accès à un UnitRange{Int64} de 2 éléments à l'index [-1]
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()
"accès à (1:2)[-1]"

@propagate_inbounds

Indique au compilateur d'inliner une fonction tout en conservant le contexte inbounds de l'appelant.

@inline

Donnez un indice au compilateur que cette fonction vaut la peine d'être intégrée.

Les petites fonctions n'ont généralement pas besoin de l'annotation @inline, car le compilateur le fait automatiquement. En utilisant @inline sur des fonctions plus grandes, un coup de pouce supplémentaire peut être donné au compilateur pour l'intégrer.

@inline peut être appliqué immédiatement avant une définition de fonction ou dans un corps de fonction.

# annoter une définition longue
@inline function longdef(x)
    ...
end

# annoter une définition courte
@inline shortdef(x) = ...

# annoter une fonction anonyme qu'un bloc `do` crée
f() do
    @inline
    ...
end

@inline block

Donnez un indice au compilateur que les appels dans block valent la peine d'être intégrés.

# Le compilateur essaiera d'intégrer `f`
@inline f(...)

# Le compilateur essaiera d'intégrer `f`, `g` et `+`
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # corps
end

let
    @inline explicit_noinline(args...) # sera intégré
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # le compilateur essaiera d'intégrer cet appel
    b = f(b0)          # le compilateur ne tentera PAS d'intégrer cet appel
    return a, b
end

@noinline

Donnez un indice au compilateur pour qu'il ne fasse pas d'inlining d'une fonction.

Les petites fonctions sont généralement inlinées automatiquement. En utilisant @noinline sur de petites fonctions, l'inlining automatique peut être empêché.

@noinline peut être appliqué immédiatement avant une définition de fonction ou dans le corps d'une fonction.

# annoter une définition longue
@noinline function longdef(x)
    ...
end

# annoter une définition courte
@noinline shortdef(x) = ...

# annoter une fonction anonyme créée par un bloc `do`
f() do
    @noinline
    ...
end

@noinline block

Donnez un indice au compilateur pour qu'il ne fasse pas d'inlining des appels dans block.

# Le compilateur essaiera de ne pas inliner `f`
@noinline f(...)

# Le compilateur essaiera de ne pas inliner `f`, `g` et `+`
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # corps
end

let
    @noinline explicit_inline(args...) # ne sera pas inliné
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # le compilateur ne tentera PAS d'inliner cet appel
    b = f(b0)            # le compilateur tentera d'inliner cet appel
    return a, b
end

@nospecialize

Appliqué à un nom d'argument de fonction, cela indique au compilateur que l'implémentation de la méthode ne doit pas être spécialisée pour différents types de cet argument, mais plutôt utiliser le type déclaré pour cet argument. Il peut être appliqué à un argument dans une liste d'arguments formelle, ou dans le corps de la fonction. Lorsqu'il est appliqué à un argument, la macro doit envelopper l'ensemble de l'expression d'argument, par exemple, @nospecialize(x::Real) ou @nospecialize(i::Integer...) plutôt que d'envelopper seulement le nom de l'argument. Lorsqu'il est utilisé dans un corps de fonction, la macro doit se trouver en position de déclaration et avant tout code.

Lorsqu'il est utilisé sans arguments, il s'applique à tous les arguments de la portée parente. Dans une portée locale, cela signifie tous les arguments de la fonction contenant. Dans une portée globale (de niveau supérieur), cela signifie toutes les méthodes définies par la suite dans le module actuel.

La spécialisation peut être réinitialisée à la valeur par défaut en utilisant @specialize.

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

Exemples

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

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

Ici, l'annotation @nospecialize donne lieu à l'équivalent de

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

garantissant qu'une seule version de code natif sera générée pour g, une qui est générique pour tout AbstractArray. Cependant, le type de retour spécifique est toujours inféré pour g et f, et cela est toujours utilisé pour optimiser les appelants de f et g.

@specialize

Réinitialise l'indice de spécialisation pour un argument à la valeur par défaut. Pour plus de détails, voir @nospecialize.

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

Indique au compilateur d'inférer f en utilisant les types déclarés des arguments @nospecialize. Cela peut être utilisé pour limiter le nombre de spécialisations générées par le compilateur pendant l'inférence.

Exemples

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline Base.@nospecializeinfer g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

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

Dans cet exemple, f sera inféré pour chaque type spécifique de A, mais g ne sera inféré qu'une seule fois avec le type d'argument déclaré A::AbstractArray, ce qui signifie que le compilateur ne verra probablement pas le temps d'inférence excessif sur celui-ci tout en ne pouvant pas inférer le type de retour concret. Sans le @nospecializeinfer, f([1.0]) inférerait le type de retour de g comme Float64, indiquant que l'inférence a été effectuée pour g(::Vector{Float64}) malgré l'interdiction de génération de code spécialisé.

Base.@constprop réglage [ex]

Contrôlez le mode de propagation constante interprocédurale pour la fonction annotée.

Deux réglages sont pris en charge :

• Base.@constprop :aggressive [ex] : appliquez la propagation constante de manière agressive. Pour une méthode dont le type de retour dépend de la valeur des arguments, cela peut donner de meilleurs résultats d'inférence au prix d'un temps de compilation supplémentaire.
• Base.@constprop :none [ex] : désactivez la propagation constante. Cela peut réduire les temps de compilation pour les fonctions que Julia pourrait autrement juger dignes de propagation constante. Les cas courants concernent les fonctions avec des arguments de type Bool ou Symbol ou des arguments de mot-clé.

Base.@constprop peut être appliqué immédiatement avant une définition de fonction ou dans le corps d'une fonction.

# annoter une définition longue
Base.@constprop :aggressive function longdef(x)
    ...
end

# annoter une définition courte
Base.@constprop :aggressive shortdef(x) = ...

# annoter une fonction anonyme qu'un bloc `do` crée
f() do
    Base.@constprop :aggressive
    ...
end

gensym([tag])

Génère un symbole qui ne conflictera pas avec d'autres noms de variables (dans le même module).

@gensym

Génère un symbole gensym pour une variable. Par exemple, @gensym x y est transformé en x = gensym("x"); y = gensym("y").

var

La syntaxe var"#example#" fait référence à une variable nommée Symbol("#example#"), même si #example# n'est pas un nom d'identifiant valide en Julia.

Cela peut être utile pour l'interopérabilité avec des langages de programmation qui ont des règles différentes pour la construction d'identifiants valides. Par exemple, pour faire référence à la variable R draw.segments, vous pouvez utiliser var"draw.segments" dans votre code Julia.

Il est également utilisé pour show le code source julia qui a été soumis à l'hygiène des macros ou qui contient autrement des noms de variables qui ne peuvent pas être analysés normalement.

Notez que cette syntaxe nécessite un support du parseur, elle est donc étendue directement par le parseur plutôt que d'être implémentée comme une macro de chaîne normale @var_str.

@goto nom

@goto nom effectue un saut inconditionnel vers l'instruction à l'emplacement @label nom.

@label et @goto ne peuvent pas créer de sauts vers des instructions de niveau supérieur différentes. Les tentatives entraînent une erreur. Pour utiliser quand même @goto, enfermez @label et @goto dans un bloc.

@label nom

Étiquette une déclaration avec l'étiquette symbolique nom. L'étiquette marque le point de fin d'un saut inconditionnel avec @goto nom.

@simd

Annoter une boucle for pour permettre au compilateur de prendre des libertés supplémentaires pour permettre le réarrangement des boucles

L'objet itéré dans une boucle @simd for doit être une plage unidimensionnelle. En utilisant @simd, vous affirmez plusieurs propriétés de la boucle :

• Il est sûr d'exécuter les itérations dans un ordre arbitraire ou qui se chevauche, avec une attention particulière pour les variables de réduction.
• Les opérations en virgule flottante sur les variables de réduction peuvent être réorganisées ou contractées, ce qui peut entraîner des résultats différents de ceux sans @simd.

Dans de nombreux cas, Julia est capable de vectoriser automatiquement les boucles internes sans l'utilisation de @simd. L'utilisation de @simd donne au compilateur un peu plus de marge de manœuvre pour le rendre possible dans plus de situations. Dans tous les cas, votre boucle interne doit avoir les propriétés suivantes pour permettre la vectorisation :

• La boucle doit être une boucle la plus interne
• Le corps de la boucle doit être du code en ligne droite. Par conséquent, @inbounds est actuellement nécessaire pour tous les accès aux tableaux. Le compilateur peut parfois transformer de courtes expressions &&, || et ?: en code en ligne droite s'il est sûr d'évaluer tous les opérandes de manière inconditionnelle. Envisagez d'utiliser la fonction ifelse au lieu de ?: dans la boucle si cela est sûr à faire.
• Les accès doivent avoir un motif de pas et ne peuvent pas être des "gather" (lectures à index aléatoire) ou des "scatter" (écritures à index aléatoire).
• Le pas doit être un pas unitaire.

• Il n'existe aucune dépendance de mémoire portée par la boucle
• Aucune itération n'attend jamais qu'une itération précédente progresse.

@polly

Indique au compilateur d'appliquer l'optimiseur polyédrique Polly à une fonction.

@generated f

@generated est utilisé pour annoter une fonction qui sera générée. Dans le corps de la fonction générée, seuls les types des arguments peuvent être lus (pas les valeurs). La fonction renvoie une expression citée évaluée lorsque la fonction est appelée. Le macro @generated ne doit pas être utilisé sur des fonctions modifiant l'espace global ou dépendant d'éléments mutables.

Voir Metaprogramming pour plus de détails.

Exemples

julia> @generated function bar(x)
           if x <: Integer
               return :(x ^ 2)
           else
               return :(x)
           end
       end
bar (generic function with 1 method)

julia> bar(4)
16

julia> bar("baz")
"baz"

Base.@assume_effects réglage... [ex]

Surchargez la modélisation des effets du compilateur. Cette macro peut être utilisée dans plusieurs contextes :

1. Immédiatement avant une définition de méthode, pour remplacer la modélisation des effets de la méthode appliquée.
2. Dans le corps d'une fonction sans arguments, pour remplacer la modélisation des effets de la méthode englobante.
3. Appliquée à un bloc de code, pour remplacer la modélisation locale des effets du bloc de code appliqué.

Exemples

julia> Base.@assume_effects :terminates_locally function fact(x)
           # utilisation 1 :
           # ce :terminates_locally permet à `fact` d'être constant plié
           res = 1
           0 ≤ x < 20 || error("mauvais fact")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (generic function with 1 method)

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

julia> code_typed() do
           map((2,3,4)) do x
               # utilisation 2 :
               # ce :terminates_locally permet à cette fonction anonyme d'être constant pliée
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("mauvais fact")
               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("mauvais fact")
               # utilisation 3 :
               # avec cette annotation :terminates_locally, le compilateur évite de marquer
               # l'effet `:terminates` dans ce bloc `while`, permettant à la fonction
               # anonyme parente d'être constant pliée
               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}

En général, chaque valeur de réglage fait une assertion sur le comportement de la fonction, sans exiger que le compilateur prouve que ce comportement est effectivement vrai. Ces assertions sont faites pour tous les âges du monde. Il est donc conseillé de limiter l'utilisation de fonctions génériques qui pourraient être étendues ultérieurement pour invalider l'hypothèse (ce qui entraînerait un comportement indéfini).

Les réglages suivants sont pris en charge.

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

Aide étendue

:consistent

Le réglage :consistent affirme que pour des entrées égales (===) :

• La manière de terminaison (valeur de retour, exception, non-termination) sera toujours la même.
• Si la méthode retourne, les résultats seront toujours égaux.

:effect_free

Le réglage :effect_free affirme que la méthode est exempte d'effets secondaires sémantiquement visibles externes. La liste suivante est une liste incomplète d'effets secondaires sémantiquement visibles externes :

• Changer la valeur d'une variable globale.
• Muter le tas (par exemple, un tableau ou une valeur mutable), sauf comme noté ci-dessous.
• Changer la table des méthodes (par exemple, par des appels à eval).
• I/O de fichiers/réseau/etc.
• Changement de tâche.

Cependant, les éléments suivants ne sont explicitement pas visibles sémantiquement, même s'ils peuvent être observables :

• Allocations de mémoire (à la fois mutables et immuables).
• Temps écoulé.
• Collecte des ordures.
• Mutations du tas d'objets dont la durée de vie ne dépasse pas la méthode (c'est-à-dire qui ont été alloués dans la méthode et ne s'échappent pas).
• La valeur retournée (qui est visible de l'extérieur, mais pas un effet secondaire).

La règle générale ici est qu'un effet secondaire visible de l'extérieur est tout ce qui affecterait l'exécution du reste du programme si la fonction n'était pas exécutée.

:nothrow

Le réglage :nothrow affirme que cette méthode ne lance pas d'exception (c'est-à-dire qu'elle retournera toujours une valeur ou ne retournera jamais).

:terminates_globally

Le réglage :terminates_globally affirme que cette méthode se terminera éventuellement (soit normalement, soit anormalement), c'est-à-dire qu'elle ne boucle pas indéfiniment.

:terminates_locally

Le réglage :terminates_locally est comme :terminates_globally, sauf qu'il ne s'applique qu'au flux de contrôle syntaxique dans la méthode annotée. C'est donc une assertion beaucoup plus faible (et donc plus sûre) qui permet la possibilité de non-termination si la méthode appelle une autre méthode qui ne se termine pas.

:notaskstate

Le réglage :notaskstate affirme que la méthode n'utilise ni ne modifie l'état de tâche local (stockage local de tâche, état RNG, etc.) et peut donc être déplacée en toute sécurité entre les tâches sans résultats observables.

:inaccessiblememonly

Le réglage :inaccessiblememonly affirme que la méthode n'accède ni ne modifie la mémoire mutable accessible de l'extérieur. Cela signifie que la méthode peut accéder ou modifier la mémoire mutable pour des objets nouvellement alloués qui ne sont pas accessibles par d'autres méthodes ou exécutions de niveau supérieur avant le retour de la méthode, mais elle ne peut pas accéder ou modifier un état global mutable ou une mémoire mutable pointée par ses arguments.

:noub

Le réglage :noub affirme que la méthode n'exécutera aucun comportement indéfini (pour toute entrée). Notez que le comportement indéfini peut techniquement amener la méthode à violer d'autres assertions d'effet (telles que :consistent ou :effect_free), mais nous ne modélisons pas cela, et elles supposent l'absence de comportement indéfini.

:nortcall

Le réglage :nortcall affirme que la méthode n'appelle pas Core.Compiler.return_type, et que toutes les autres méthodes que cette méthode pourrait appeler n'appellent également pas Core.Compiler.return_type.

:foldable

Ce réglage est un raccourci pratique pour l'ensemble des effets que le compilateur exige pour garantir le pliage constant d'un appel à la compilation. Il est actuellement équivalent aux réglages suivants :

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

:removable

Ce réglage est un raccourci pratique pour l'ensemble des effets que le compilateur exige pour garantir la suppression d'un appel dont le résultat est inutilisé à la compilation. Il est actuellement équivalent aux réglages suivants :

• :effect_free
• :nothrow
• :terminates_globally

:total

Ce réglage est le maximum possible d'effets. Il implique actuellement les autres réglages suivants :

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

Effets niés

Les noms d'effet peuvent être préfixés par ! pour indiquer que l'effet doit être supprimé d'un effet méta précédent. Par exemple, :total !:nothrow indique que bien que l'appel soit généralement total, il peut cependant lancer.

@deprecate old new [export_old=true]

Déprécier la méthode old et spécifier l'appel de remplacement new, en définissant une nouvelle méthode old avec la signature spécifiée dans le processus.

Pour empêcher old d'être exporté, définissez export_old sur false.

Voir aussi Base.depwarn().

Exemples

julia> @deprecate old(x) new(x)
old (generic function with 1 method)

julia> @deprecate old(x) new(x) false
old (generic function with 1 method)

Les appels à @deprecate sans annotations de type explicites définiront des méthodes dépréciées acceptant n'importe quel nombre d'arguments positionnels et d'arguments de mot-clé de type Any.

Pour restreindre la dépréciation à une signature spécifique, annotez les arguments de old. Par exemple,

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

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

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

julia> methods(old)
# 1 method for generic function "old" from Main:
 [1] old(x::Int64)
     @ deprecated.jl:94

définira et dépréciera une méthode old(x::Int) qui reflète new(x::Int) mais ne définira ni ne dépréciera la méthode old(x::Float64).

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

Imprime msg comme un avertissement de dépréciation. Le symbole funcsym doit être le nom de la fonction appelante, qui est utilisé pour s'assurer que l'avertissement de dépréciation n'est imprimé qu'une seule fois pour chaque lieu d'appel. Définissez force=true pour forcer l'avertissement à toujours être affiché, même si Julia a été démarré avec --depwarn=no (par défaut).

Voir aussi @deprecate.

Exemples

function deprecated_func()
    Base.depwarn("N'utilisez pas `deprecated_func()` !", :deprecated_func)

    1 + 1
end

Missing

Un type sans champs dont l'instance unique missing est utilisée pour représenter des valeurs manquantes.

Voir aussi : skipmissing, nonmissingtype, Nothing.

missing

L'instance singleton de type Missing représentant une valeur manquante.

Voir aussi : NaN, skipmissing, nonmissingtype.

coalesce(x...)

Renvoie la première valeur dans les arguments qui n'est pas égale à missing, le cas échéant. Sinon, renvoie missing.

Voir aussi skipmissing, something, @coalesce.

Exemples

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # renvoie `nothing`

julia> coalesce(missing, missing)
missing

@coalesce(x...)

Version à court-circuit de coalesce.

Exemples

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

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` est toujours manquant")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` est toujours manquant")
f(2)
f(3)
ERROR: `b` est toujours manquant
[...]

ismissing(x)

Indique si x est missing.

Voir aussi : skipmissing, isnothing, isnan.

skipmissing(itr)

Renvoie un itérateur sur les éléments de itr en sautant les valeurs missing. L'objet retourné peut être indexé en utilisant les indices de itr si ce dernier est indexable. Les indices correspondant aux valeurs manquantes ne sont pas valides : ils sont ignorés par keys et eachindex, et une MissingException est levée lorsque vous essayez de les utiliser.

Utilisez collect pour obtenir un Array contenant les valeurs non-missing dans itr. Notez que même si itr est un tableau multidimensionnel, le résultat sera toujours un Vector car il n'est pas possible de supprimer les valeurs manquantes tout en préservant les dimensions de l'entrée.

Voir aussi coalesce, ismissing, something.

Exemples

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: la valeur à l'index (2,) est manquante
[...]

julia> argmax(x)
3

julia> collect(keys(x))
Vector{Int64} de 2 éléments:
 1
 3

julia> collect(skipmissing([1, missing, 2]))
Vector{Int64} de 2 éléments:
 1
 2

julia> collect(skipmissing([1 missing; 2 missing]))
Vector{Int64} de 2 éléments:
 1
 2

nonmissingtype(T::Type)

Si T est une union de types contenant Missing, renvoie un nouveau type avec Missing supprimé.

Exemples

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

julia> nonmissingtype(Any)
Any

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

Exécute un objet de commande, construit avec des backticks (voir la section Exécution de programmes externes dans le manuel). Lève une erreur si quelque chose ne va pas, y compris si le processus se termine avec un statut non nul (lorsque wait est vrai).

Les args... vous permettent de passer des descripteurs de fichiers à la commande, et sont ordonnés comme des descripteurs de fichiers unix réguliers (par exemple stdin, stdout, stderr, FD(3), FD(4)...).

Si wait est faux, le processus s'exécute de manière asynchrone. Vous pouvez ensuite attendre qu'il se termine et vérifier son statut de sortie en appelant success sur l'objet de processus retourné.

Lorsque wait est faux, les flux d'E/S du processus sont dirigés vers devnull. Lorsque wait est vrai, les flux d'E/S sont partagés avec le processus parent. Utilisez pipeline pour contrôler la redirection des E/S.

devnull

Utilisé dans une redirection de flux pour supprimer toutes les données qui y sont écrites. Essentiellement équivalent à /dev/null sur Unix ou NUL sur Windows. Utilisation :

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

success(command)

Exécute un objet de commande, construit avec des backticks (voir la section Exécution de programmes externes dans le manuel), et indique s'il a réussi (s'est terminé avec un code de 0). Une exception est levée si le processus ne peut pas être démarré.

process_running(p::Process)

Déterminez si un processus est actuellement en cours d'exécution.

process_exited(p::Process)

Déterminez si un processus a quitté.

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

Envoyer un signal à un processus. La valeur par défaut est de terminer le processus. Renvoie avec succès si le processus a déjà quitté, mais lance une erreur si la terminaison du processus a échoué pour d'autres raisons (par exemple, permissions insuffisantes).

Sys.set_process_title(title::AbstractString)

Définir le titre du processus. N'a aucun effet sur certains systèmes d'exploitation.

Sys.get_process_title()

Obtenez le titre du processus. Sur certains systèmes, cela renverra toujours une chaîne vide.

ignorestatus(command)

Marquer un objet de commande afin que son exécution ne génère pas d'erreur si le code de résultat est non nul.

detach(command)

Marque un objet de commande pour qu'il soit exécuté dans un nouveau groupe de processus, lui permettant de survivre au processus julia, et de ne pas recevoir les interruptions Ctrl-C.

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

Construit un nouvel objet Cmd, représentant un programme externe et des arguments, à partir de cmd, tout en modifiant les paramètres des arguments optionnels :

• ignorestatus::Bool : Si true (par défaut false), alors le Cmd ne lancera pas d'erreur si le code de retour est non nul.
• detach::Bool : Si true (par défaut false), alors le Cmd sera exécuté dans un nouveau groupe de processus, lui permettant de survivre au processus julia et de ne pas recevoir Ctrl-C.
• windows_verbatim::Bool : Si true (par défaut false), alors sous Windows, le Cmd enverra une chaîne de commande au processus sans citation ni échappement des arguments, même pour les arguments contenant des espaces. (Sous Windows, les arguments sont envoyés à un programme sous forme d'une seule chaîne "de ligne de commande", et les programmes sont responsables de son analyse en arguments. Par défaut, les arguments vides et les arguments contenant des espaces ou des tabulations sont cités avec des guillemets doubles " dans la ligne de commande, et \ ou " sont précédés de barres obliques inverses. windows_verbatim=true est utile pour lancer des programmes qui analysent leur ligne de commande de manière non standard.) N'a aucun effet sur les systèmes non-Windows.
• windows_hide::Bool : Si true (par défaut false), alors sous Windows, aucune nouvelle fenêtre de console n'est affichée lorsque le Cmd est exécuté. Cela n'a aucun effet si une console est déjà ouverte ou sur des systèmes non-Windows.
• env : Définit les variables d'environnement à utiliser lors de l'exécution du Cmd. env est soit un dictionnaire mappant des chaînes à des chaînes, un tableau de chaînes sous la forme "var=val", un tableau ou un tuple de paires "var"=>val. Pour modifier (plutôt que remplacer) l'environnement existant, initialisez env avec copy(ENV) puis définissez env["var"]=val selon vos besoins. Pour ajouter à un bloc d'environnement dans un objet Cmd sans remplacer tous les éléments, utilisez addenv() qui renverra un objet Cmd avec l'environnement mis à jour.
• dir::AbstractString : Spécifiez un répertoire de travail pour la commande (au lieu du répertoire actuel).

Pour tous les mots-clés qui ne sont pas spécifiés, les paramètres actuels de cmd sont utilisés.

Notez que le constructeur Cmd(exec) ne crée pas une copie de exec. Tout changement ultérieur de exec sera reflété dans l'objet Cmd.

La manière la plus courante de construire un objet Cmd est avec des littéraux de commande (backticks), par exemple :

`ls -l`

Cela peut ensuite être passé au constructeur Cmd pour modifier ses paramètres, par exemple :

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

setenv(command::Cmd, env; dir)

Définir des variables d'environnement à utiliser lors de l'exécution de la commande donnée. env est soit un dictionnaire mappant des chaînes à des chaînes, un tableau de chaînes de la forme "var=val", ou zéro ou plusieurs arguments de paire "var"=>val. Pour modifier (plutôt que de remplacer) l'environnement existant, créez env via copy(ENV) puis définissez env["var"]=val comme désiré, ou utilisez addenv.

L'argument clé dir peut être utilisé pour spécifier un répertoire de travail pour la commande. dir par défaut est le dir actuellement défini pour command (qui est le répertoire de travail actuel s'il n'est pas déjà spécifié).

Voir aussi Cmd, addenv, ENV, pwd.

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

Fusionne de nouvelles mappages d'environnement dans l'objet Cmd donné, retournant un nouvel objet Cmd. Les clés en double sont remplacées. Si command ne contient pas déjà de valeurs d'environnement, il hérite de l'environnement actuel au moment de l'appel de addenv() si inherit est true. Les clés avec la valeur nothing sont supprimées de l'environnement.

Voir aussi Cmd, setenv, ENV.

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

Exécutez f dans un environnement qui est temporairement modifié (et non remplacé comme dans setenv) par zéro ou plusieurs arguments "var"=>val kv. withenv est généralement utilisé via la syntaxe withenv(kv...) do ... end. Une valeur de nothing peut être utilisée pour désactiver temporairement une variable d'environnement (si elle est définie). Lorsque withenv retourne, l'environnement d'origine a été restauré.

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

Définissez l'affinité CPU de la command par une liste d'ID de CPU (basée sur 1) cpus. Passer cpus = nothing signifie désactiver l'affinité CPU si la original_command en a une.

Cette fonction est prise en charge uniquement sous Linux et Windows. Elle n'est pas prise en charge sous macOS car libuv ne prend pas en charge la définition de l'affinité.

Exemples

Sous Linux, le programme en ligne de commande taskset peut être utilisé pour voir comment setcpuaffinity fonctionne.

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

Notez que la valeur du masque 13 reflète que les premier, deuxième et cinquième bits (en comptant à partir de la position la moins significative) sont activés :

julia> 0b010011
0x13

pipeline(from, to, ...)

Créez un pipeline d'une source de données à une destination. La source et la destination peuvent être des commandes, des flux d'E/S, des chaînes de caractères ou des résultats d'autres appels à pipeline. Au moins un argument doit être une commande. Les chaînes de caractères font référence à des noms de fichiers. Lorsqu'il est appelé avec plus de deux arguments, ils sont enchaînés de gauche à droite. Par exemple, pipeline(a,b,c) est équivalent à pipeline(pipeline(a,b),c). Cela fournit un moyen plus concis de spécifier des pipelines à plusieurs étapes.

Exemples:

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

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

Redirige l'entrée/sortie vers ou depuis la commande donnée command. Les arguments clés spécifient quels flux de la commande doivent être redirigés. append contrôle si la sortie de fichier s'ajoute au fichier. C'est une version plus générale de la fonction pipeline à 2 arguments. pipeline(from, to) est équivalent à pipeline(from, stdout=to) lorsque from est une commande, et à pipeline(to, stdin=from) lorsque from est un autre type de source de données.

Exemples:

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

gethostname() -> String

Obtenez le nom d'hôte de la machine locale.

getpid() -> Int32

Obtenez l'ID de processus de Julia.

getpid(process) -> Int32

Obtenez l'ID du processus enfant, s'il existe encore.

time() -> Float64

Obtenez l'heure système en secondes depuis l'époque, avec une résolution assez élevée (typiquement, en microsecondes).

time_ns() -> UInt64

Obtenez le temps en nanosecondes. Le temps correspondant à 0 est indéfini et se répète tous les 5,8 ans.

@time expr
@time "description" expr

Une macro pour exécuter une expression, affichant le temps qu'il a fallu pour s'exécuter, le nombre d'allocations et le nombre total d'octets que son exécution a causé d'être alloués, avant de retourner la valeur de l'expression. Tout le temps passé à collecter les déchets (gc), à compiler du nouveau code ou à recompiler du code invalidé est affiché en pourcentage. Tout conflit de verrouillage où un ReentrantLock a dû attendre est affiché sous forme de compte.

Fournissez éventuellement une chaîne de description à imprimer avant le rapport de temps.

Dans certains cas, le système regardera à l'intérieur de l'expression @time et compilera une partie du code appelé avant que l'exécution de l'expression de niveau supérieur ne commence. Lorsque cela se produit, une partie du temps de compilation ne sera pas comptée. Pour inclure ce temps, vous pouvez exécuter @time @eval ....

Voir aussi @showtime, @timev, @timed, @elapsed, @allocated, et @allocations.

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 seconds (2.19 M allocations: 116.555 MiB, 3.75% gc time, 99.94% compilation time)

julia> @time x * x;
  0.000009 seconds (1 allocation: 896 bytes)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 seconds (8 allocations: 336 bytes)
2

julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 seconds (5 allocations: 144 bytes)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 seconds (5 allocations: 144 bytes)
2: 1.001263 seconds (5 allocations: 144 bytes)
3: 1.003676 seconds (5 allocations: 144 bytes)

@showtime expr

Comme @time mais imprime également l'expression évaluée pour référence.

Voir aussi @time.

julia> @showtime sleep(1)
sleep(1): 1.002164 secondes (4 allocations: 128 octets)

@timev expr
@timev "description" expr

Ceci est une version détaillée de la macro @time. Elle imprime d'abord les mêmes informations que @time, puis tout compteur d'allocation mémoire non nul, et retourne ensuite la valeur de l'expression.

Fournissez éventuellement une chaîne de description à imprimer avant le rapport de temps.

Voir aussi @time, @timed, @elapsed, @allocated, et @allocations.

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 seconds (2.20 M allocations: 116.632 MiB, 4.23% gc time, 99.94% compilation time)
elapsed time (ns): 546769547
gc time (ns):      23115606
bytes allocated:   122297811
pool allocs:       2197930
non-pool GC allocs:1327
malloc() calls:    36
realloc() calls:   5
GC pauses:         3

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1

@timed

Une macro pour exécuter une expression et retourner la valeur de l'expression, le temps écoulé en secondes, le total des octets alloués, le temps de collecte des ordures, un objet avec divers compteurs d'allocation mémoire, le temps de compilation en secondes et le temps de recompilation en secondes. Tout conflit de verrouillage où un ReentrantLock a dû attendre est affiché sous forme de compte.

Dans certains cas, le système examinera l'expression @timed et compilera une partie du code appelé avant que l'exécution de l'expression de niveau supérieur ne commence. Lorsque cela se produit, une partie du temps de compilation ne sera pas comptabilisée. Pour inclure ce temps, vous pouvez exécuter @timed @eval ....

Voir aussi @time, @timev, @elapsed, @allocated, @allocations et @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

Une macro pour évaluer une expression, en ignorant la valeur résultante, et en retournant plutôt le nombre de secondes qu'il a fallu pour s'exécuter sous forme de nombre à virgule flottante.

Dans certains cas, le système regardera à l'intérieur de l'expression @elapsed et compilera une partie du code appelé avant que l'exécution de l'expression de niveau supérieur ne commence. Lorsque cela se produit, un certain temps de compilation ne sera pas compté. Pour inclure ce temps, vous pouvez exécuter @elapsed @eval ....

Voir aussi @time, @timev, @timed, @allocated, et @allocations.

julia> @elapsed sleep(0.3)
0.301391426

@allocated

Une macro pour évaluer une expression, en ignorant la valeur résultante, et en retournant plutôt le nombre total d'octets alloués lors de l'évaluation de l'expression.

Voir aussi @allocations, @time, @timev, @timed, et @elapsed.

julia> @allocated rand(10^6)
8000080

@allocations

Une macro pour évaluer une expression, ignorer la valeur résultante et retourner plutôt le nombre total d'allocations pendant l'évaluation de l'expression.

Voir aussi @allocated, @time, @timev, @timed, et @elapsed.

julia> @allocations rand(10^6)
2

@lock_conflicts

Une macro pour évaluer une expression, ignorer la valeur résultante et retourner plutôt le nombre total de conflits de verrouillage pendant l'évaluation, où une tentative de verrouillage sur un ReentrantLock a entraîné une attente parce que le verrou était déjà détenu.

Voir aussi @time, @timev et @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

Un singleton de ce type fournit une interface de table de hachage aux variables d'environnement.

ENV

Référence au singleton EnvDict, fournissant une interface de dictionnaire pour les variables d'environnement système.

(Sous Windows, les variables d'environnement système ne tiennent pas compte de la casse, et ENV convertit donc toutes les clés en majuscules pour l'affichage, l'itération et la copie. Le code portable ne doit pas s'appuyer sur la capacité à distinguer les variables par leur casse, et doit être conscient que définir une variable apparemment en minuscules peut entraîner une clé ENV en majuscules.)

Exemples

julia> ENV
Base.EnvDict avec "50" entrées :
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "nom_utilisateur"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

Voir aussi : withenv, addenv.

Sys.STDLIB::String

Une chaîne contenant le chemin complet vers le répertoire contenant les packages stdlib.

Sys.isunix([os])

Prédicat pour tester si le système d'exploitation fournit une interface de type Unix. Voir la documentation dans Handling Operating System Variation.

Sys.isapple([os])

Prédicat pour tester si le système d'exploitation est un dérivé d'Apple Macintosh OS X ou de Darwin. Voir la documentation dans Handling Operating System Variation.

Sys.islinux([os])

Prédicat pour tester si le système d'exploitation est un dérivé de Linux. Voir la documentation dans Handling Operating System Variation.

Sys.isbsd([os])

Prédicat pour tester si le système d'exploitation est un dérivé de BSD. Voir la documentation dans Handling Operating System Variation.

Sys.isfreebsd([os])

Prédicat pour tester si le système d'exploitation est un dérivé de FreeBSD. Voir la documentation dans Handling Operating System Variation.

Sys.isopenbsd([os])

Prédicat pour tester si le système d'exploitation est un dérivé d'OpenBSD. Voir la documentation dans Handling Operating System Variation.

Sys.isnetbsd([os])

Prédicat pour tester si le système d'exploitation est un dérivé de NetBSD. Voir la documentation dans Handling Operating System Variation.

Sys.isdragonfly([os])

Prédicat pour tester si le système d'exploitation est un dérivé de DragonFly BSD. Voir la documentation dans Handling Operating System Variation.

Sys.iswindows([os])

Prédicat pour tester si le système d'exploitation est un dérivé de Microsoft Windows NT. Voir la documentation dans Handling Operating System Variation.

Sys.windows_version()

Renvoie le numéro de version pour le noyau Windows NT sous la forme d'un VersionNumber, c'est-à-dire v"major.minor.build", ou v"0.0.0" si cela ne fonctionne pas sous Windows.

Sys.free_memory()

Obtenez la mémoire totale libre dans la RAM en octets.

Sys.total_memory()

Obtenez la mémoire totale en RAM (y compris celle qui est actuellement utilisée) en octets. Ce montant peut être contraint, par exemple, par les groupes de contrôle Linux. Pour le montant non contraint, voir Sys.total_physical_memory().

Sys.free_physical_memory()

Obtenez la mémoire libre du système en octets. La totalité de la mémoire peut ne pas être disponible pour le processus actuel ; utilisez Sys.free_memory() pour le montant réellement disponible.

Sys.total_physical_memory()

Obtenez la mémoire totale en RAM (y compris celle qui est actuellement utilisée) en octets. La totalité de la mémoire peut ne pas être disponible pour le processus actuel ; voir Sys.total_memory().

Sys.uptime()

Obtient le temps de fonctionnement actuel du système en secondes.

Sys.isjsvm([os])

Prédicat pour tester si Julia s'exécute dans une machine virtuelle JavaScript (JSVM), y compris par exemple un embedding JavaScript WebAssembly dans un navigateur web.

Sys.loadavg()

Obtenez la moyenne de charge. Voir : https://en.wikipedia.org/wiki/Load_(computing).

isexecutable(path::String)

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

Voir aussi ispath, isreadable, iswritable.

isreadable(path::String)

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

Voir aussi ispath, isexecutable, iswritable.

isreadable(io) -> Bool

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

Exemples

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

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

julia> rm("myfile.txt")

iswritable(path::String)

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

Voir aussi ispath, isexecutable, isreadable.

iswritable(io) -> Bool

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

Exemples

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

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

julia> rm("myfile.txt")

Sys.username() -> String

Renvoie le nom d'utilisateur pour l'utilisateur actuel. Si le nom d'utilisateur ne peut pas être déterminé ou est vide, cette fonction génère une erreur.

Pour récupérer un nom d'utilisateur qui peut être remplacé via une variable d'environnement, par exemple, USER, envisagez d'utiliser

user = get(Sys.username, ENV, "USER")

Voir aussi homedir.

@static

Évalue partiellement une expression au moment de l'analyse.

Par exemple, @static Sys.iswindows() ? foo : bar évaluera Sys.iswindows() et insérera soit foo soit bar dans l'expression. Cela est utile dans les cas où une construction serait invalide sur d'autres plateformes, comme un ccall à une fonction inexistante. @static if Sys.isapple() foo end et @static foo <&&,||> bar sont également une syntaxe valide.

VersionNumber

Type de numéro de version qui suit les spécifications de versionnement sémantique (semver), composé de valeurs numériques majeures, mineures et de correctifs, suivies d'annotations alphanumériques de pré-version et de construction.

Les objets VersionNumber peuvent être comparés avec tous les opérateurs de comparaison standard (==, <, <=, etc.), le résultat suivant les règles de semver.

VersionNumber a les champs publics suivants :

• v.major::Integer
• v.minor::Integer
• v.patch::Integer
• v.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}
• v.build::Tuple{Vararg{Union{Integer, AbstractString}}}

Voir aussi @v_str pour construire efficacement des objets VersionNumber à partir de chaînes littérales au format semver, VERSION pour le VersionNumber de Julia lui-même, et Littéraux de Numéro de Version dans le manuel.

Exemples

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

Macro de chaîne utilisée pour analyser une chaîne en un VersionNumber.

Exemples

julia> v"1.2.3"
v"1.2.3"

julia> v"2.0.1-rc1"
v"2.0.1-rc1"

error(message::AbstractString)

Lève une ErrorException avec le message donné.

error(msg...)

Lève une ErrorException avec un message construit par string(msg...).

throw(e)

Lancer un objet en tant qu'exception.

Voir aussi : rethrow, error.

rethrow()

Relance l'exception actuelle depuis un bloc catch. L'exception relancée continuera sa propagation comme si elle n'avait pas été interceptée.

backtrace()

Obtenez un objet backtrace pour le point de programme actuel.

catch_backtrace()

Obtenez la trace de la pile de l'exception actuelle, à utiliser dans les blocs catch.

current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

Obtenez la pile des exceptions actuellement gérées. Pour les blocs catch imbriqués, il peut y avoir plus d'une exception actuelle, auquel cas l'exception lancée le plus récemment est la dernière dans la pile. La pile est renvoyée sous la forme d'un ExceptionStack, qui est un AbstractVector de tuples nommés (exception,backtrace). Si backtrace est faux, la trace de la pile dans chaque paire sera définie sur nothing.

Passer explicitement task renverra la pile d'exceptions actuelle sur une tâche arbitraire. Cela est utile pour inspecter les tâches qui ont échoué en raison d'exceptions non interceptées.

@assert cond [texte]

Lance une AssertionError si cond est false. C'est la syntaxe préférée pour écrire des assertions, qui sont des conditions supposées vraies, mais que l'utilisateur pourrait décider de vérifier de toute façon, comme aide au débogage en cas d'échec. Le message optionnel texte est affiché en cas d'échec de l'assertion.

Exemples

julia> @assert iseven(3) "3 est un nombre impair !"
ERROR: AssertionError: 3 est un nombre impair !

julia> @assert isodd(3) "Qu'est-ce qu'un nombre pair ?"

Experimental.register_error_hint(handler, exceptiontype)

Enregistrez une fonction de "sugestion" handler(io, exception) qui peut suggérer des moyens potentiels pour les utilisateurs de contourner les erreurs. handler doit examiner exception pour voir si les conditions appropriées pour une suggestion sont remplies, et si c'est le cas, générer une sortie vers io. Les packages doivent appeler register_error_hint depuis leur fonction __init__.

Pour des types d'exception spécifiques, handler doit accepter des arguments supplémentaires :

• MethodError : fournir handler(io, exc::MethodError, argtypes, kwargs), qui divise les arguments combinés en arguments positionnels et en arguments de mot-clé.

Lors de l'émission d'une suggestion, la sortie doit généralement commencer par \n.

Si vous définissez des types d'exception personnalisés, votre méthode showerror peut prendre en charge les suggestions en appelant Experimental.show_error_hints.

Exemples

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
                    # La couleur n'est pas nécessaire, c'est juste pour montrer que c'est possible.
                    print(io, "\nVouliez-vous appeler ")
                    printstyled(io, "`any_number`?", color=:cyan)
               end
           end
       end

       end

Alors si vous appelez Hinter.only_int sur quelque chose qui n'est pas un Int (déclenchant ainsi un MethodError), cela émet la suggestion :

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
La fonction `only_int` existe, mais aucune méthode n'est définie pour cette combinaison de types d'arguments.
Vouliez-vous appeler `any_number` ?
Les candidats les plus proches sont :
    ...

Experimental.show_error_hints(io, ex, args...)

Invoquez tous les gestionnaires de Experimental.register_error_hint pour le type d'exception particulier typeof(ex). args doit contenir tous les autres arguments attendus par le gestionnaire pour ce type.

ArgumentError(msg)

Les arguments passés à une fonction sont invalides. msg est un message d'erreur descriptif.

AssertionError([msg])

La condition affirmée n'a pas été évaluée à true. L'argument optionnel msg est une chaîne de caractères descriptive d'erreur.

Exemples

julia> @assert false "ceci n'est pas vrai"
ERROR: AssertionError: ceci n'est pas vrai

AssertionError est généralement lancé par @assert. ```

BoundsError([a],[i])

Une opération d'indexation dans un tableau, a, a tenté d'accéder à un élément hors limites à l'index i.

Exemples

julia> A = fill(1.0, 7);

julia> A[8]
ERREUR : BoundsError : tentative d'accès à un Vector{Float64} de 7 éléments à l'index [8]


julia> B = fill(1.0, (2,3));

julia> B[2, 4]
ERREUR : BoundsError : tentative d'accès à un Matrix{Float64} de 2×3 à l'index [2, 4]


julia> B[9]
ERREUR : BoundsError : tentative d'accès à un Matrix{Float64} de 2×3 à l'index [9]

CompositeException

Enveloppe un Vector d'exceptions levées par une Task (par exemple, générées par un travailleur distant via un canal ou une écriture I/O locale exécutée de manière asynchrone ou un travailleur distant sous pmap) avec des informations sur la série d'exceptions. Par exemple, si un groupe de travailleurs exécute plusieurs tâches, et que plusieurs travailleurs échouent, le CompositeException résultant contiendra un "paquet" d'informations de chaque travailleur indiquant où et pourquoi l(es) exception(s) s'est/sont produite(s).

DimensionMismatch([msg])

Les objets appelés n'ont pas de dimensions correspondantes. L'argument optionnel msg est une chaîne de caractères descriptive d'erreur.

DivideError()

Une division entière a été tentée avec une valeur de dénominateur de 0.

Exemples

julia> 2/0
Inf

julia> div(2, 0)
ERREUR: DivideError: erreur de division entière
Trace de la pile :
[...]

DomainError(val)
DomainError(val, msg)

L'argument val d'une fonction ou d'un constructeur est en dehors du domaine valide.

Exemples

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt a été appelé avec un argument réel négatif mais ne renverra un résultat complexe que s'il est appelé avec un argument complexe. Essayez sqrt(Complex(x)).
Stacktrace:
[...]

EOFError()

Aucune donnée supplémentaire n'était disponible à lire à partir d'un fichier ou d'un flux.

ErrorException(msg)

Type d'erreur générique. Le message d'erreur, dans le champ .msg, peut fournir des détails plus spécifiques.

Exemples

julia> ex = ErrorException("J'ai fait une mauvaise chose");

julia> ex.msg
"J'ai fait une mauvaise chose"

InexactError(name::Symbol, T, val)

Impossible de convertir exactement val en type T dans une méthode de la fonction name.

Exemples

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]

InterruptException()

Le processus a été arrêté par une interruption du terminal (CTRL+C).

Notez que, dans un script Julia démarré sans l'option -i (interactive), InterruptException n'est pas lancé par défaut. Appeler Base.exit_on_sigint(false) dans le script peut rétablir le comportement du REPL. Alternativement, un script Julia peut être démarré avec

julia -e "include(popfirst!(ARGS))" script.jl

pour permettre à InterruptException d'être lancé par CTRL+C pendant l'exécution.

KeyError(key)

Une opération d'indexation dans un AbstractDict (Dict) ou un objet de type Set a tenté d'accéder ou de supprimer un élément inexistant.

LoadError(file::AbstractString, line::Int, error)

Une erreur s'est produite lors de include, require ou using d'un fichier. Les détails de l'erreur devraient être disponibles dans le champ .error.

MethodError(f, args)

Un méthode avec la signature de type requise n'existe pas dans la fonction générique donnée. Alternativement, il n'y a pas de méthode la plus spécifique unique.

MissingException(msg)

Exception levée lorsqu'une valeur missing est rencontrée dans une situation où elle n'est pas supportée. Le message d'erreur, dans le champ msg, peut fournir des détails plus spécifiques.

OutOfMemoryError()

Une opération a alloué trop de mémoire pour que le système ou le ramasse-miettes puisse gérer correctement.

ReadOnlyMemoryError()

Une opération a tenté d'écrire dans une mémoire qui est en lecture seule.

OverflowError(msg)

Le résultat d'une expression est trop grand pour le type spécifié et provoquera un débordement.

ProcessFailedException

Indique un statut de sortie problématique d'un processus. Lors de l'exécution de commandes ou de pipelines, cela est lancé pour indiquer qu'un code de sortie non nul a été retourné (c'est-à-dire que le processus invoqué a échoué).

TaskFailedException

Cette exception est lancée par un appel à wait(t) lorsque la tâche t échoue. TaskFailedException enveloppe la tâche échouée t.

StackOverflowError()

L'appel de fonction a dépassé la taille de la pile d'appels. Cela se produit généralement lorsqu'un appel se récursive indéfiniment.

SystemError(prefix::AbstractString, [errno::Int32])

Un appel système a échoué avec un code d'erreur (dans la variable globale errno).

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

Une erreur d'assertion de type, ou l'appel d'une fonction intrinsèque avec un type d'argument incorrect.

UndefKeywordError(var::Symbol)

L'argument clé requis var n'a pas été assigné dans un appel de fonction.

Exemples

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
ERROR: UndefKeywordError: keyword argument `my_arg` not assigned
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] top-level scope at REPL[2]:1

UndefRefError()

L'élément ou le champ n'est pas défini pour l'objet donné.

Exemples

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: accès à une référence indéfinie
Stacktrace:
[...]

UndefVarError(var::Symbol, [scope])

Un symbole dans le scope actuel n'est pas défini.

Exemples

julia> a
ERROR: UndefVarError: `a` not defined in `Main`

julia> a = 1;

julia> a
1

StringIndexError(str, i)

Une erreur s'est produite lors de la tentative d'accès à str à l'index i qui n'est pas valide.

InitError(mod::Symbol, error)

Une erreur s'est produite lors de l'exécution de la fonction __init__ d'un module. L'erreur réelle levée est disponible dans le champ .error.

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

Renvoie une fonction anonyme qui appelle la fonction f. Si une exception se produit, f est appelée à nouveau, chaque fois que check renvoie true, après avoir attendu le nombre de secondes spécifié dans delays. check doit entrer l'état actuel de delays et l'Exception.