# Chapitre 1 : L'Encodage ASCII
## Introduction
Dans le monde numérique, tout est représenté par des nombres. Que ce soit une image, un son, une vidéo ou du texte, l'ordinateur ne manipule que des séquences de bits. Pour que les ordinateurs puissent traiter et afficher du texte compréhensible par les humains, il est nécessaire d'établir un système de correspondance entre les caractères que nous utilisons (lettres, chiffres, symboles) et des valeurs numériques. C'est le rôle de l'encodage de caractères.
Ce chapitre se concentre sur **ASCII** (American Standard Code for Information Interchange), qui fut l'un des premiers et le plus influent de ces systèmes. Comprendre ASCII est fondamental car il a jeté les bases de la représentation textuelle dans l'informatique moderne et influence encore de nombreux aspects de la programmation et des protocoles réseau.
> [!note] Pré-requis
> Une bonne compréhension des [[Systèmes de numération]] (binaire, décimal, hexadécimal) est essentielle pour appréhender ce chapitre. Nous allons manipuler des nombres qui représentent des caractères, et savoir passer d'une base à l'autre facilitera grandement votre compréhension.
## 1. Qu'est-ce que l'ASCII ?
> [!definition] Définition : ASCII
> **ASCII** (prononcé "ask-ii") est un standard d'encodage de caractères qui a été publié pour la première fois en 1963. Il définit une correspondance entre 128 caractères communs (lettres latines, chiffres arabes, symboles de ponctuation et caractères de contrôle) et des entiers sur 7 bits, allant de 0 à 127.
L'objectif principal d'ASCII était de standardiser la manière dont les ordinateurs et les périphériques (comme les téléimprimeurs et les imprimantes) échangeaient des informations textuelles. Avant ASCII, chaque fabricant avait souvent sa propre méthode d'encodage, ce qui rendait l'interopérabilité difficile.
Chaque caractère ASCII est donc représenté par un nombre unique. Par exemple, la lettre 'A' majuscule est associée à la valeur décimale 65, tandis que la lettre 'a' minuscule est associée à 97. Cette distinction entre majuscules et minuscules est une caractéristique clé.
> [!example] Représentation Numérique
> Le caractère 'A' est représenté par la valeur décimale 65.
> En binaire (sur 7 bits), cela donne $65_{10} = 01000001_2$.
> En hexadécimal, cela donne $65_{10} = 41_{16}$.
## 2. La Table ASCII : Structure et Caractères
La table ASCII est divisée en plusieurs catégories de caractères, chacune ayant une plage de valeurs numériques spécifique. Étant donné qu'ASCII utilise 7 bits, il peut représenter $2^7 = 128$ caractères différents, numérotés de 0 à 127.
### 2.1. Les Caractères de Contrôle (0-31 et 127)
Ces caractères ne sont pas destinés à être affichés à l'écran. Ils étaient historiquement utilisés pour contrôler des périphériques comme les téléimprimeurs, les modems ou pour organiser la structure du texte.
> [!note] Historique des Caractères de Contrôle
> Beaucoup de ces caractères proviennent des besoins des téléimprimeurs de l'époque. Par exemple, `CR` (Carriage Return) faisait revenir le chariot au début de la ligne, et `LF` (Line Feed) faisait avancer le papier d'une ligne.
Voici quelques exemples notables :
* **NUL (Null)** : Valeur 0. Utilisé pour indiquer la fin d'une chaîne de caractères dans certains langages (comme le C).
* **BEL (Bell)** : Valeur 7. Fait sonner une cloche ou émet un bip sonore.
* **BS (Backspace)** : Valeur 8. Déplace le curseur d'un caractère vers l'arrière.
* **HT (Horizontal Tab)** : Valeur 9. Insère une tabulation horizontale.
* **LF (Line Feed)** : Valeur 10. Avance le curseur d'une ligne sans le ramener au début (saut de ligne).
* **CR (Carriage Return)** : Valeur 13. Ramène le curseur au début de la ligne sans avancer d'une ligne.
* **ESC (Escape)** : Valeur 27. Utilisé pour introduire des séquences d'échappement pour des commandes spéciales.
* **DEL (Delete)** : Valeur 127. Historiquement utilisé pour effacer le caractère précédent ou marquer des caractères à ignorer.
### 2.2. Les Caractères Imprimables (32-126)
Ce sont les caractères que nous voyons et utilisons quotidiennement.
* **Espace (Space)** : Valeur 32. C'est le premier caractère imprimable.
* **Ponctuation et Symboles** : Valeurs 33-47, 58-64, 91-96, 123-126. Incluent `!`, `"`, `#`, `
, `%`, `&`, `'`, `(`, `)`, `*`, `+`, `,`, `-`, `.`, `/`, `:`, `;`, `<`, `=`, `>`, `?`, `@`, `[`, `\`, `]`, `^`, `_`, `` ` ``, `{`, `|`, `}`, `~`.
* **Chiffres (0-9)** : Valeurs 48-57.
* `'0'` correspond à 48.
* `'1'` correspond à 49.
* ...
* `'9'` correspond à 57.
* > [!tip] Astuce
> Pour convertir un chiffre ASCII en sa valeur numérique, il suffit de soustraire la valeur ASCII de `'0'` (48). Par exemple, le caractère `'5'` a la valeur 53. $53 - 48 = 5$.
* **Lettres Majuscules (A-Z)** : Valeurs 65-90.
* `'A'` correspond à 65.
* `'B'` correspond à 66.
* ...
* `'Z'` correspond à 90.
* **Lettres Minuscules (a-z)** : Valeurs 97-122.
* `'a'` correspond à 97.
* `'b'` correspond à 98.
* ...
* `'z'` correspond à 122.
> [!note] Relation Majuscules/Minuscules
> Il est intéressant de noter la relation entre les lettres majuscules et minuscules. La valeur ASCII d'une lettre minuscule est toujours supérieure de 32 à celle de sa majuscule correspondante.
> Par exemple, `'A'` est 65 et `'a'` est 97. $97 - 65 = 32$.
> En binaire, cela correspond à la différence sur le 6ème bit (en partant de la droite, le bit de poids 32).
> `'A'` : $01000001_2$
> `'a'` : $01100001_2$
> Ce décalage est souvent exploité en programmation pour convertir rapidement la casse d'un caractère.
### 2.3. Table ASCII (extrait)
Voici un extrait de la table ASCII pour illustrer les correspondances :
| Décimal | Hexadécimal | Binaire (7 bits) | Caractère | Description |
| :------ | :---------- | :--------------- | :-------- | :---------------------- |
| 0 | 0x00 | 0000000 | NUL | Null |
| 7 | 0x07 | 0000111 | BEL | Bell (Bip) |
| 8 | 0x08 | 0001000 | BS | Backspace |
| 9 | 0x09 | 0001001 | HT | Horizontal Tab |
| 10 | 0x0A | 0001010 | LF | Line Feed |
| 13 | 0x0D | 0001101 | CR | Carriage Return |
| ... | ... | ... | ... | |
| 32 | 0x20 | 0100000 | (Space) | Espace |
| 33 | 0x21 | 0100001 | ! | Point d'exclamation |
| 34 | 0x22 | 0100010 | " | Guillemet |
| ... | ... | ... | ... | |
| 48 | 0x30 | 0110000 | 0 | Chiffre zéro |
| 49 | 0x31 | 0110001 | 1 | Chiffre un |
| ... | ... | ... | ... | |
| 57 | 0x39 | 0111001 | 9 | Chiffre neuf |
| ... | ... | ... | ... | |
| 65 | 0x41 | 1000001 | A | Lettre A majuscule |
| 66 | 0x42 | 1000010 | B | Lettre B majuscule |
| ... | ... | ... | ... | |
| 90 | 0x5A | 1011010 | Z | Lettre Z majuscule |
| ... | ... | ... | ... | |
| 97 | 0x61 | 1100001 | a | Lettre a minuscule |
| 98 | 0x62 | 1100010 | b | Lettre b minuscule |
| ... | ... | ... | ... | |
| 122 | 0x7A | 1111010 | z | Lettre z minuscule |
| ... | ... | ... | ... | |
| 127 | 0x7F | 1111111 | DEL | Delete |
## 3. Fonctionnement de l'Encodage et du Décodage
Quand un programme "écrit" un caractère, il envoie la valeur numérique ASCII correspondante. Quand un programme "lit" un caractère, il reçoit une valeur numérique et la convertit en caractère en utilisant la table ASCII.
> [!example] Encodage et Décodage d'un mot
> Considérons le mot "Hello".
>
> 1. **Encodage** : Chaque caractère est remplacé par sa valeur ASCII décimale :
> * 'H' $\rightarrow$ 72
> * 'e' $\rightarrow$ 101
> * 'l' $\rightarrow$ 108
> * 'l' $\rightarrow$ 108
> * 'o' $\rightarrow$ 111
> Le mot "Hello" est donc stocké comme la séquence de nombres : 72, 101, 108, 108, 111.
> En binaire (sur 8 bits, car les octets sont l'unité de stockage la plus courante, même si ASCII est sur 7 bits, le 8ème bit est souvent mis à 0 ou utilisé pour la parité) :
> $01001000_2, 01100101_2, 01101100_2, 01101100_2, 01101111_2$.
>
> 2. **Décodage** : Quand un programme lit cette séquence de nombres, il utilise la table ASCII pour retrouver les caractères :
> * 72 $\rightarrow$ 'H'
> * 101 $\rightarrow$ 'e'
> * 108 $\rightarrow$ 'l'
> * 108 $\rightarrow$ 'l'
> * 111 $\rightarrow$ 'o'
> Ce qui reconstitue le mot "Hello".
## 4. Les Limites de l'ASCII
Malgré son succès et sa simplicité, l'ASCII présente une limitation majeure : son nombre de caractères est très restreint. Avec seulement 128 caractères, il est suffisant pour l'anglais américain et quelques symboles, mais il ne peut pas représenter :
1. **Les caractères accentués et spéciaux** des langues européennes (français, allemand, espagnol, etc.) : `é`, `à`, `ç`, `ü`, `ñ`, `ß`, etc.
2. **Les alphabets non latins** : Cyrillique (russe), Grec, Arabe, Hébreu, etc.
3. **Les systèmes d'écriture asiatiques** : Chinois, Japonais, Coréen (qui nécessitent des milliers de caractères).
> [!warning] Problèmes d'Interprétation
> L'incapacité d'ASCII à gérer ces caractères a conduit à de nombreux problèmes d'affichage et de compatibilité. Si un texte contient des caractères non-ASCII et est interprété comme de l'ASCII pur, ces caractères apparaîtront comme des symboles étranges ou des points d'interrogation (souvent appelés "mojibake").
## Conclusion
L'ASCII a été une avancée majeure pour l'interopérabilité des systèmes informatiques, en fournissant une norme simple et efficace pour l'échange de texte. Sa table de 128 caractères, basée sur 7 bits, est devenue un pilier de l'informatique anglo-saxonne.
Cependant, les limites inhérentes à son jeu de caractères restreint ont rapidement mis en évidence la nécessité de solutions plus robustes pour prendre en charge la diversité linguistique mondiale. C'est cette limitation qui a pavé la voie aux extensions 8 bits, puis ultimement à l'émergence d'Unicode et de ses encodages comme UTF-8, qui sont devenus le standard de facto pour la représentation du texte dans le monde moderne.
Maîtriser ASCII, c'est comprendre les fondations sur lesquelles repose toute la gestion du texte numérique. C'est un pré-requis indispensable avant d'aborder les complexités et les richesses des encodages de caractères universels.
## 🗓️ Historique
> **Dernière mise à jour :** `01 novembre 2025`
> **Rédigé par :** [[Julien DUQUENNOY]]