Le binaire, l'octal et l'hexadécimal (aussi appelé hex) sont différents systèmes de numération avec des bases différentes.
Le binaire est en base 2, l'octal en base 8, et l'hexadécimal en base 16.
En Crystal, les entiers ordinaires sont en base 10.
Le binaire, l'octal et l'hexadécimal sont tous des représentations d'entiers.
Cela signifie qu'ils représentent des nombres positifs et négatifs (y compris zéro) sans fractions ni nombres décimaux, et prennent en charge toutes les opérations que l'on peut effectuer avec des entiers.
Binaire
Le binaire est un système de numération en base 2, qui n'utilise que les chiffres 0 et 1.
Il représente couramment les états 0 (« éteint ») et 1 (« allumé ») du flux électrique à travers les transistors et les interrupteurs des ordinateurs, ainsi que les charges positives et négatives des supports de stockage magnétiques.
Le binaire peut représenter tous les entiers utilisés en base 10.
Un extrait du système en base 2 ressemble à ceci, même s'il continue à l'infini et ne s'arrête pas à 128 :
| 128 |
64 |
32 |
16 |
8 |
4 |
2 |
1 |
| 2 ** 7 |
2 ** 6 |
2 ** 5 |
2 ** 4 |
2 ** 3 |
2 ** 2 |
2 ** 1 |
2 ** 0 |
Ainsi, si l'on veut représenter le nombre 6, en binaire cela donne : 110
| Place value |
4 |
2 |
1 |
| Binary number |
1 |
1 |
0 |
Et l'opération serait : 4 + 2 + 0 = 6
Un autre exemple : 19
| Place value |
16 |
8 |
4 |
2 |
1 |
| Binary number |
1 |
0 |
0 |
1 |
1 |
Le nombre binaire serait : 10011
Et l'opération serait : 16 + 0 + 0 + 2 + 1 = 19
Le binaire en Crystal
En Crystal, on peut représenter des littéraux binaires à l'aide du préfixe 0b.
Si l'on écrit 0b10011, Crystal l'interprétera comme un nombre binaire et le convertira en base 10.
0b10011
# => 19
typeof(0b10011)
# => Int32
Si tu écris un nombre avec le préfixe 0b qui n'est pas dans le système binaire, cela provoquera une erreur de compilation.
0b10211
# => Error: unexpected token: "211"
Opérations avec les nombres binaires
Comme les nombres binaires sont des entiers, on peut leur appliquer toutes les opérations que l'on peut faire avec des entiers.
0b10011 + 0b10011
# => 38
0b10011 * 0b10011
# => 361
0b10011 / 3
# => 6.333333333333333
Conversion vers et depuis la représentation binaire
Crystal convertira automatiquement un littéral binaire en Int32.
Pour convertir un Int32 en représentation binaire, utilise la méthode <int>.to_s(base) avec l'argument base défini à 2.
La méthode renverra une représentation sous forme de string du nombre binaire :
19.to_s(2)
# => "10011"
Pour convertir une représentation binaire sous forme de string en entier, on peut utiliser la méthode <int>.to_i(base), en passant la base (2) en argument :
"10011".to_i(2)
# => 19
Donner une mauvaise base (ou une représentation binaire invalide) lèvera une ArgumentError :
"011021".to_i(2)
# => Invalid Int32: "011021" (ArgumentError)
Méthodes binaires
Certaines méthodes peuvent être utilisées sur les entiers pour obtenir des informations sur la représentation binaire du nombre.
<int>.bit_length renverra le nombre de bits nécessaires pour représenter le nombre :
19.bit_length
# => 5
<int>.bit(index) renverra le bit à l'indice donné, en partant de la droite (bit de poids faible) :
19.bit(0)
# => 1
0b10011.bit(1)
# => 1
Octal
L'octal est un système de numération en base 8.
Il utilise les chiffres 0, 1, 2, 3, 4, 5, 6 et 7.
En Crystal, on peut représenter des nombres octaux à l'aide du préfixe 0o.
Comme pour le binaire, Crystal convertit automatiquement une représentation octale en Int32.
0o123
# => 83
Préfixer un nombre avec 0o qui n'est pas dans le système octal provoquera une erreur de compilation.
Conversion vers et depuis la représentation octale
Comme pour le binaire, on peut utiliser la méthode <int>.to_s(base) pour convertir un Int32 en représentation octale.
Et on peut utiliser la méthode <int>.to_i(base) pour convertir une représentation octale en Int32.
83.to_s(8)
# => "123"
"123".to_i(8)
# => 83
Comme pour le binaire, donner une mauvaise base lèvera une ArgumentError.
Hexadécimal
L'hexadécimal est un système de numération en base 16.
Il utilise les chiffres 0 à 9 et les lettres A, B, C, D, E et F.
A vaut 10, B vaut 11, C vaut 12, D vaut 13, E vaut 14 et F vaut 15.
On peut représenter les nombres hexadécimaux en Crystal à l'aide du préfixe 0x.
Comme pour le binaire et l'octal, Crystal convertira automatiquement les littéraux hexadécimaux en Int32.
#=> 0x123
291
Préfixer un nombre non hexadécimal avec 0x provoquera une erreur de compilation.
Conversion vers et depuis la représentation hexadécimale
Comme pour le binaire, on peut utiliser la méthode <int>.to_s(base) pour convertir un Int32 en représentation hexadécimale.
Et on peut utiliser la méthode <int>.to_i(base) pour convertir une représentation hexadécimale en Int32.
291.to_s(16)
# => "123"
"123".to_i(16)
# => 291
Comme pour le binaire et l'octal, donner une mauvaise base lèvera une ArgumentError.
Précision
Lorsque l'on convertit un nombre en une représentation sous forme de string, on peut spécifier la précision du nombre.
Cela signifie le nombre minimum de chiffres utilisés pour représenter le nombre.
Si le nombre a moins de chiffres que la précision, des zéros seront ajoutés au début de la représentation sous forme de string.
Cela se fait en passant l'argument precision à la méthode <int>.to_s(<base>, precision: <value>).
291.to_s(16, precision: 5)
# => "00123"
543.to_s(precision: 2)
# => "543"
Exercice d'apprentissage
