Command-line Interface

Using arguments inside scripts

Lorsque vous exécutez un script en utilisant julia, vous pouvez passer des arguments supplémentaires à votre script :

$ julia script.jl arg1 arg2...

Ces arguments supplémentaires de ligne de commande sont passés dans la constante globale ARGS. Le nom du script lui-même est passé en tant que PROGRAM_FILE global. Notez que ARGS est également défini lorsqu'une expression Julia est donnée en utilisant l'option -e sur la ligne de commande (voir la sortie d'aide de julia ci-dessous), mais PROGRAM_FILE sera vide. Par exemple, pour simplement imprimer les arguments donnés à un script, vous pourriez faire ceci :

$ julia -e 'println(PROGRAM_FILE); for x in ARGS; println(x); end' foo bar

foo
bar

Ou vous pourriez mettre ce code dans un script et l'exécuter :

$ echo 'println(PROGRAM_FILE); for x in ARGS; println(x); end' > script.jl
$ julia script.jl foo bar
script.jl
foo
bar

Le délimiteur -- peut être utilisé pour séparer les arguments de ligne de commande destinés au fichier de script des arguments destinés à Julia :

$ julia --color=yes -O -- script.jl arg1 arg2..

Voir aussi Scripting pour plus d'informations sur l'écriture de scripts Julia.

The Main.main entry point

À partir de Julia 1.11, Base exporte le macro @main. Ce macro s'étend au symbole main, mais à la fin de l'exécution d'un script ou d'une expression, julia tentera d'exécuter la fonction Main.main(ARGS) si une telle fonction a été définie et que ce comportement a été choisi en utilisant le macro @main.

Cette fonctionnalité est destinée à aider à l'unification des flux de travail compilés et interactifs. Dans les flux de travail compilés, le chargement du code qui définit la fonction main peut être spatialement et temporellement séparé de l'invocation. Cependant, pour les flux de travail interactifs, le comportement est équivalent à un appel explicite de exit(main(ARGS)) à la fin du script ou de l'expression évaluée.

Pour voir cette fonctionnalité en action, considérez la définition suivante, qui exécutera la fonction print malgré l'absence d'appel explicite à main :

$ julia -e '(@main)(args) = println("Hello World!")'
Hello World!
$

Seul le binding main dans le module Main a ce comportement et uniquement si le macro @main a été utilisé dans le module définissant.

Par exemple, utiliser hello au lieu de main ne fera pas exécuter la fonction hello :

$ julia -e 'hello(ARGS) = println("Hello World!")'
$

et une définition simple de main ne le fera pas non plus :

$ julia -e 'main(ARGS) = println("Hello World!")'
$

Cependant, l'opt-in n'a pas besoin de se produire au moment de la définition :

$ julia -e 'main(ARGS) = println("Hello World!"); @main'
Hello World!
$

Le lien main peut être importé d'un paquet. Un paquet hello world défini comme

module Hello

export main
(@main)(args) = println("Hello from the package!")

end

peut être utilisé comme :

$ julia -e 'using Hello'
Hello from the package!
$ julia -e 'import Hello' # N.B.: Execution depends on the binding not whether the package is loaded
$

Cependant, notez que la recommandation actuelle des meilleures pratiques est de ne pas mélanger le code d'application et le code de bibliothèque réutilisable dans le même package. Les applications d'aide peuvent être distribuées sous forme de packages séparés ou en tant que scripts avec des points d'entrée main séparés dans le dossier bin d'un package.

Parallel mode

Julia peut être démarré en mode parallèle avec les options -p ou --machine-file. -p n lancera n processus de travail supplémentaires, tandis que --machine-file file lancera un travailleur pour chaque ligne dans le fichier file. Les machines définies dans file doivent être accessibles via une connexion ssh sans mot de passe, avec Julia installé au même emplacement que l'hôte actuel. Chaque définition de machine prend la forme [count*][user@]host[:port] [bind_addr[:port]]. user par défaut est l'utilisateur actuel, port au port ssh standard. count est le nombre de travailleurs à créer sur le nœud, et par défaut à 1. L'optionnelle bind-to bind_addr[:port] spécifie l'adresse IP et le port que les autres travailleurs doivent utiliser pour se connecter à ce travailleur.

Startup file

Si vous avez du code que vous souhaitez exécuter chaque fois que Julia est lancé, vous pouvez le placer dans ~/.julia/config/startup.jl :

$ echo 'println("Greetings! 你好! 안녕하세요?")' > ~/.julia/config/startup.jl
$ julia
Greetings! 你好! 안녕하세요?

...

Notez que bien que vous deviez avoir un répertoire ~/.julia une fois que vous avez exécuté Julia pour la première fois, vous devrez peut-être créer le dossier ~/.julia/config et le fichier ~/.julia/config/startup.jl si vous l'utilisez.

Pour que le code de démarrage s'exécute uniquement dans The Julia REPL (et pas lorsque julia est par exemple exécuté sur un script), utilisez atreplinit dans startup.jl :

atreplinit() do repl
    # ...
end

Command-line switches for Julia

Il existe plusieurs façons d'exécuter du code Julia et de fournir des options, similaires à celles disponibles pour les programmes perl et ruby :

julia [switches] -- [programfile] [args...]

La liste suivante est une liste complète des options de ligne de commande disponibles lors du lancement de julia (un '*' marque la valeur par défaut, si applicable ; les paramètres marqués '($)' peuvent déclencher la précompilation des paquets) :