Il fut un temps où l’on utilisait XMLHttpRequest
pour créer des requêtes API. Il n’intégrait pas les promesses et n’était pas conçu pour générer des codes JavaScript propres. En utilisant jQuery, vous avez utilisé la syntaxe de nettoyage avec jQuery.ajax()
.
Maintenant, JavaScript intègre un moyen qui lui est propre de créer des requêtes API. Il s’agit de l’API Fetch, une nouvelle norme qui permet de réaliser des requêtes sur un serveur en utilisant des promesses. Elle intègre cependant bien d’autres fonctionnalités.
Au cours de ce tutoriel, vous allez apprendre à utiliser API Fetch pour réaliser des requêtes GET et POST.
Pour terminer ce tutoriel, vous aurez besoin des éléments suivants :
Pour utiliser l’API Fetch, appelez la méthode fetch
, qui accepte l’URL de l’API comme paramètre :
fetch(url)
Après la méthode fetch()
, ajoutez la méthode de promesse then()
:
.then(function() {
})
La méthode fetch()
retourne une promesse. Si la promesse renvoyée est resolve
, cela signifie que la fonction dans la méthode then()
est bien exécutée. Cette fonction contient le code qui permet de traiter les données reçues à partir de l’API.
Sous la méthode then()
, ajoutez la méthode catch()
:
.catch(function() {
});
Il se peut que l’API que vous appelez en utilisant fetch()
soit défaillante ou que d’autres erreurs se produisent. Le cas échéant, le système renverra la promesse reject
. Vous pouvez utiliser la méthode cath
pour gérer reject
. Le code dans catch()
sera exécuté dans le cas où une erreur se produit lors de l’appel de l’API de votre choix.
Pour résumer, l’utilisation de l’API Fetch ressemblera à l’exemple suivant :
fetch(url)
.then(function() {
})
.catch(function() {
});
En ayant une compréhension de la syntaxe qui permet d’utiliser l’API Fetch, vous pouvez désormais passer à l’utilisation de fetch()
sur une API réelle.
Les échantillons de code suivants seront basés sur l’API Random User. En utilisant l’API, vous obtiendrez dix utilisateurs que vous pourrez afficher sur la page en utilisant Vanilla JavaScript.
L’idée est de récupérer toutes les données de l’API Random User et de les afficher dans les éléments de la liste de l’auteur. Commencez par créer un fichier HTML, ajoutez un titre et une liste non ordonnée avec l’id
des authors
:
<h1>Authors</h1>
<ul id="authors"></ul>
Ajoutez maintenant les balises script
au bas de votre fichier HTML et utilisez un sélecteur DOM pour récupérer l’ul
. Utilisez l’argument getElementById
avec authors
. N’oubliez pas, authors
est l’id
de l’ul
précédemment créé :
<script>
const ul = document.getElementById('authors');
</script>
Créez une variable constante nommée url
qui contiendra l’URL de l’API qui renverra dix utilisateurs aléatoires :
const url = 'https://randomuser.me/api/?results=10';
Une fois que ul
et url
sont créés, il est temps pour vous de créer les fonctions qui serviront à créer les éléments de la liste. Créez une fonction appelée createNode
qui prend un paramètre appelé element
:
function createNode(element) {
}
Plus tard, lorsque vous appellerez createNode
, vous devrez transmettre le nom d’un élément HTML réel à créer.
Dans la fonction, ajoutez une instruction return
qui renvoie element
en utilisant document.createElement()
:
function createNode(element) {
return document.createElement(element);
}
En outre, vous devrez créer une fonction appelée append
qui intègre deux paramètres : parent
et el
:
function append(parent, el) {
}
Cette fonction ajoutera el
au parent
en utilisant document.createElement
:
function append(parent, el) {
return parent.appendChild(el);
}
createNode
et append
sont tous deux prêts à être utilisés. Maintenant, en utilisant l’API Fetch, appelez l’API Random User en utilisant fetch()
avec l’argument url
:
fetch(url)
fetch(url)
.then(function(data) {
})
})
.catch(function(error) {
});
Dans le code ci-dessus, vous appelez l’API Fetch et passez l’URL à l’API Random User. Ensuite, vous recevrez une réponse. Cependant, la réponse que vous obtenez n’est pas JSON, mais plutôt un objet avec une série de méthodes utilisables en fonction de ce que vous voulez faire avec les informations. Pour convertir l’objet renvoyé en JSON, utilisez la méthode json()
.
Ajoutez la méthode then()
qui contiendra une fonction avec un paramètre appelé resp
:
fetch(url)
.then((resp) => )
Le paramètre resp
prend la valeur de l’objet renvoyé de fetch(url)
. Utilisez la méthode json()
pour convertir resp
en données JSON :
fetch(url)
.then((resp) => resp.json())
Il vous reste encore à traiter les données JSON. Ajoutez une autre instruction then()
avec une fonction dont l’argument s’appelle data
:
.then(function(data) {
})
})
Dans cette fonction, créez une variable appelée authors
, qui est définie comme égale à data.results
:
.then(function(data) {
let authors = data.results;
Pour chaque auteur dans authors
, il vous faudra créer un élément de liste qui affiche leur photographie et leur nom respectifs. La méthode map()
est idéale pour faire cela :
let authors = data.results;
return authors.map(function(author) {
})
Dans votre fonction map
, créez une variable appelée li
qui sera définie comme égale à createNode
avec li
(l’élément HTML) comme argument :
return authors.map(function(author) {
let li = createNode('li');
})
Répétez cette manœuvre pour créer un élément span
et un élément img
:
let li = createNode('li');
let img = createNode('img');
let span = createNode('span');
L’API propose un nom pour l’auteur et une image qui accompagne le nom. Définissez l’img.src
sur l’image de l’auteur :
let img = createNode('img');
let span = createNode('span');
img.src = author.picture.medium;
L’élément span
doit contenir le prénom et le nom de famille de l’auteur
. Pour cela, utilisez la propriété innerHTML
et l’interpolation des chaînes de caractères :
img.src = author.picture.medium;
span.innerHTML = `${author.name.first} ${author.name.last}`;
Une fois l’image et l’élément de liste créés avec l’élément span
, vous pouvez utiliser la fonction append
précédemment créée pour afficher ces éléments sur la page :
append(li, img);
append(li, span);
append(ul, li);
Une fois les deux fonctions then()
terminées, vous pouvez maintenant ajouter la fonction catch()
. Cette fonction enregistrera l’erreur potentielle sur la console :
.catch(function(error) {
console.log(error);
});
Voici le code complet de la requête que vous avez créée :
function createNode(element) {
return document.createElement(element);
}
function append(parent, el) {
return parent.appendChild(el);
}
const ul = document.getElementById('authors');
const url = 'https://randomuser.me/api/?results=10';
fetch(url)
.then((resp) => resp.json())
.then(function(data) {
let authors = data.results;
return authors.map(function(author) {
let li = createNode('li');
let img = createNode('img');
let span = createNode('span');
img.src = author.picture.medium;
span.innerHTML = `${author.name.first} ${author.name.last}`;
append(li, img);
append(li, span);
append(ul, li);
})
})
.catch(function(error) {
console.log(error);
});
Vous avez réussi à réaliser une requête GET en utilisant l’API Random User et l’API Fetch. Au cours de la prochaine étape, vous allez apprendre à réaliser des requêtes POST.
Fetch utilise par défaut les requêtes GET, mais vous pouvez utiliser tous les autres types de requêtes, changer les en-têtes et envoyer des données. Pour ce faire, vous devez configurer votre objet et le passer comme le deuxième argument de la fonction fetch.
Avant de créer une requête POST, créez les données que vous souhaitez envoyer à l’API. Il s’agira d’un objet appelé data
avec le name
clé et la valeur Sammy
(ou votre nom) :
const url = 'https://randomuser.me/api';
let data = {
name: 'Sammy'
}
Veillez à bien inclure une variable constante qui contient le lien vers l’API Random User.
Comme il s’agit d’une requête POST, vous devrez l’indiquer de manière explicite. Créez un objet appelé fetchData
:
let fetchData = {
}
Cet objet doit inclure trois clés : method
, body
et headers
. La clé method
doit avoir la valeur 'POST'
. body
doit être défini comme égal à l’objet data
qui vient d’être créé. headers
devrait avoir la valeur des new Headers()
:
let fetchData = {
method: 'POST',
body: data,
headers: new Headers()
}
L’interface Headers
est une propriété de l’API Fetch qui vous permet d’effectuer diverses actions sur les en-têtes des requêtes et des réponses HTTP. Si vous souhaitez en savoir plus à ce sujet, vous pourrez trouver de plus amples informations dans l’article suivant : Comment définir les routes et les méthodes de requête HTTP dans Express.
Une fois ce code en place, vous pouvez réaliser la requête POST en utilisant l’API Fetch. Vous allez inclure url
et fetchData
comme arguments pour votre requête POST fetch
:
fetch(url, fetchData)
La fonction then()
comprendra un code qui gère la réponse reçue du serveur API Random User :
fetch(url, fetchData)
.then(function() {
// Handle response you get from the server
});
Vous disposez également d’une autre option pour créer un objet et utiliser la fonction fetch()
. Au lieu de créer un objet comme fetchData
, vous pouvez utiliser le constructeur de requêtes pour créer votre objet de requête. Pour ce faire, créez une variable appelée request
:
const url = 'https://randomuser.me/api';
let data = {
name: 'Sara'
}
var request =
La variable request
doit être configurée comme new Request
. La construction New Request
prend deux arguments : l’url de l’API url (url
) et un objet. L’objet doit également inclure les clés method
, body
et headers
tout comme fetchData
:
var request = new Request(url, {
method: 'POST',
body: data,
headers: new Headers()
});
Maintenant, vous pouvez utiliser request
comme le seul argument de fetch()
car il inclut également l’url de l’API :
fetch(request)
.then(function() {
// Handle response we get from the API
})
L’ensemble de votre code ressemblera à ce qui suit :
const url = 'https://randomuser.me/api';
let data = {
name: 'Sara'
}
var request = new Request(url, {
method: 'POST',
body: data,
headers: new Headers()
});
fetch(request)
.then(function() {
// Handle response we get from the API
})
Vous connaissez maintenant deux méthodes qui vous permettront de créer et d’exécuter des requêtes POST avec l’API Fetch.
Même si la plupart des navigateurs ne prennent pas l’API Fetch en charge, il s’agit d’une superbe alternative à XMLHttpRequest. Si vous souhaitez apprendre à appeler les API Web en utilisant React, consultez cet article sur ce même sujet.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!
Hello, Nice Javascript. How to do to import the contains of an input in the const url ? (my api has a query so I have to use of a variable in the const url) Thanks