Aller au contenu principal

4. Utilisation des champs structurés en HTTP (Working with Structured Fields in HTTP)

Cette section définit comment sérialiser et analyser les champs structurés dans les valeurs de champs HTTP textuels et dans d'autres encodages compatibles (par exemple, dans HTTP/2 [RFC7540] avant la compression avec HPACK [RFC7541]).

4.1 Sérialisation des champs structurés (Serializing Structured Fields)​

Étant donné une structure définie dans cette spécification, retourner une chaîne ASCII appropriée pour une utilisation dans une valeur de champ HTTP.

Algorithme principal​

  1. Si la structure est un Dictionary ou une List et que sa valeur est vide (c'est-à-dire sans membres), ne pas sérialiser le champ du tout (c'est-à-dire omettre le field-name et la field-value).

  2. Si la structure est une List, laisser output_string être le résultat de l'exécution de « Sérialiser une List » (section 4.1.1).

  3. Sinon, si la structure est un Dictionary, laisser output_string être le résultat de l'exécution de « Sérialiser un Dictionary » (section 4.1.2).

  4. Sinon, si la structure est un Item, laisser output_string être le résultat de l'exécution de « Sérialiser un Item » (section 4.1.3).

  5. Sinon, la sérialisation échoue.

  6. Convertir output_string en tableau d'octets en utilisant l'encodage ASCII [RFC0020] et retourner.

4.1.1 Sérialiser une List (Serializing a List)​

Étant donné un tableau de tuples (member_value, parameters) comme input_list, retourner une chaîne ASCII.

Algorithme​

  1. Laisser output être une chaîne vide.

  2. Pour chaque (member_value, parameters) dans input_list :

    • Si member_value est un tableau, ajouter le résultat de « Sérialiser une Inner List » (section 4.1.1.1) à output
    • Sinon, ajouter le résultat de « Sérialiser un Item » (section 4.1.3) à output
    • S'il y a d'autres member_values dans input_list :
      • Ajouter « , » à output
      • Ajouter un espace simple (SP) à output

  3. Retourner output.

Exemples​

Entrée : [(1, {}), (2, {}), (3, {})]
Sortie : "1, 2, 3"

Entrée : [("foo", {}), ("bar", {a: 1})]
Sortie : "foo, bar;a=1"

4.1.1.1 Sérialiser une Inner List (Serializing an Inner List)​

Étant donné un tableau de tuples (member_value, parameters) comme inner_list et des paramètres comme list_parameters, retourner une chaîne ASCII.

Algorithme​

  1. Laisser output être la chaîne « ( ».

  2. Pour chaque (member_value, parameters) dans inner_list :

    • Ajouter le résultat de « Sérialiser un Item » à output
    • S'il y a d'autres valeurs dans inner_list, ajouter un espace simple à output

  3. Ajouter « ) » à output.

  4. Ajouter le résultat de « Sérialiser des Parameters » (section 4.1.1.2) à output.

  5. Retourner output.

Exemple​

Entrée : [(1, {}), (2, {})] avec paramètres {lvl: 5}
Sortie : "(1 2);lvl=5"

4.1.1.2 Sérialiser des Parameters (Serializing Parameters)​

Étant donné un Dictionary ordonné comme input_parameters (chaque membre ayant param_key et param_value), retourner une chaîne ASCII.

Algorithme​

  1. Laisser output être une chaîne vide.

  2. Pour chaque param_key avec valeur param_value dans input_parameters :

    • Ajouter « ; » à output
    • Ajouter le résultat de « Sérialiser une Key » (section 4.1.1.3) à output
    • Si param_value n'est pas Boolean true :
      • Ajouter « = » à output
      • Ajouter le résultat de « Sérialiser un bare Item » à output

  3. Retourner output.

Exemple​

Entrée : {a: 1, b: true, c: "value"}
Sortie : ";a=1;b;c=\"value\""

4.1.1.3 Sérialiser une Key (Serializing a Key)​

