Les bases en

À propos de Les bases

Julia est un langage de programmation dynamique et fortement typé. Son style de programmation est essentiellement fonctionnel, même s'il offre plus de souplesse que des langages comme Haskell.

Julia dispose d'un système de types puissant et polyvalent, qui prendra de l'importance dans les concepts suivants. En pratique, Julia déduit le plus souvent un type par défaut adapté au contexte.

Malgré l'accent mis sur la lisibilité, qui lui donne l'apparence d'un langage de script comme Python ou Ruby, le code Julia est compilé avant d'être exécuté. Le compilateur Just In Time (JIT) produit du code hautement optimisé pour chaque fonction au moment où elle est rencontrée, ce qui donne une grande vitesse d'exécution.

Julia n'est pas un langage orienté objet, et il n'a pas de hiérarchie de classes comme celle qui est au cœur de nombreux autres langages.

À la place (et surtout, ne panique pas en lisant ça !), Julia s'appuie sur :

• Une hiérarchie de types.
• Des fonctions composables (conçues pour se combiner facilement, de manière polyvalente et puissante).
• Le dispatch multiple, c'est-à-dire que l'on peut appeler les fonctions avec un nombre et des types d'arguments variables.

Ces termes un peu déroutants deviendront plus clairs au fil du programme.

La documentation officielle contient beaucoup d'informations précieuses pour la version actuelle, même si elle peut sembler un peu intimidante pour les débutants.

• Manuel
• Tutoriels
• Bien démarrer avec Julia
• Notes pour les programmeurs Python
• Notes pour les programmeurs R
• Notes pour les programmeurs C/C++
• Notes pour les programmeurs Matlab (c'est un langage propriétaire, très populaire chez les ingénieurs et l'une des inspirations de Julia)

Parmi les vidéos :

• Une brève introduction à Julia de la part de la direction d'Exercism !
• Une introduction en douceur à Julia
• Apprendre Julia avec nous : une série en 4 parties

Commentaires

Ajouter des commentaires à son code est extrêmement important pour aider les humains à lire le code et à comprendre tes intentions : peut-être d'autres personnes, mais aussi le toi du futur. Ils sont (en grande partie) ignorés par le compilateur.

Julia propose deux options :

• Les commentaires sur une seule ligne commencent par #
• Les commentaires sur plusieurs lignes commencent par #= et se terminent par =#. L'imbrication est autorisée.

# This is a single-line comment

x = 3  # This is an inline comment

#=
	Multi-line comments can be used for longer explanations.

	They are especially useful to comment out blocks of code during debugging.
=#

Variables et affectation

Pour créer une variable, il suffit de lui affecter une valeur :

julia> myvar = 42  # an integer (in fact, Int64)
42

julia> bigint = 1_234_567_890  # optionally use underscore as digit separator, for readability
1234567890

julia> name = "Maria"  # strings are surrounded by double-quotes ""
"Maria"

L'affectation « lie » une valeur à la variable.

Préciser un type est facultatif, et dans la plupart des cas Julia déduit un type par défaut adapté au contexte.

Les types sont un sujet important en Julia. On les explorera plus en détail dans les concepts suivants. Pour l'instant, mieux vaut ne pas s'en préoccuper.

Contrairement à beaucoup de langages fonctionnels, les variables en Julia peuvent être réaffectées, et tu es libre de changer à la fois la valeur et le type liés à la variable :

julia> myvar = 3
3

julia> myvar = "now a string"
"now a string"

Constantes

Les variables globales, créées en dehors de toute fonction, sont :

• Autorisées.
• Parfois nécessaires.
• Généralement déconseillées (mais seulement dans les fichiers *.jl ; le REPL fonctionne différemment).

Si une valeur doit être disponible dans tout le programme sans être censée changer, utilise plutôt une constante.

Faire précéder l'affectation du mot-clé const permet au compilateur de générer du code plus efficace.

