Les bases en

À propos de Les bases

Crystal est un langage de programmation compilé et orienté objet. Voici quelques-uns des objectifs du langage :

• Une syntaxe inspirée de Ruby.

• Un contrôle statique des types, sans avoir à préciser le type des variables ni des arguments de méthode.

• La possibilité d'appeler du code C grâce à des bindings écrits en Crystal.

• Une évaluation et une génération de code à la compilation, pour éviter d'écrire du code qui se répète.

• La compilation vers du code natif efficace.

Le développement de Crystal a débuté en 2011, avec pour objectif de créer un langage qui allie l'élégance et la productivité de Ruby aux performances et à la sûreté du typage d'un langage compilé. Le compilateur du langage a d'abord été écrit en Ruby, avant d'être réécrit en Crystal en 2013. Ary Borenszweig, Juan Wajnerman et Brian Cardiff ont conçu et développé le langage.

Pour commencer

Variables

Pour déclarer une variable, utilise l'opérateur d'affectation =. En Crystal, les variables s'écrivent en 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 leur nom s'écrit entièrement en majuscules, ce qu'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 à la compilation. Le compilateur est capable de 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 exigent de préciser un type seront expliqués dans les prochains concepts.

Méthodes

Les méthodes permettent de regrouper un ensemble d'instructions réutilisables. En Crystal, les méthodes sont souvent définies dans une classe, un module ou une structure. Toutefois, les méthodes peuvent aussi être définies 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 noms de 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 transmises à une méthode. Pour donner des arguments à une méthode, il faut préciser le nom de chaque argument. En Crystal, les arguments s'écrivent en snake_case. Une méthode peut prendre plusieurs arguments, mais ceux-ci doivent être séparés par une virgule.

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

Une méthode peut 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 (.). La syntaxe est la suivante : <ClassName>.<method_name>. Quand une méthode n'appartient pas à une classe, un module ou une structure, il suffit d'écrire son nom pour l'appeler. 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 les indiquer, aussi bien à l'appel qu'à la définition, comme ceci : <method_name>(<argument_1>, <argument_2>, ...). Quand une méthode ne prend aucun argument, il faut omettre les parenthèses.

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 indiqués dans le même ordre que dans la définition 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 l'opérateur * permet de 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