Étant donné une key comme input_key, retourner une chaîne ASCII.

Algorithme​

  1. Convertir input_key en séquence de caractères ASCII ; si la conversion échoue, la sérialisation échoue.

  2. Si input_key contient des caractères qui ne sont pas dans lcalpha, DIGIT, « _ », « - », « . » ou « * », la sérialisation échoue.

  3. Si le premier caractère de input_key n'est pas lcalpha ou « * », la sérialisation échoue.

  4. Retourner input_key.

Exemples de clés valides​

✓ "foo"
✓ "foo_bar"
✓ "foo-bar"
✓ "*star"
✗ "Foo"      (majuscule)
✗ "123foo"   (commence par un chiffre)

4.1.2 Sérialiser un Dictionary (Serializing a Dictionary)​

Étant donné un Dictionary ordonné comme input_dictionary (chaque membre ayant member_key et une valeur tuple (member_value, parameters)), retourner une chaîne ASCII.

Algorithme​

  1. Laisser output être une chaîne vide.

  2. Pour chaque member_key avec valeur (member_value, parameters) dans input_dictionary :

    • Ajouter le résultat de « Sérialiser une Key » à output
    • Si member_value est Boolean true :
      • Ajouter le résultat de « Sérialiser des Parameters » à output
    • Sinon :
      • Ajouter « = » à output
      • Si member_value est un tableau, ajouter le résultat de « Sérialiser une Inner List »
      • Sinon, ajouter le résultat de « Sérialiser un Item »
    • S'il y a d'autres membres dans input_dictionary :
      • Ajouter « , » à output
      • Ajouter un espace simple à output

  3. Retourner output.

Exemple​

Entrée : {a: 1, b: true, c: (2, 3)}
Sortie : "a=1, b, c=(2 3)"

4.1.3 Sérialiser un Item (Serializing an Item)​

Étant donné un Item comme bare_item et des Parameters comme item_parameters, retourner une chaîne ASCII.

Algorithme​

  1. Laisser output être une chaîne vide.
  2. Ajouter le résultat de « Sérialiser un Bare Item » (section 4.1.3.1) à output.
  3. Ajouter le résultat de « Sérialiser des Parameters » à output.
  4. Retourner output.

4.1.3.1 Sérialiser un Bare Item (Serializing a Bare Item)​

Étant donné un Item comme input_item, appeler la fonction de sérialisation correspondante selon son type :

  • Integer → section 4.1.4
  • Decimal → section 4.1.5
  • String → section 4.1.6
  • Token → section 4.1.7
  • Byte Sequence → section 4.1.8
  • Boolean → section 4.1.9

4.1.4 Sérialiser un Integer (Serializing an Integer)​

Algorithme​

  1. Si input_integer n'est pas dans la plage -999 999 999 999 999 à 999 999 999 999 999 (inclus), la sérialisation échoue.
  2. Si input_integer < 0, ajouter « - ».
  3. Ajouter la représentation décimale de input_integer.

Exemples​

42      → "42"
-100    → "-100"
0       → "0"

4.1.5 Sérialiser un Decimal (Serializing a Decimal)​

Algorithme​

  1. Si ce n'est pas un décimal, la sérialisation échoue.
  2. Si la partie décimale a plus de 3 chiffres significatifs, arrondir à 3 chiffres.
  3. Si la partie entière a plus de 12 chiffres significatifs, la sérialisation échoue.
  4. Si input_decimal < 0, ajouter « - ».
  5. Ajouter la représentation décimale de la partie entière.
  6. Ajouter « . ».
  7. Ajouter la partie décimale (ajouter « 0 » si elle est nulle).

Exemples​

4.5       → "4.5"
-0.123    → "-0.123"
3.14159   → "3.142"  (arrondi)

4.1.6 Sérialiser une String (Serializing a String)​

