Les lasagnes incroyables d'Ary

Pour commencer

Variables

Pour déclarer une variable, utilise l'opérateur d'affectation =. En Crystal, les variables doivent utiliser le format snake_case.

number = 1
puts number # => 1

number = 2
puts number # => 2

Constantes

Les constantes se déclarent avec le même opérateur d'affectation =, mais s'écrivent entièrement en majuscules, ce que l'on appelle le SCREAMING_SNAKE_CASE.

NUMBER = 1
puts NUMBER # => 1

Affecter une valeur à une constante déjà définie provoque une erreur à la compilation.

NUMBER = 1

NUMBER = 2
# Error: already initialized constant NUMBER

Types

Crystal est un langage compilé, ce qui signifie que chaque variable ou argument de méthode se voit attribuer un type au moment de la compilation. Le compilateur sait déduire le type d'une variable ou d'un argument de méthode. Cependant, dans certains cas, il est nécessaire de préciser le type. Les cas qui nécessitent de préciser un type seront expliqués dans les prochains concepts.

Méthodes

Les méthodes permettent de regrouper un ensemble d'instructions qui peuvent être réutilisées. En Crystal, les méthodes sont souvent définies dans une classe, un module ou une structure. Cependant, on peut aussi définir des méthodes en dehors d'une classe, d'un module ou d'une structure. Les méthodes se déclarent avec le mot-clé def, suivi du nom de la méthode. En Crystal, les méthodes s'écrivent en snake_case. On peut omettre les parenthèses quand une méthode ne prend aucun argument. Pour marquer la fin d'une méthode, il faut utiliser le mot-clé end.

def hello
  puts "Hello World!"
end

Utiliser une méthode qui n'existe pas pour le type d'une variable ou d'un argument de méthode provoque une erreur à la compilation.

number = 1
number + "1"
# Error: no overload matches 'Int32#+' with type String

Arguments

Les méthodes peuvent prendre des arguments. Les arguments sont les données que l'on passe à une méthode. Pour donner des arguments à une méthode, il faut préciser le nom de l'argument. En Crystal, les arguments s'écrivent en snake_case. Une méthode peut prendre plusieurs arguments, mais ils doivent être séparés par une virgule.

def hello(name)
  puts "Hello #{name}!"
end

Les méthodes peuvent aussi prendre plusieurs arguments. Dans ce cas, les arguments doivent être séparés par une virgule.

def hello(name, language)
  puts "Hello #{name}! You are learning #{language}."
end

Appelle des méthodes

Quand on appelle une méthode qui appartient à une classe, un module ou une structure, il faut utiliser l'opérateur point (.). Le format est le suivant : <ClassName>.<method_name>. Quand une méthode n'appartient pas à une classe, à un module ou à une structure, on peut simplement l'appeler en écrivant son nom. Les méthodes renvoient toujours implicitement la valeur de la dernière expression.

Quand une méthode prend des arguments, on peut utiliser des parenthèses pour préciser les arguments lors de l'appel et de la définition de la méthode, comme ceci : <method_name>(<argument_1>, <argument_2>, ...). Quand une méthode ne prend aucun argument, les parenthèses doivent être omises.

def hello(name)
  "Hello #{name}!"
end

hello("Crystal")
# => Hello Crystal!

Quand on appelle une méthode avec plusieurs arguments, ceux-ci doivent être séparés par une virgule. Les arguments doivent être donnés dans le même ordre que les arguments de la méthode.

def hello_language(name, language)
  "Hello #{name}! You are learning #{language}."
end

hello_language("World", "Crystal")
# => Hello World! You are learning Crystal.

Appeler une méthode avec un nombre incorrect d'arguments provoque une erreur à la compilation.

hello_language("Crystal")
# wrong number of arguments for 'hello_language' (given 1, expected 2)

Addition, soustraction et multiplication

En Crystal, on peut utiliser l'opérateur + pour additionner deux nombres. On peut aussi utiliser l'opérateur - pour soustraire deux nombres. Et on peut utiliser l'opérateur * pour multiplier deux nombres.

1 + 1
# => 2

2 - 1
# => 1

2 * 2
# => 4

Commentaires

En Crystal, les commentaires s'écrivent avec le caractère #, suivi d'un espace puis du commentaire. Les commentaires servent à documenter le code. Le compilateur n'exécute pas les commentaires.

# This is a comment