Aller au contenu principal
Forme d'encodage 32 bits à largeur fixe Unicode Standard 17.0 §3.8 & §3.9 ISO/IEC 10646

Encodage UTF-32

UTF-32 (format de transformation Unicode de 32 bits) est la forme d'encodage de caractères à largeur fixe qui mappe chaque valeur scalaire Unicode sur exactement une unité de code de 32 bits (4 octets). En UTF-32, la valeur numérique de l'unité de code de 32 bits est identiquement égale à la valeur scalaire. Comme il utilise un entier de 32 bits pour chaque valeur scalaire, UTF-32 n'exige aucun substitut à largeur variable ; cependant, les points de code substituts (U+D800–U+DFFF) et les valeurs au-dessus de U+10FFFF sont strictement invalides.

Données techniques rapides

Taille d'unité de code 32 bits (4 Bytes) Unité fondamentale de la forme d'encodage
Unités par valeur scalaire Exactly 1 Code Unit Mappage direct 1:1 scalaire-unité
Octets sérialisés par scalaire 4 Bytes (Serialized) Toujours 4 octets dans les flux d'octets
Plages scalaires valides U+0000–U+D7FF & U+E000–U+10FFFF 1,112,064 valeurs scalaires valides au total
Points de code substituts U+D800–U+DFFF (interdits) Pas des valeurs scalaires ; rejetés en UTF-32
Schémas de boutisme UTF-32BE / UTF-32LE Flux d'octets Big-Endian et Little-Endian
Marque d'ordre des octets (BOM) Optionnelle (U+FEFF) BE: 00 00 FE FF | LE: FF FE 00 00
Nuance de largeur fixe Fixe par scalaire uniquement Les clusters de graphèmes multi-scalaires exigent plus d'une unité

Espace de code Unicode et plages scalaires valides

L'espace de code Unicode se compose de $1,114,112$ points de code ($U+0000$ à $U+10FFFF$). En UTF-32, chaque valeur scalaire Unicode valide est mappée sur exactement une unité de code de 32 bits (4 octets). Les points de code substituts ($U+D800$ à $U+DFFF$) et les valeurs dépassant $U+10FFFF$ sont strictement interdits par le standard Unicode 17.0 (§3.8 & §3.9).

Section de l'espace de code Plage scalaire Unités de code Longueur en octets Plage d'unités de code UTF-32 (hex) Statut de conformité
Basic Multilingual Plane (BMP, Lower)
Contains ASCII, Latin, Greek, Cyrillic, Hebrew, Arabic, and most world scripts.
 U+0000–U+D7FF 1 unité de code 4 octets 00000000–0000D7FF Valid Scalar Range
High & Low Surrogate Range (Reserved)
Reserved exclusively for UTF-16 surrogate pairs. Surrogates are NOT Unicode scalar values.
 U+D800–U+DFFF 0 unité (interdit) — 0000D800–0000DFFF Prohibited (Surrogates)
Basic Multilingual Plane (BMP, Upper)
Private Use Area, CJK compatibility, alphabetic presentation forms, and specials.
 U+E000–U+FFFF 1 unité de code 4 octets 0000E000–0000FFFF Valid Scalar Range
Supplementary Planes (Planes 1–16)
Emojis, historic scripts (Linear B, Egyptian Hieroglyphs), musical symbols, rare CJK ideographs.
 U+10000–U+10FFFF 1 unité de code 4 octets 00010000–0010FFFF Valid Scalar Range
Outside Unicode Codespace
Values exceeding U+10FFFF are outside the Unicode codespace and cannot be represented in UTF-32.
 > U+10FFFF 0 unité (interdit) — 00110000–FFFFFFFF Prohibited (Out of Codespace)

Architecture des unités de code 32 bits UTF-32