Algorithme​

  1. Convertir en séquence de caractères ASCII ; si échec, la sérialisation échoue.
  2. Si la chaîne contient des caractères dans la plage %x00-1f ou %x7f-ff, la sérialisation échoue.
  3. Ajouter DQUOTE (").
  4. Pour chaque caractère :
    • Si c'est « \ » ou DQUOTE, ajouter « \ »
    • Ajouter le caractère
  5. Ajouter DQUOTE.

Exemples​

hello world   → "\"hello world\""
say "hi"      → "\"say \\\"hi\\\"\""

4.1.7 Sérialiser un Token (Serializing a Token)​

Algorithme​

  1. Convertir en séquence de caractères ASCII ; si échec, la sérialisation échoue.
  2. Vérifier que le premier caractère est ALPHA ou « * ».
  3. Vérifier que les caractères restants sont dans tchar, « : » ou « / ».
  4. Retourner input_token.

Exemples​

foo123/456       → "foo123/456"
application/json → "application/json"
*                → "*"

4.1.8 Sérialiser une Byte Sequence (Serializing a Byte Sequence)​

Algorithme​

  1. Si ce n'est pas une séquence d'octets, la sérialisation échoue.
  2. Ajouter « : ».
  3. Ajouter les input_bytes encodés en base64 (selon la section 4 de [RFC4648]).
  4. Ajouter « : ».

Exemple​

[0x48, 0x65, 0x6c, 0x6c, 0x6f]  → ":SGVsbG8=:"

4.1.9 Sérialiser un Boolean (Serializing a Boolean)​

Algorithme​

  1. Si ce n'est pas un boolean, la sérialisation échoue.
  2. Ajouter « ? ».
  3. Si true, ajouter « 1 » ; si false, ajouter « 0 ».

Exemples​

true   → "?1"
false  → "?0"

4.2 Analyse des champs structurés (Parsing Structured Fields)​

Lorsqu'une implémentation réceptrice analyse un champ HTTP connu comme champ structuré, il faut être prudent car de nombreux cas limites peuvent entraîner des problèmes d'interopérabilité, voire de sécurité. Cette section spécifie les algorithmes pour effectuer cette opération.

Algorithme principal​

Étant donné un tableau d'octets input_bytes représentant la field-value du champ sélectionné (ou vide si le champ n'existe pas) et field_type (l'un de « dictionary », « list » ou « item »), retourner la valeur d'en-tête analysée.

  1. Convertir input_bytes en chaîne ASCII input_string ; si la conversion échoue, l'analyse échoue.

  2. Supprimer tous les caractères SP au début de input_string.

  3. Si field_type est « list », laisser output être le résultat de l'exécution de « Analyser une List » (section 4.2.1).

  4. Si field_type est « dictionary », laisser output être le résultat de l'exécution de « Analyser un Dictionary » (section 4.2.2).

  5. Si field_type est « item », laisser output être le résultat de l'exécution de « Analyser un Item » (section 4.2.3).

  6. Supprimer tous les caractères SP au début de input_string.

  7. Si input_string n'est pas vide, l'analyse échoue.

  8. Sinon, retourner output.

Principes clés​

  • Analyse stricte : toute erreur entraîne l'ignorance du champ entier
  • Pas de tolérance aux erreurs : ne pas tenter de « corriger » les entrées mal formées
  • Sécurité en priorité : prévenir les attaques par injection et les ambiguïtés
  • Fusion de champs : l'analyseur DOIT combiner toutes les lignes de champs dont les noms correspondent (sans distinction de casse) dans la même section (en-tête ou pied de page) en une seule field-value séparée par des virgules

Note importante​

Pour les Lists et les Dictionaries, cela concatène correctement toutes les lignes du champ, à condition que les membres individuels de la structure de données de niveau supérieur ne soient pas répartis sur plusieurs instances d'en-tête.

Si l'analyse échoue (y compris lors de l'appel d'autres algorithmes), la valeur entière du champ DOIT (MUST) être ignorée (c'est-à-dire traitée comme si le champ n'existait pas dans cette section). Ceci est intentionnellement strict pour améliorer l'interopérabilité et la sécurité ; les spécifications référençant ce document ne sont pas autorisées à assouplir cette exigence.

4.2.1 Analyser une List (Parsing a List)​

Étant donné une chaîne ASCII input_string, retourner un tableau de tuples (item_or_inner_list, parameters). input_string est modifié pour supprimer les valeurs analysées.

Algorithme​

  1. Laisser members être un tableau vide.

  2. Tant que input_string n'est pas vide :

    • Ajouter le résultat de « Analyser un Item ou une Inner List » (section 4.2.1.1) à members
    • Supprimer tous les caractères OWS au début de input_string
    • Si input_string est vide, retourner members
    • Consommer le premier caractère de input_string ; s'il n'est pas « , », l'analyse échoue
    • Supprimer tous les caractères OWS au début de input_string
    • Si input_string est vide, il y a une virgule finale ; l'analyse échoue

  3. Aucune donnée structurée trouvée ; retourner members (vide).

4.2.1.1 Analyser un Item ou une Inner List (Parsing an Item or Inner List)​

Étant donné une chaîne ASCII input_string, retourner un tuple (item_or_inner_list, parameters).

Algorithme​

  1. Si le premier caractère de input_string est « ( », retourner le résultat de « Analyser une Inner List » (section 4.2.1.2).

  2. Retourner le résultat de « Analyser un Item » (section 4.2.3).

4.2.1.2 Analyser une Inner List (Parsing an Inner List)​

Étant donné une chaîne ASCII input_string, retourner un tuple (inner_list, parameters).

Algorithme​

  1. Consommer le premier caractère de input_string ; s'il n'est pas « ( », l'analyse échoue.

  2. Laisser inner_list être un tableau vide.

  3. Tant que input_string n'est pas vide :

    • Supprimer tous les caractères SP au début de input_string
    • Si le premier caractère de input_string est « ) » :
      • Consommer le premier caractère de input_string
      • Laisser parameters être le résultat de « Analyser des Parameters » (section 4.2.3.2)
      • Retourner le tuple (inner_list, parameters)
    • Laisser item être le résultat de « Analyser un Item » (section 4.2.3)
    • Ajouter item à inner_list
    • Si le premier caractère de input_string n'est pas SP ou « ) », l'analyse échoue

  4. Fin de Inner List non trouvée ; l'analyse échoue.

4.2.2 Analyser un Dictionary (Parsing a Dictionary)​

Étant donné une chaîne ASCII input_string, retourner une map ordonnée avec des valeurs de tuples (item_or_inner_list, parameters).

Algorithme​

  1. Laisser dictionary être une map ordonnée vide.

  2. Tant que input_string n'est pas vide :

    • Laisser this_key être le résultat de « Analyser une Key » (section 4.2.3.3)
    • Si le premier caractère de input_string est « = » :
      • Consommer le premier caractère de input_string
      • Laisser member être le résultat de « Analyser un Item ou une Inner List » (section 4.2.1.1)
    • Sinon :
      • Laisser value être Boolean true
      • Laisser parameters être le résultat de « Analyser des Parameters » (section 4.2.3.2)
      • Laisser member être le tuple (value, parameters)
    • Si dictionary contient déjà la clé this_key (comparaison caractère par caractère), remplacer sa valeur par member
    • Sinon, ajouter la clé this_key avec la valeur member à dictionary
    • Supprimer tous les caractères OWS au début de input_string
    • Si input_string est vide, retourner dictionary
    • Consommer le premier caractère de input_string ; s'il n'est pas « , », l'analyse échoue
    • Supprimer tous les caractères OWS au début de input_string
    • Si input_string est vide, il y a une virgule finale ; l'analyse échoue

  3. Aucune donnée structurée trouvée ; retourner dictionary (vide).

Note : Lorsque des clés Dictionary en double sont rencontrées, toutes les instances sauf la dernière sont ignorées.

4.2.3 Analyser un Item (Parsing an Item)​

Étant donné une chaîne ASCII input_string, retourner un tuple (bare_item, parameters).

Algorithme​

  1. Laisser bare_item être le résultat de « Analyser un Bare Item » (section 4.2.3.1).

  2. Laisser parameters être le résultat de « Analyser des Parameters » (section 4.2.3.2).

  3. Retourner le tuple (bare_item, parameters).

4.2.3.1 Analyser un Bare Item (Parsing a Bare Item)​

Étant donné une chaîne ASCII input_string, retourner un bare Item.

Algorithme​

  1. Si le premier caractère de input_string est « - » ou DIGIT, retourner le résultat de « Analyser un Integer ou Decimal » (section 4.2.4).

  2. Si le premier caractère de input_string est DQUOTE, retourner le résultat de « Analyser une String » (section 4.2.5).

  3. Si le premier caractère de input_string est ALPHA ou « * », retourner le résultat de « Analyser un Token » (section 4.2.6).

  4. Si le premier caractère de input_string est « : », retourner le résultat de « Analyser une Byte Sequence » (section 4.2.7).

  5. Si le premier caractère de input_string est « ? », retourner le résultat de « Analyser un Boolean » (section 4.2.8).

  6. Sinon, le type d'item est non reconnu ; l'analyse échoue.

4.2.3.2 Analyser des Parameters (Parsing Parameters)​

Étant donné une chaîne ASCII input_string, retourner une map ordonnée de bare Items.

Algorithme​

  1. Laisser parameters être une map ordonnée vide.

  2. Tant que input_string n'est pas vide :

    • Si le premier caractère de input_string n'est pas « ; », quitter la boucle
    • Consommer le caractère « ; » au début de input_string
    • Supprimer tous les caractères SP au début de input_string
    • Laisser param_key être le résultat de « Analyser une Key » (section 4.2.3.3)
    • Laisser param_value être Boolean true
    • Si le premier caractère de input_string est « = » :
      • Consommer le caractère « = » au début de input_string
      • Laisser param_value être le résultat de « Analyser un Bare Item » (section 4.2.3.1)
    • Si parameters contient déjà la clé param_key, remplacer sa valeur par param_value
    • Sinon, ajouter la clé param_key avec la valeur param_value à parameters

  3. Retourner parameters.

Note : Lorsque des clés de paramètres en double sont rencontrées, toutes les instances sauf la dernière sont ignorées.

4.2.3.3 Analyser une Key (Parsing a Key)​

Étant donné une chaîne ASCII input_string, retourner une key.

Algorithme​

  1. Si le premier caractère de input_string n'est pas lcalpha ou « * », l'analyse échoue.

  2. Laisser output_string être une chaîne vide.

  3. Tant que input_string n'est pas vide :

    • Si le premier caractère de input_string n'est pas lcalpha, DIGIT, « _ », « - », « . » ou « * », retourner output_string
    • Laisser char être le résultat de la consommation du premier caractère de input_string
    • Ajouter char à output_string

  4. Retourner output_string.

4.2.4 Analyser un Integer ou Decimal (Parsing an Integer or Decimal)​

Étant donné une chaîne ASCII input_string, retourner un Integer ou Decimal.

Note : Cet algorithme analyse à la fois les Integers (section 3.3.1) et les Decimals (section 3.3.2), et retourne la structure correspondante.

Algorithme​

  1. Laisser type être « integer ».

  2. Laisser sign être 1.

  3. Laisser input_number être une chaîne vide.

  4. Si le premier caractère de input_string est « - », le consommer et définir sign à -1.

  5. Si input_string est vide, il y a un entier vide ; l'analyse échoue.

  6. Si le premier caractère de input_string n'est pas DIGIT, l'analyse échoue.

  7. Tant que input_string n'est pas vide :

    • Laisser char être le résultat de la consommation du premier caractère de input_string
    • Si char est DIGIT, l'ajouter à input_number
    • Sinon, si type est « integer » et char est « . » :
      • Si input_number contient plus de 12 caractères, l'analyse échoue
      • Sinon, ajouter char à input_number et définir type à « decimal »
    • Sinon, remettre char au début de input_string et quitter la boucle
    • Si type est « integer » et input_number contient plus de 15 caractères, l'analyse échoue
    • Si type est « decimal » et input_number contient plus de 16 caractères, l'analyse échoue

  8. Si type est « integer » :

    • Analyser input_number comme entier, laisser output_number être le résultat multiplié par sign

  9. Sinon :

    • Si le dernier caractère de input_number est « . », l'analyse échoue
    • Si le nombre de caractères après « . » dans input_number est supérieur à 3, l'analyse échoue
    • Analyser input_number comme décimal, laisser output_number être le résultat multiplié par sign

  10. Retourner output_number.

4.2.5 Analyser une String (Parsing a String)​

Étant donné une chaîne ASCII input_string, retourner une String sans guillemets.

Algorithme​

  1. Laisser output_string être une chaîne vide.

  2. Si le premier caractère de input_string n'est pas DQUOTE, l'analyse échoue.

  3. Supprimer le premier caractère de input_string.

  4. Tant que input_string n'est pas vide :

    • Laisser char être le résultat de la consommation du premier caractère de input_string
    • Si char est une barre oblique inverse (« \ ») :
      • Si input_string est maintenant vide, l'analyse échoue
      • Laisser next_char être le résultat de la consommation du premier caractère de input_string
      • Si next_char n'est pas DQUOTE ou « \ », l'analyse échoue
      • Ajouter next_char à output_string
    • Sinon, si char est DQUOTE, retourner output_string
    • Sinon, si char est dans la plage %x00-1f ou %x7f-ff (c'est-à-dire pas dans VCHAR ou SP), l'analyse échoue
    • Sinon, ajouter char à output_string

  5. Fin de input_string atteinte sans trouver le DQUOTE de fermeture ; l'analyse échoue.

4.2.6 Analyser un Token (Parsing a Token)​

Étant donné une chaîne ASCII input_string, retourner un Token.

Algorithme​

  1. Si le premier caractère de input_string n'est pas ALPHA ou « * », l'analyse échoue.

  2. Laisser output_string être une chaîne vide.

  3. Tant que input_string n'est pas vide :

    • Si le premier caractère de input_string n'est pas dans tchar, « : » ou « / », retourner output_string
    • Laisser char être le résultat de la consommation du premier caractère de input_string
    • Ajouter char à output_string

  4. Retourner output_string.

4.2.7 Analyser une Byte Sequence (Parsing a Byte Sequence)​

Étant donné une chaîne ASCII input_string, retourner une Byte Sequence.

Algorithme​

  1. Si le premier caractère de input_string n'est pas « : », l'analyse échoue.

  2. Supprimer le premier caractère de input_string.

  3. S'il n'y a pas de caractère « : » avant la fin de input_string, l'analyse échoue.

  4. Laisser b64_content être le résultat de la consommation du contenu de input_string jusqu'à (mais sans inclure) la première instance du caractère « : ».

  5. Consommer le caractère « : » au début de input_string.

  6. Si b64_content contient des caractères qui ne sont pas dans ALPHA, DIGIT, « + », « / » et « = », l'analyse échoue.

  7. Laisser binary_content être le résultat du décodage base64 [RFC4648] de b64_content, en synthétisant le rembourrage si nécessaire. Si le décodage base64 échoue, l'analyse échoue.

  8. Retourner binary_content.

Notes d'implémentation :

  • Comme certaines implémentations base64 ne permettent pas de rejeter les données encodées sans rembourrage « = » correct, les analyseurs NE DEVRAIENT PAS (SHOULD NOT) échouer lorsque le rembourrage « = » est absent, sauf s'ils ne peuvent pas être configurés autrement.
  • Comme certaines implémentations base64 ne permettent pas de rejeter les données encodées avec des bits de rembourrage non nuls, les analyseurs NE DEVRAIENT PAS (SHOULD NOT) échouer en présence de bits de rembourrage non nuls, sauf s'ils ne peuvent pas être configurés autrement.
  • Les analyseurs DOIVENT (MUST) échouer sur les caractères en dehors de l'alphabet base64 et sur les sauts de ligne dans les données encodées.

4.2.8 Analyser un Boolean (Parsing a Boolean)​

Étant donné une chaîne ASCII input_string, retourner un Boolean.

Algorithme​

  1. Si le premier caractère de input_string n'est pas « ? », l'analyse échoue.

  2. Supprimer le premier caractère de input_string.

  3. Si le premier caractère de input_string correspond à « 1 », supprimer le premier caractère et retourner true.

  4. Si le premier caractère de input_string correspond à « 0 », supprimer le premier caractère et retourner false.

  5. Aucune valeur correspondante ; l'analyse échoue.

Exemples complets d'analyse​

Exemple d'analyse de List​

// Chaîne d'entrée
"42;a=1, foo, (1 2);b"

// Résultat de l'analyse
[
  (42, {a: 1}),
  ("foo", {}),
  ([1, 2], {b: true})
]

Exemple d'analyse de Dictionary​

// Chaîne d'entrée
"key1=42;a=1, key2, key3=(1 2)"

// Résultat de l'analyse
{
  key1: (42, {a: 1}),
  key2: (true, {}),
  key3: ([1, 2], {})
}

Exemple d'analyse d'Item​

// Chaîne d'entrée
"42;foo=\"bar\";flag"

// Résultat de l'analyse
(42, {foo: "bar", flag: true})

Exemples complets de sérialisation​

Exemple de List​

// Entrée
[
  (42, {a: 1}),
  ("foo", {}),
  ([1, 2], {b: true})
]

// Sortie
"42;a=1, foo, (1 2);b"

Exemple de Dictionary​

// Entrée
{
  key1: (42, {a: 1}),
  key2: (true, {}),
  key3: ([1, 2], {})
}

// Sortie
"key1=42;a=1, key2, key3=(1 2)"

Exemple d'Item​

// Entrée
(42, {foo: "bar", flag: true})

// Sortie
"42;foo=\"bar\";flag"

Points clés (Key Takeaways)​

Sérialisation​

  1. Gestion des valeurs vides : les List et Dictionary vides ne sont pas sérialisés (le champ entier est omis)
  2. Abréviation Boolean : la valeur true omet la partie « =value »
  3. Format strict : chaque type a des exigences de format précises
  4. Échec immédiat : tout échec de validation fait échouer immédiatement toute la sérialisation

Recommandations d'implémentation​

// Exemple de pseudo-code
function serializeStructuredField(field) {
  if (isEmpty(field)) {
    return null;  // ne pas sérialiser
  }
  
  try {
    if (field.type === 'list') {
      return serializeList(field.value);
    } else if (field.type === 'dictionary') {
      return serializeDictionary(field.value);
    } else if (field.type === 'item') {
      return serializeItem(field.value, field.parameters);
    }
  } catch (error) {
    // Échec de sérialisation, retourner une erreur
    throw new SerializationError(error);
  }
}

Aperçu de la section suivante​

La section 4.2 (algorithmes d'analyse) est tout aussi importante et définit comment analyser les valeurs de champs HTTP en données structurées. Les algorithmes d'analyse garantissent une validation stricte et une gestion cohérente des erreurs.

Note : Comme les algorithmes d'analyse sont très détaillés et symétriques à la sérialisation, les implémenteurs devraient se référer à la spécification complète de la RFC 8941 pour assurer une conformité totale.

Dernière mise à jour le