Command-line Interface

Using arguments inside scripts

Al ejecutar un script usando julia, puedes pasar argumentos adicionales a tu script:

$ julia script.jl arg1 arg2...

Estos argumentos adicionales de la línea de comandos se pasan en la constante global ARGS. El nombre del script en sí se pasa como el global PROGRAM_FILE. Tenga en cuenta que ARGS también se establece cuando se proporciona una expresión de Julia utilizando la opción -e en la línea de comandos (vea la salida de ayuda de julia a continuación), pero PROGRAM_FILE estará vacío. Por ejemplo, para simplemente imprimir los argumentos dados a un script, podría hacer esto:

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

foo
bar

O podrías poner ese código en un script y ejecutarlo:

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

El delimitador -- se puede usar para separar los argumentos de línea de comandos destinados al archivo de script de los argumentos destinados a Julia:

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

Consulta también Scripting para más información sobre cómo escribir scripts en Julia.

The Main.main entry point

A partir de Julia 1.11, Base exporta el macro @main. Este macro se expande al símbolo main, pero al concluir la ejecución de un script o expresión, julia intentará ejecutar la función Main.main(ARGS) si tal función ha sido definida y este comportamiento fue optado al usar el macro @main.

Esta función está destinada a ayudar en la unificación de flujos de trabajo compilados e interactivos. En los flujos de trabajo compilados, cargar el código que define la función main puede estar separada espacial y temporalmente de la invocación. Sin embargo, para los flujos de trabajo interactivos, el comportamiento es equivalente a llamar explícitamente a exit(main(ARGS)) al final del script o expresión evaluada.

Para ver esta función en acción, considera la siguiente definición, que ejecutará la función print a pesar de no haber una llamada explícita a main:

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

Solo el enlace main en el módulo Main tiene este comportamiento y solo si se utilizó el macro @main dentro del módulo definitorio.

Por ejemplo, usar hello en lugar de main no resultará en la ejecución de la función hello:

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

y tampoco lo hará una definición simple de main:

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

Sin embargo, la opción de participar no necesita ocurrir en el momento de la definición:

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

El enlace main puede ser importado de un paquete. Un paquete de hola mundo definido como

module Hello

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

end

puede ser utilizado como:

$ 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
$

Sin embargo, ten en cuenta que la recomendación actual de mejores prácticas es no mezclar el código de la aplicación y el código de la biblioteca reutilizable en el mismo paquete. Las aplicaciones auxiliares pueden distribuirse como paquetes separados o como scripts con puntos de entrada main separados en la carpeta bin de un paquete.

Parallel mode

Julia se puede iniciar en modo paralelo con las opciones -p o --machine-file. -p n lanzará n procesos de trabajo adicionales, mientras que --machine-file file lanzará un trabajador por cada línea en el archivo file. Las máquinas definidas en file deben ser accesibles a través de un inicio de sesión ssh sin contraseña, con Julia instalada en la misma ubicación que el host actual. Cada definición de máquina tiene la forma [count*][user@]host[:port] [bind_addr[:port]]. user se establece de forma predeterminada en el usuario actual, port en el puerto estándar de ssh. count es el número de trabajadores que se generarán en el nodo y se establece de forma predeterminada en 1. La opción bind-to bind_addr[:port] especifica la dirección IP y el puerto que otros trabajadores deben usar para conectarse a este trabajador.

Startup file

Si tienes código que deseas ejecutar cada vez que se ejecute Julia, puedes colocarlo en ~/.julia/config/startup.jl:

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

...

Tenga en cuenta que, aunque debería tener un directorio ~/.julia una vez que haya ejecutado Julia por primera vez, es posible que deba crear la carpeta ~/.julia/config y el archivo ~/.julia/config/startup.jl si lo utiliza.

Para que el código de inicio se ejecute solo en The Julia REPL (y no cuando julia se ejecuta por ejemplo en un script), usa atreplinit en startup.jl:

atreplinit() do repl
    # ...
end

Command-line switches for Julia

Hay varias formas de ejecutar código Julia y proporcionar opciones, similares a las disponibles para los programas perl y ruby:

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

La siguiente es una lista completa de los interruptores de línea de comandos disponibles al iniciar julia (un '*' marca el valor predeterminado, si corresponde; los ajustes marcados '($)' pueden activar la precompilación de paquetes):