Contrairement à UTF-8 (1–4 octets) ou UTF-16 (2 ou 4 octets), UTF-32 est à largeur fixe au niveau des unités de code. La valeur scalaire Unicode U+1F600 (😀) est mappée directement sur l'unité de code 32 bits 0001F600, qui se sérialise en quatre octets de 8 bits.

Valeur scalaire Unicode : 😀 (U+1F600) Plane 1 (SMP - Supplementary Multilingual Plane)
Unité de code 32 bits (entier en mémoire)
0001F600 Bits 31 .. 0 (32 bits)
00000000 00000001 11110110 00000000
UTF-32BE (Big-Endian) Octet de poids fort en premier ($B_0 \to B_3$)
B₀ (Bits 31..24) 00
B₁ (Bits 23..16) 01
B₂ (Bits 15..8) F6
B₃ (Bits 7..0) 00
Octets sérialisés : 00 01 F6 00
UTF-32LE (Little-Endian) Octet de poids faible en premier ($B_0 \to B_3$)
B₀ (Bits 7..0) 00
B₁ (Bits 15..8) F6
B₂ (Bits 23..16) 01
B₃ (Bits 31..24) 00
Octets sérialisés : 00 F6 01 00

Inspecteur et validateur UTF-32 interactif

Inspectez n'importe quel texte ou caractère en temps réel pour voir ses unités de code 32 bits exactes, basculez entre les sérialisations d'octets Big-Endian et Little-Endian, ou saisissez des unités de code hexadécimales brutes pour valider la conformité.

Préréglages rapides :
Format d'affichage :
Points de code : 1
Unités de code 32 bits : 1
Octets sérialisés : 4
Clusters de graphèmes : 1
Unités de code UTF-32 hexadécimales :
0001F600
😀 U+1F600
Plan multilingue supplémentaire 1 unité de code (4 octets)
Unité de code 32 bits : 0001F600
Octets BE : 00 01 F6 00
Octets LE : 00 F6 01 00

Exemples de caractères UTF-32 choisis à travers les plans

Caractères Unicode représentatifs, symboles mathématiques, écritures historiques, signes combinants et séquences d'émojis complexes encodés en UTF-32.

A

Latin Capital Letter A

Plane 0 (BMP) • Basic ASCII
Valeur scalaire : U+0041
Unité de code UTF-32 : 00000041
Octets UTF-32BE : 00 00 00 41
Octets UTF-32LE : 41 00 00 00
1 Code Unité 4 Octets 1 Graphème

Standard ASCII character; numeric value 65 maps identically to code unit 00000041.

é

Latin Small Letter E with Acute

Plane 0 (BMP) • Latin-1 Supplement
Valeur scalaire : U+00E9
Unité de code UTF-32 : 000000E9
Octets UTF-32BE : 00 00 00 E9
Octets UTF-32LE : E9 00 00 00
1 Code Unité 4 Octets 1 Graphème

Precomposed accented letter. In UTF-32, directly encoded as 000000E9.

€

Euro Sign

Plane 0 (BMP) • Currency Symbols
Valeur scalaire : U+20AC
Unité de code UTF-32 : 000020AC
Octets UTF-32BE : 00 00 20 AC
Octets UTF-32LE : AC 20 00 00
1 Code Unité 4 Octets 1 Graphème

Requires 3 bytes in UTF-8 and 2 bytes in UTF-16, but exactly 4 bytes in UTF-32.

∞

Infinity

Plane 0 (BMP) • Mathematical Operators
Valeur scalaire : U+221E
Unité de code UTF-32 : 0000221E
Octets UTF-32BE : 00 00 22 1E
Octets UTF-32LE : 1E 22 00 00
1 Code Unité 4 Octets 1 Graphème

Mathematical operator represented as code unit 0000221E.

😀

Grinning Face

Plane 1 (SMP) • Emoji & Pictographs
Valeur scalaire : U+01F600
Unité de code UTF-32 : 0001F600
Octets UTF-32BE : 00 01 F6 00
Octets UTF-32LE : 00 F6 01 00
1 Code Unité 4 Octets 1 Graphème

