Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Propriétés supplémentaires de GraphQL
<a name="graphql-properties"></a>

GraphQL repose sur plusieurs principes de conception visant à maintenir la simplicité et la robustesse à grande échelle.

## Déclaratif
<a name="declarative-property"></a>

GraphQL est déclaratif, ce qui signifie que l'utilisateur décrira (façonnera) les données en déclarant uniquement les champs qu'il souhaite interroger. La réponse renverra uniquement les données relatives à ces propriétés. Par exemple, voici une opération qui récupère un `Book` objet dans une table DynamoDB dont la valeur ISBN 13 est : `id` *9780199536061*

```
{
  getBook(id: "9780199536061") {
    name
    year
    author
  }
}
```

La réponse renverra les champs de la charge utile (`name`,`year`, et`author`) et rien d'autre :

```
{
  "data": {
    "getBook": {
      "name": "Anna Karenina",
      "year": "1878",
      "author": "Leo Tolstoy",
    }
  }
}
```

Grâce à ce principe de conception, GraphQL élimine les problèmes récurrents de surextraction et de sous-extraction auxquels REST est confronté dans les systèmes APIs complexes. Cela se traduit par une collecte de données plus efficace et une amélioration des performances du réseau.

## Hiérarchique
<a name="hierarchical-property"></a>

GraphQL est flexible dans la mesure où les données demandées peuvent être façonnées par l'utilisateur pour répondre aux besoins de l'application. Les données demandées suivent toujours les types et la syntaxe des propriétés définies dans votre API GraphQL. Par exemple, l'extrait suivant montre l'`getBook`opération avec une nouvelle portée de champ appelée `quotes` qui renvoie toutes les chaînes de guillemets stockées et les pages liées au : `Book` *9780199536061*

```
{
  getBook(id: "9780199536061") {
    name
    year
    author
    quotes {
      description
      page
    }
  }
}
```

L'exécution de cette requête renvoie le résultat suivant :

```
{
  "data": {
    "getBook": {
      "name": "Anna Karenina",
      "year": "1878",
      "author": "Leo Tolstoy",
      "quotes": [
         {
            "description": "The highest Petersburg society is essentially one: in it everyone knows everyone else, everyone even visits everyone else.",
            "page": 135
         },
         { 
            "description": "Happy families are all alike; every unhappy family is unhappy in its own way.",
            "page": 1
         },
         {        
            "description": "To Konstantin, the peasant was simply the chief partner in their common labor.",
            "page": 251
         }
      ]
    }
  }
}
```

Comme vous pouvez le constater, les `quotes` champs liés au livre demandé ont été renvoyés sous forme de tableau dans le même format que celui décrit dans notre requête. Bien qu'il n'ait pas été présenté ici, GraphQL présente l'avantage supplémentaire de ne pas être précis quant à l'emplacement des données qu'il récupère. `Books`et `quotes` pourraient être stockés séparément, mais GraphQL récupérera toujours les informations tant que l'association existe. Cela signifie que votre requête peut récupérer une multitude de données autonomes en une seule demande.

## Introspectif
<a name="introspective-property"></a>

GraphQL est autodocumenté, c'est-à-dire introspectif. Il prend en charge plusieurs opérations intégrées qui permettent aux utilisateurs de visualiser les types et les champs sous-jacents du schéma. Par exemple, voici un `Foo` type avec un `description` champ `date` et :

```
type Foo {
	date: String
	description: String
}
```

Nous pourrions utiliser l'`_type`opération pour trouver les métadonnées de saisie sous le schéma :

```
{
  __type(name: "Foo") {
    name                   # returns the name of the type
    fields {               # returns all fields in the type
      name                 # returns the name of each field
      type {               # returns all types for each field
        name               # returns the scalar type
      }
    }
  }
}
```

Cela renverra une réponse :

```
{
  "__type": {
    "name": "Foo",                     # The type name
    "fields": [
      {
        "name": "date",                # The date field
        "type": { "name": "String" }   # The date's type
      },
      {
        "name": "description",         # The description field
        "type": { "name": "String" }   # The description's type
      },
    ]
  }
}
```

Cette fonctionnalité peut être utilisée pour déterminer les types et les champs pris en charge par un schéma GraphQL particulier. GraphQL prend en charge une grande variété de ces opérations introspectives. Pour plus d'informations, consultez la section [Introspection](https://graphql.org/learn/introspection/).

## Typographie forte
<a name="strong-typing-property"></a>

GraphQL prend en charge la saisie forte grâce à son système de types et de champs. Lorsque vous définissez un élément dans votre schéma, il doit avoir un type qui peut être validé avant l'exécution. Il doit également suivre les spécifications de syntaxe de GraphQL. Ce concept n'est pas différent de la programmation dans d'autres langages. Par exemple, voici le `Foo` type précédent :

```
type Foo {
	date: String
	description: String
}
```

Nous pouvons voir que `Foo` c'est l'objet qui sera créé. À l'intérieur d'une instance de`Foo`, il y aura un `description` champ `date` et, tous deux de type `String` primitif (scalaire). Syntaxiquement, nous voyons que cela `Foo` a été déclaré et que ses champs existent dans son champ d'application. Cette combinaison de vérification de type et de syntaxe logique garantit que votre API GraphQL est concise et évidente. Les spécifications de typage et de syntaxe de GraphQL se trouvent [ici](https://spec.graphql.org/).