Si tu essaies de modifier accidentellement la valeur const, tu obtiendras un avertissement :

julia> const answer = 42
42

julia> answer = 24
WARNING: redefinition of constant Main.answer. This may fail, cause incorrect answers, or produce other errors.
24

Opérateurs arithmétiques

L'arithmétique fonctionne en grande partie de manière classique :

2 + 3  # 5 (addition)
2 - 3  # -1 (subtraction)
2 * 3  # 6 (multiplication)
8 / 2  # 4.0 (division)
8 % 3  # 2 (remainder)
2 ^ 3  # 8 (exponentiation)

À noter que la division avec / donne toujours un nombre à virgule flottante.

On y reviendra dans les concepts suivants, qui aborderont la division entière avec div() ou ÷ pour tronquer, et // pour obtenir un nombre rationnel.

Fonctions

Pour de meilleures performances à l'exécution, mieux vaut placer la majeure partie du code dans des fonctions. Avoir beaucoup de petites fonctions n'est pas un problème, contrairement à certains autres langages.

Il y a deux façons courantes de définir une fonction nommée en Julia :

1. En utilisant le mot-clé function

   function muladd(x, y, z)
       x * y + z
   end
   

   L'indentation de 4 espaces est la convention pour la lisibilité, mais le compilateur l'ignore. Le mot-clé end est indispensable : plus proche de Ruby que de Python.

   À noter qu'on aurait pu écrire return x * y + z. Cependant, les fonctions Julia renvoient toujours la dernière expression évaluée, donc le mot-clé return est facultatif. Beaucoup de programmeurs préfèrent l'inclure pour rendre leurs intentions plus explicites.

2. En utilisant la « forme d'affectation »

   muladd(x, y, z) = x * y + z
   

   On l'utilise le plus souvent pour des définitions de fonction sur une seule ligne ou pour des fonctions mathématiques, dont le corps tient en une seule expression. Le mot-clé return n'est jamais utilisé avec la forme d'affectation.

Les deux formes sont équivalentes et s'utilisent exactement de la même manière : choisis celle qui te semble la plus lisible.

Pour appeler une fonction, on précise son nom et on passe un argument pour chacun de ses paramètres :

# invoking a function
muladd(10, 5, 1)

# and of course you can invoke a function within the body of another function:
square_plus_one(x) = muladd(x, x, 1)

Du fait qu'on parle de fonctions « nommées », tu devines peut-être qu'il existe aussi des fonctions « anonymes ». Elles seront abordées dans un concept ultérieur.

Conventions de nommage

Comme beaucoup de langages, Julia impose que les noms (de variables, de fonctions et de bien d'autres choses) commencent par une lettre, suivie d'une combinaison quelconque de lettres, de chiffres et de tirets bas.

Par convention, les noms de variables, de constantes et de fonctions s'écrivent en minuscules, et on évite les tirets bas sauf quand ils sont nécessaires pour éviter une confusion.

Cependant, Julia utilise Unicode partout, donc le terme « lettre » s'interprète de façon très souple.

Les langues autres que l'anglais sont prises en charge, tout comme les emojis (mais fais preuve de bon goût et choisis quelque chose d'approprié).

En particulier, toutes les lettres grecques chères aux mathématiciens sont disponibles (et plusieurs valeurs utiles sont prédéfinies) :

julia> π   # a built-in constant
π = 3.1415926535897...

Les éditeurs qui connaissent Julia, notamment le REPL, Pluto.jl et VS Code avec le plugin Julia, facilitent la saisie de ces caractères.

Pour π, tape \pi puis appuie sur <Tab>. Ce que tu as tapé est remplacé par la lettre grecque.

Tu verras bien d'autres exemples de ce genre dans les concepts suivants.

En fait, ces abréviations avec une barre oblique inverse ne sont pas propres à Julia. Elles viennent de LaTeX, un système de composition typographique que de nombreux scientifiques et ingénieurs utilisent presque quotidiennement pour rédiger des rapports.