Supplementary plane emoji. Unlike UTF-16 surrogate pairs, UTF-32 uses exactly 1 code unit (0001F600).

𐂃

Linear B Ideogram B105F Mare

Plane 1 (SMP) • Historic Scripts
Valeur scalaire : U+010083
Unité de code UTF-32 : 00010083
Octets UTF-32BE : 00 01 00 83
Octets UTF-32LE : 83 00 01 00
1 Code Unité 4 Octets 1 Graphème

Ancient Mediterranean script in Plane 1, encoded as 00010083.

𪚥

CJK Unified Ideograph-2A6A5

Plane 2 (SIP) • CJK Extension B
Valeur scalaire : U+02A6A5
Unité de code UTF-32 : 0002A6A5
Octets UTF-32BE : 00 02 A6 A5
Octets UTF-32LE : A5 A6 02 00
1 Code Unité 4 Octets 1 Graphème

Rare 64-stroke Chinese ideograph (dragon quadruple), represented as 0002A6A5.

é

e + Combining Acute Accent

Plane 0 (BMP) • Combining Sequence
Valeur scalaire : U+0065 + U+0301
Unité de code UTF-32 : 00000065 00000301
Octets UTF-32BE : 00 00 00 65 00 00 03 01
Octets UTF-32LE : 65 00 00 00 01 03 00 00
2 Code Unités 8 Octets 1 Graphème

Decomposed grapheme cluster: 2 scalars = 2 UTF-32 units (8 bytes), displaying as 1 visible letter.

👩‍💻

Woman Technologist

Plane 1 & Plane 0 • Emoji ZWJ Sequence
Valeur scalaire : U+01F469 + U+200D + U+01F4BB
Unité de code UTF-32 : 0001F469 0000200D 0001F4BB
Octets UTF-32BE : 00 01 F4 69 00 00 20 0D 00 01 F4 BB
Octets UTF-32LE : 69 F4 01 00 0D 20 00 00 BB F4 01 00
3 Code Unités 12 Octets 1 Graphème

Comprises 3 scalars: Woman (U+1F469), ZWJ (U+200D), and Laptop (U+1F4BB) = 3 units (12 bytes).

Null Character

Plane 0 (BMP) • Control Code
Valeur scalaire : U+0000
Unité de code UTF-32 : 00000000
Octets UTF-32BE : 00 00 00 00
Octets UTF-32LE : 00 00 00 00
1 Code Unité 4 Octets 1 Graphème

Lowest valid scalar value in Unicode. Encodes as 00000000.

U+D7FF

Last BMP Pre-Surrogate Code Point

Plane 0 (BMP) • Hangul Jamo Extended-B
Valeur scalaire : U+D7FF
Unité de code UTF-32 : 0000D7FF
Octets UTF-32BE : 00 00 D7 FF
Octets UTF-32LE : FF D7 00 00
1 Code Unité 4 Octets 1 Graphème

Highest scalar value immediately before the reserved surrogate range. Encodes as 0000D7FF.

U+E000

First BMP Post-Surrogate Code Point

Plane 0 (BMP) • Private Use Area
Valeur scalaire : U+E000
Unité de code UTF-32 : 0000E000
Octets UTF-32BE : 00 00 E0 00
Octets UTF-32LE : 00 E0 00 00
1 Code Unité 4 Octets 1 Graphème

Lowest scalar value immediately following the surrogate range. Encodes as 0000E000.

U+FFFF

BMP Noncharacter

Plane 0 (BMP) • Special / Noncharacter
Valeur scalaire : U+FFFF
Unité de code UTF-32 : 0000FFFF
Octets UTF-32BE : 00 00 FF FF
Octets UTF-32LE : FF FF 00 00
1 Code Unité 4 Octets 1 Graphème

Valid Unicode scalar value reserved for internal processing. Fully encodable as 0000FFFF.

U+10000

Linear B Syllable B008 A

