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
GraphQL repose sur plusieurs principes de conception pour maintenir la simplicité et la robustesse à grande échelle.
## Déclaratif
GraphQL est déclaratif, ce qui signifie que l'utilisateur va décrire (mettre en forme) les données en déclarant uniquement les champs qu'il souhaite interroger. La réponse renverra uniquement les données pour ces propriétés. Par exemple, voici une opération qui extrait un `Book` objet dans une table DynamoDB dont la valeur ISBN 13 est la suivante : `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 liés à la surestimation et à la sous-extraction auxquels les API REST sont confrontées dans les systèmes complexes. Il en résulte une collecte de données plus efficace et une amélioration des performances du réseau.
## Hiérarchique
GraphQL est flexible dans la mesure où les données demandées peuvent être mises en forme 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 étendue 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 voir, 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 par notre requête. Bien que cela n'ait pas été illustré 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ées 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
GraphQL s'auto-documente ou est 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 cette `_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écouvrir 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, voir [ Introspection](https://graphql.org/learn/introspection/).
## dactylographie forte
GraphQL prend en charge la saisie forte grâce à son système de types et de champs. Lorsque vous définissez quelque chose dans votre schéma, celui-ci doit avoir un type qui peut être validé avant l'exécution. Il doit également respecter la spécification 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éé. Dans 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 sa portée. Cette combinaison de vérification de type et de syntaxe logique garantit que votre API GraphQL est concise et évidente. La spécification de typage et de syntaxe de GraphQL se trouve [ ici. ](https://spec.graphql.org/)