Wikipédia abstraite/Canonique et normal

This page is a translated version of the page Abstract Wikipedia/Canonical and normal and the translation is 100% complete.

Nous avons eu récemment quelques discussions concernant les formes canonique et normale pour la représentation en JSON des Objets-Z.

Pour la plupart des contributeurs et utilisateurs de Wikifonctions, ceci ne devrait ne pas importer en réalité : l’interface utilisateur devrait effectivement les mettre ne pas les exposer à la représentation JSON. Mais pour ces cas où cela compte, voici quelques éléments de fond.

De nombreux objets JSON peuvent effectivement décrire le même Objet-Z. Il y a deux formes bien définies : la forme normale et la forme canonique. Celles-ci sont celles utilisées dans le système. Parfois, des contributeurs pourraient écrire quelque chose à mi-chemin des deux, et toutes les parties du système devraient l’accepter.

La normalisation devrait toujours retourner la même forme normale pour toute entrée bien formée. La canonicalisation devrait toujours retourner la même forme canonique pour toute entrée bien formée. La plupart des endroits ne devraient donc pas avoir à se préoccuper de ce qui est reçu, tant que c’est bien formé. Ils peuvent simplement canonicaliser ou normaliser leur entrée pour l’obtenir dans le format sous lequel ils désirent travailler.

En interne, nous stockons la forme canonique dans la base de donnée et utilisons de préférence la forme canonique pour l’afficher à l’utilisateur. La forme normale est utilisée dans la plupart des autres cas, notamment lors du traitement des données dans l’orchestrateur ou dans le frontal.

Finalement, il y a ce qu’on appelle la labellisation. Ceci consiste simplement à remplacer chaque ZID d’objet ou chaque référence de clé avec le libellé dans la langue donnée. Ceci est habituellement une étape produisant de la perte d’information : un délibelleur ne fonctionnera pas nécessairement. Ceci n’est purement destiné aux fins de sortie pour l’affichage. Dans ce qui suit, nous montrons la version libellée à gauche et la version brute à droite.

Voici un appel de fonction en forme normale :

Forme lisible par un humain

Forme normale

{
  "type": {
    "type": "Reference",
    "reference ID": "Function call"
  },
  "function": {
    "type": "Reference",
    "reference ID": "Head"
  },
  "list": {
    "type": "List",
    "head": {
      "type": "String",
      "value": "a"
    },
    "tail": {
        "type": "List"
    }
  }
}

{
  "Z1K1": {
    "Z1K1": "Z9",
    "Z9K1": "Z7"
  },
  "Z7K1": {
    "Z1K1": "Z9",
    "Z9K1": "Z811"
  },
  "Z811K1": {
    "Z1K1": "Z10",
    "Z10K1": {
      "Z1K1": "Z6",
      "Z6K1": "a"
    },
    "Z10K2": {
        "Z1K1": "Z10"
    }
  }
}

Le même appel en forme canonique :

Forme lisible par un humain	Forme canonique
{ "type": "Function call", "function": "Head", "list": [ "a" ] }	{ "Z1K1": "Z7", "Z7K1": "Z811", "Z811K1": [ "a" ] }

Le même appel de fonction dans ce que la poupart des développeurs de logiciel considérait comme une forme raisonnablement lisible :

Head(["a"])

Ceci est l’appel à la fonction Head (Tête) avec un argument qui est une liste qui comprend ici un seul élément, cet élément étant la chaîne "a". Head retourne le premier élément d’une liste, donc le résultats de cet appel de fonctions serait, en forme normale :

{ "type": "String", "value": "a" }	{ "Z1K1": "Z6", "Z6K1": "a" }

ou simplemement en forme canonique :

"a"

Puisque nous sommes parfois confus par la terminologie, nous appelons forme « longue » ou « explicite » la forme normale. Le terme « normal » est inspiré par le concept de normalisation des bases de données. Le forme canonique est ce que nous appelons également forme « courte » ou « compacte », car elle est habituellement bien plus courte. La canonicalisation est le terme usuel pour cette étape en informatique. Notez qu’en informatique la canonicalisation et la normalisation sont souvent synonymes l’une de l’autre, c’est pourquoi les formes « courte » ou « longue » conduisent à moins de confusion.