%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %% > [!nav] > ↩ [[Code et Développement/Programmation/Encodage/Encodage|Accueil · Encodage]] > > | | [[Code et Développement/Programmation/Encodage/02_Encodage UTF-8\|Encodage UTF-8 →]] | > |:---|---:| %% nav-fin %% # Chapitre 1 : L’Encodage ASCII ## Introduction Un ordinateur ne manipule que des séquences de bits, qu’il s’agisse d’une image, d’un son ou d’un texte. Pour traiter du texte, il faut associer chaque caractère (lettre, chiffre, symbole) à un nombre. C’est le rôle de l’encodage de caractères. Ce chapitre présente **ASCII** (American Standard Code for Information Interchange), l’un des premiers encodages. Les encodages actuels, dont UTF-8, reprennent sa table pour les 128 premiers caractères. > [!note] Pré-requis > Ce chapitre utilise les [[Code et Développement/Programmation/Systèmes de numération/Systèmes de numération|Systèmes de numération]] (binaire, décimal, hexadécimal). Les caractères y sont représentés par des nombres, écrits dans plusieurs bases. ## 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} = 1000001_2$. Sur un octet de 8 bits, on écrit $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 > La valeur ASCII d’une lettre minuscule est supérieure de 32 à celle de sa majuscule. > 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 sert en programmation pour passer d’une majuscule à une minuscule, et inversement. **Pour vérifier :** utilisez l’écart de 32. ```sq-quiz ? Le code de 'G' est 71. Quel est le code de 'g' ? - [ ] 39 - [x] 103 - [ ] 72 > Une minuscule a un code supérieur de 32 à celui de sa majuscule : 71 + 32 = 103. ? Le code de 'm' est 109. Quel caractère a le code 77 ? - [x] 'M' - [ ] 'n' - [ ] 'L' > 109 − 32 = 77 : c’est la majuscule de 'm'. ? Quel bit change entre 'A' (1000001) et 'a' (1100001) ? - [x] Le bit de poids 32 - [ ] Le bit de poids 1 - [ ] Le bit de poids 64 > 32 = 2^5 : seul le bit de poids 32 passe de 0 à 1. ``` ### 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 | **À manipuler :** cliquez sur un caractère pour lire son code. ```sq-ascii ``` ## 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 L’ASCII ne compte que 128 caractères. Il suffit pour l’anglais américain, mais il ne représente pas : 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 fourni une norme commune pour échanger du texte entre systèmes. Sa table compte 128 caractères codés sur 7 bits. Ce nombre limité de caractères a conduit aux extensions sur 8 bits, puis à Unicode et à ses encodages comme UTF-8, devenu le standard du texte. Le chapitre suivant présente UTF-8, qui reprend la table ASCII pour ses 128 premiers caractères. %% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %% > [!nav] > ↩ [[Code et Développement/Programmation/Encodage/Encodage|Accueil · Encodage]] > > | | [[Code et Développement/Programmation/Encodage/02_Encodage UTF-8\|Encodage UTF-8 →]] | > |:---|---:| %% nav-fin %% --- 🗓️ Historique Dernière mise à jour : `8 novembre 2026` Rédigé par : [[Julien DUQUENNOY]]