Plane 1 (SMP) • Supplementary Start
Valeur scalaire : U+010000
Unité de code UTF-32 : 00010000
Octets UTF-32BE : 00 01 00 00
Octets UTF-32LE : 00 00 01 00
1 Code Unité 4 Octets 1 Graphème

First scalar value of the Supplementary Planes. Encodes cleanly as 00010000.

U+10FFFF

Maximum Unicode Codespace Limit

Plane 16 (SSP) • Special / Noncharacter
Valeur scalaire : U+10FFFF
Unité de code UTF-32 : 0010FFFF
Octets UTF-32BE : 00 10 FF FF
Octets UTF-32LE : FF FF 10 00
1 Code Unité 4 Octets 1 Graphème

The absolute maximum scalar value defined by Unicode. Encodes as 0010FFFF.

Ordre des octets et sérialisation : UTF-32BE contre UTF-32LE

Le standard Unicode sépare formellement la forme d'encodage en mémoire (unités de code entières de 32 bits) du schéma d'encodage sérialisé (flux d'octets de 8 bits ordonnés). Quand une unité de code de 32 bits est écrite dans un fichier ou un socket réseau, l'ordre des octets doit être spécifié.

UTF-32BE (Big-Endian / ordre des octets réseau)

Octet de poids fort en premier. Utilisé par les protocoles internet standard.

B₀ = (W >> 24) & 0xFF // Most significant byte B₁ = (W >> 16) & 0xFF B₂ = (W >> 8) & 0xFF B₃ = W & 0xFF // Least significant byte

UTF-32LE (Little-Endian / natif x86 et ARM)

Octet de poids faible en premier. Disposition mémoire native des CPU modernes.

B₀ = W & 0xFF // Least significant byte B₁ = (W >> 8) & 0xFF B₂ = (W >> 16) & 0xFF B₃ = (W >> 24) & 0xFF // Most significant byte
Caractère Valeur scalaire Unité de code 32 bits UTF-32BE (Big-Endian) UTF-32LE (Little-Endian) Comportement de sérialisation
A U+0041 00000041 00 00 00 41 41 00 00 00 ASCII Capital A: BE puts leading zeros first; LE places byte 0x41 in lowest position.
é U+00E9 000000E9 00 00 00 E9 E9 00 00 00 Latin-1 character: BE = 00 00 00 E9, LE = E9 00 00 00.
€ U+20AC 000020AC 00 00 20 AC AC 20 00 00 BMP symbol: In LE, byte 0xAC leads followed by 0x20 and two null bytes.
😀 U+1F600 0001F600 00 01 F6 00 00 F6 01 00 Supplementary emoji: BE splits high byte 0x01 then 0xF6; LE reverses to 0x00 0xF6 0x01 0x00.
U+10FFFF U+10FFFF 0010FFFF 00 10 FF FF FF FF 10 00 Codespace boundary: BE has 0x00 then 0x10; LE leads with two 0xFF bytes.

Remarquez les octets nuls de tête

Comme toutes les valeurs scalaires Unicode valides sont $\le \text{U+10FFFF}$, l'octet le plus élevé ($B_0$ en BE, $B_3$ en LE) est toujours 0x00 pour tout caractère Unicode valide. De plus, pour tous les caractères ASCII ($U+0000$ à $U+007F$), trois des quatre octets sont des octets nuls (0x00).

Sémantique de la marque d'ordre des octets (BOM)

Dans les flux sérialisés en octets où l'ordre des octets n'est pas explicitement déclaré, Unicode définit le point de code U+FEFF (ESPACE SANS CHASSE INSÉCABLE) comme signature marque d'ordre des octets (BOM) placée au début du fichier.

Signature BOM UTF-32BE U+FEFF
00 00 FE FF

L'unité de code 32 bits 0000FEFF sérialisée en ordre gros-boutiste place d'abord les deux octets nuls, suivis de 0xFE et 0xFF.

Signature BOM UTF-32LE U+FEFF
FF FE 00 00

L'unité de code 32 bits 0000FEFF sérialisée en ordre petit-boutiste place d'abord 0xFF et 0xFE, suivis de deux octets nuls.

Règles normatives d'usage de la BOM (Unicode 17.0 §3.10)

  • Explicit UTF-32BE or UTF-32LE streams (e.g. Content-Type: charset=utf-32be) do NOT require a BOM.
  • In generic UTF-32 streams, decoders inspect the first 4 bytes to deduce endianness.
  • When used as a signature at stream start, U+FEFF is stripped by conformant decoders and not rendered.
  • If an initial 00 00 FE FF is read as Little-Endian, it yields 0xFFFE0000 (> U+10FFFF), immediately exposing the endian mismatch.
  • If an initial FF FE 00 00 is read as Big-Endian, it yields U+FFFE0000 (> U+10FFFF), immediately exposing the endian mismatch.

Validation de conformité : valeurs interdites et erreurs

Contrairement aux tableaux d'entiers 32 bits arbitraires, UTF-32 est strictement limité aux valeurs scalaires Unicode. Tout analyseur, convertisseur ou validateur doit rejeter les valeurs ne correspondant pas à des valeurs scalaires Unicode valides.

SURROGATE_VALUE

Surrogate Code Point Prohibited

Plage : 0000D800–0000DFFF

Surrogates are reserved exclusively for UTF-16 surrogate pairs and are expressly NOT Unicode scalar values (Unicode 17.0 §3.8, D88). UTF-32 cannot encode surrogates.

OUT_OF_RANGE

Out of Unicode Codespace

Plage : > 0010FFFF (up to FFFFFFFF)

The Unicode codespace strictly ends at U+10FFFF (1,114,111). Any 32-bit integer exceeding 0010FFFF is invalid Unicode and cannot be represented.

MALFORMED_BYTE_LENGTH

Truncated 4-Byte Sequence

Plage : Byte count not divisible by 4

Every serialized UTF-32 code unit requires exactly 4 contiguous bytes. A stream with non-multiple of 4 bytes is incomplete or corrupted.

INVALID_HEX_CHARACTER

Non-Hexadecimal Format

Plage : Characters outside [0-9A-Fa-f]

Hexadecimal code units must contain valid hexadecimal digits formatted in 8-digit groups.

Vecteurs de test de conformité

Vecteur de test Classification de l'erreur Verdict de validation Raison technique
0000D800 SURROGATE_VALUE REJETÉ (mal formé) Lead surrogate code point (U+D800). Rejected because surrogates are not scalar values.
0000DFFF SURROGATE_VALUE REJETÉ (mal formé) Trail surrogate code point (U+DFFF). Rejected as non-scalar value.
00110000 OUT_OF_RANGE REJETÉ (mal formé) First code point beyond Unicode codespace (U+110000). Exceeds 0010FFFF limit.
FFFFFFFF OUT_OF_RANGE REJETÉ (mal formé) Maximum 32-bit unsigned integer. Far exceeds the Unicode codespace.
80000000 OUT_OF_RANGE REJETÉ (mal formé) Bit 31 set. Outside Unicode codespace.
00 00 20 MALFORMED_BYTE_LENGTH REJETÉ (mal formé) Only 3 bytes provided. Serialized UTF-32 requires 4-byte alignment.

Concepts architecturaux fondamentaux et pièges

Distinctions essentielles entre points de code Unicode abstraits, unités de code concrètes, ordres d'octets sérialisés et clusters de graphèmes perçus par l'humain.

Code Unit vs. Code Point: The 1:1 Identity

In UTF-32, the abstract Unicode scalar value and the 32-bit code unit share identical numeric values. For example, U+1F600 has the scalar value 0x1F600 and encodes into the 32-bit code unit 0001F600. While the numerical value is identical, the concepts remain distinct: a code point is an abstract position in the Unicode codespace, whereas a code unit is the concrete bit representation used in memory or storage.

The Grapheme Caveat: Why UTF-32 Is Not "1 Visible Character = 4 Bytes"

A persistent myth in software engineering is that UTF-32 allows O(1) random indexing of visible characters. While UTF-32 provides direct O(1) indexing of Unicode scalar values, human-perceived characters (grapheme clusters) frequently comprise multiple scalar values. A combining accent sequence like "e + \u0301" requires two UTF-32 units (8 bytes), and emoji ZWJ sequences like "👩‍💻" require three UTF-32 units (12 bytes). True string segmentation requires Unicode Annex #29 grapheme cluster boundaries, regardless of encoding form.

Encoding Form vs. Encoding Scheme: Byte Ordering

Unicode formally distinguishes between an encoding form (which operates on in-memory integer units) and an encoding scheme (which specifies how those units serialize into an ordered sequence of 8-bit bytes). UTF-32 is the encoding form. When serialized into bytes, byte endianness must be specified: UTF-32BE places the most significant byte first (00 01 F6 00), while UTF-32LE places the least significant byte first (00 F6 01 00).

Why Surrogates Are Strictly Forbidden in UTF-32

Surrogates (U+D800–U+DFFF) were created solely as a mechanism for UTF-16 to address code points above U+FFFF. Because UTF-32 uses 32-bit code units, it can directly represent any scalar value without surrogates. The Unicode Standard formally defines Unicode scalar values as all code points excluding surrogates. Any 32-bit integer in the range 0000D800–0000DFFF is therefore ill-formed and must be rejected by conformant UTF-32 parsers.

UTF-32 vs. UCS-4 Historical Context

Historically, ISO/IEC 10646 defined UCS-4 as a full 31-bit encoding capable of addressing up to 2 billion characters (0x00000000 to 0x7FFFFFFF). When Unicode and ISO synchronized their standards, Unicode capped the codespace at 17 planes (U+10FFFF). UTF-32 was defined as the restricted Unicode form that represents only Unicode scalar values up to U+10FFFF. In modern computing, UCS-4 and UTF-32 are identical in practice, as ISO 10646 has aligned with Unicode codespace boundaries.

Comparaison des encodages : UTF-8 contre UTF-16 contre UTF-32

Comment UTF-32 se compare directement aux formes d'encodage Unicode à largeur variable selon la taille des unités de code, l'efficacité de stockage, la dépendance au boutisme et l'adoption par les normes.

Caractéristique architecturale UTF-8 UTF-16 UTF-32 (cette page)
Code Unit Size 8 bits (1 byte) 16 bits (2 bytes) 32 bits (4 bytes)
Code Units per Scalar 1 to 4 code units 1 or 2 code units Exactly 1 code unit
Serialized Bytes per Scalar 1, 2, 3, or 4 bytes 2 or 4 bytes Always 4 bytes
Fixed Width per Scalar No (Variable width) No (Variable width via surrogates) Yes (Fixed 32-bit code units)
Fixed Width per Visible Grapheme No No No (Multi-scalar graphemes require >1 unit)
ASCII Storage Efficiency Optimal (1 byte / 100% ASCII match) Moderate (2 bytes / 100% overhead) High Overhead (4 bytes / 300% overhead)
Endianness Dependency None (Byte-oriented stream) Yes (UTF-16BE / UTF-16LE) Yes (UTF-32BE / UTF-32LE)
Web Standard Status Universal Web Standard (HTML5/WHATWG) Supported for legacy/APIs Not used for web document interchange
Primary Use Case Network interchange, web, storage, files Windows APIs, Java/JS string engines Internal fixed-width indexing, parsers, C/C++ wchar_t

Normes de référence et références normatives

Toutes les données, règles de bornes scalaires, définitions d'unités de code 32 bits et ordres de sérialisation des octets de cette page dérivent directement de normes techniques normatives :