Aller au contenu
English

L'essentiel de JavaScript

  • Leçon 3
  • 60 min
  • Module 1 : Premiers pas avec le Web

Où nous en sommes

Dans la leçon précédente, nous avons écrit la première page du bureau des billets avec HTML et CSS. Elle a la bonne apparence, mais elle ne fait rien : la liste affiche toujours « Loading… », et Send ticket recharge seulement la page. HTML et CSS ne peuvent pas demander des données à l'API. Dans cette leçon, nous apprenons les éléments de JavaScript qui font fonctionner la page, et nous les utilisons pour charger les billets et envoyer le formulaire.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Faites fonctionner la première page : chargez les billets de soutien les plus récents depuis l’API simulée. Envoyez aussi le formulaire pour créer un billet. Vous apprendrez les éléments de JavaScript utilisés dans toutes les leçons suivantes : objets, tableaux, fonctions, modules, événements et promesses.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 60 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • ~/projects/ticket-desk avec les deux fichiers de la dernière leçon, et l’API simulée en cours d’exécution dans le terminal 1.
  • Node.js 24, pour exécuter les petits exemples dans le terminal 2.

À la fin, le dossier contient un nouveau fichier, bridge/app.js, identique à celui de l’instantané end-of-m01.

La première page a la bonne apparence, mais elle ne fait rien. La liste affiche toujours « Loading… » (chargement…). Send ticket (envoyer le billet) recharge la page, et aucun billet n’arrive à l’API. HTML décrit une page, et CSS définit son apparence. Aucun des deux ne peut demander des données à l’API, attendre la réponse ou réagir quand l’agent sélectionne un bouton.

C’est le rôle de JavaScript : un langage de programmation que le navigateur exécute dans la page. Vous connaissez Python, donc la plupart des idées vous sont familières. Les mots diffèrent, et deux idées sont nouvelles : les événements et les promesses. Cette leçon enseigne chaque idée avec un petit programme à exécuter avec Node.js dans le terminal 2. Elle l’utilise ensuite dans la page.

Un billet de l’API est un ensemble de valeurs nommées : un identifiant, un sujet, une équipe. En Python, vous conservez cela dans un dictionnaire. En JavaScript, c’est un objet : des noms et des valeurs entre accolades. Une liste de billets est un tableau : des valeurs entre crochets, comme une liste Python.

Créez un dossier try dans ticket-desk, puis un fichier try/values.mjs avec trois vrais billets de l’API simulée :

try/values.mjs
// Objects, arrays and functions: three tickets of the mock API, without a browser.
const ticket = { ticket_id: 'T-80009', subject: 'My order LK-55190 never arrived', team: 'shipping', priority: 2 };
console.log(ticket.subject);
console.log(ticket['team']);
console.log(ticket.owner);
const tickets = [
ticket,
{ ticket_id: 'T-80008', subject: 'Hello, where is my order LK-581106?', team: 'shipping', priority: 2 },
{ ticket_id: 'T-80007', subject: 'You charged my card twice', team: 'billing', priority: 1 },
];
console.log(tickets.length, tickets[2].ticket_id);
function line(t) {
return `${t.ticket_id}: ${t.subject}`;
}
const shipping = tickets.filter((t) => t.team === 'shipping');
console.log(shipping.map(line));
console.log(JSON.stringify(tickets[2]));

Exécutez-le dans le terminal 2, dans le dossier ticket-desk :

Fenêtre de terminal
node try/values.mjs
My order LK-55190 never arrived
shipping
undefined
3 T-80007
[
'T-80009: My order LK-55190 never arrived',
'T-80008: Hello, where is my order LK-581106?'
]
{"ticket_id":"T-80007","subject":"You charged my card twice","team":"billing","priority":1}

Examinez la sortie ligne par ligne :

  • const ticket = {…} donne un nom à une valeur. const signifie que le nom pointe toujours vers cette valeur. let crée un nom qui pourra pointer vers une autre valeur plus tard. console.log affiche une valeur, comme print en Python.
  • ticket.subject et ticket['team'] lisent une valeur à partir de son nom.
  • ticket.owner affiche undefined (non défini). L’objet n’a pas de owner, et JavaScript ne s’arrête pas avec une erreur, contrairement à KeyError en Python. Il donne la valeur spéciale undefined : « il n’y a rien ici ». Cela cause souvent des erreurs qui passent inaperçues. TypeScript aide à les éviter dans la prochaine leçon.
  • tickets.length est le nombre d’éléments, comme len() en Python. tickets[2] est le troisième élément : le compte commence à 0.

Le tableau place les mots que vous connaissez à côté de leur forme JavaScript :

Python JavaScript
{"team": "shipping"} (dictionnaire) { team: 'shipping' } (objet)
[1, 2, 3] (liste) [1, 2, 3] (tableau)
None null, et undefined pour « absent »
True, False true, false
f"{t['ticket_id']}: …" `${t.ticket_id}: …` (un littéral de gabarit, avec des accents graves)
print(x) console.log(x)
json.dumps(x), json.loads(s) JSON.stringify(x), JSON.parse(s)

Une fonction est un bloc de code nommé qui reçoit des valeurs et renvoie une valeur. function line(t) { … return …; } représente la même idée que def line(t): en Python. Le corps est entre accolades plutôt que défini par l’indentation, et les instructions se terminent par ;.

JavaScript a une forme courte, la fonction fléchée : (t) => t.team === 'shipping' reçoit t et renvoie la valeur après la flèche. Elle ressemble à lambda en Python. Utilisez-la pour les petites fonctions que vous passez à d’autres fonctions.

Les tableaux ont des méthodes qui reçoivent une telle fonction. filter garde les éléments pour lesquels la fonction renvoie true : ici, les deux billets d’expédition. map crée un nouveau tableau avec le résultat de la fonction pour chaque élément : ici, une ligne de texte par billet. Lisez shipping.map(line) comme « pour chaque billet d’expédition, créez sa ligne ». Notez === : cet opérateur compare deux valeurs sans convertir leurs types. Utilisez toujours === en JavaScript, jamais ==.

Un programme grandit. Vous voulez séparer le code qui met en forme un billet du code qui l’utilise, comme le permet import en Python. En JavaScript, chaque fichier est un module. Un module exporte les noms que d’autres fichiers peuvent utiliser, et un autre module les importe.

try/lines.mjs
// lines.mjs: one function, exported so another file can use it.
export function line(t) {
return `${t.ticket_id}: ${t.subject}`;
}
try/main.mjs
// main.mjs: imports the function from lines.mjs.
import { line } from './lines.mjs';
console.log(line({ ticket_id: 'T-80008', subject: 'Hello, where is my order LK-581106?' }));
Fenêtre de terminal
node try/main.mjs
T-80008: Hello, where is my order LK-581106?

./lines.mjs est un chemin situé à côté du fichier qui l’importe. Retirez le mot export, puis exécutez le programme de nouveau. L’importation échoue avant l’exécution de toute ligne :

SyntaxError: The requested module './lines.mjs' does not provide an export named 'line'

Un module cache donc tout ce qu’il n’exporte pas. Dans un navigateur, <script type="module" src="app.js"> charge app.js comme un module, avec les mêmes règles. À partir du module 2, le bureau des billets contient plusieurs modules, chacun avec une seule responsabilité.

Vous ne restez pas toute la journée devant votre porte pour voir si quelqu’un arrive. Vous avez une sonnette. Quand elle sonne, vous ouvrez la porte. La sonnerie est un événement, et ouvrir la porte est votre réaction.

Une page a le même problème. JavaScript exécute son fichier une fois, du début à la fin, au chargement de la page. Mais l’agent sélectionne Send ticket plus tard, peut-être après une minute. Le code ne peut pas attendre à cette ligne. Il indique plutôt à l’avance quoi faire quand l’événement se produit. Il ajoute un écouteur, une fonction que le navigateur appelle à chaque événement.

try/doorbell.mjs
// An event: say what to do when it happens, then wait.
const door = new EventTarget();
door.addEventListener('ring', (event) => console.log('Open the door for the', event.type));
console.log('Nothing happens yet.');
door.dispatchEvent(new Event('ring'));
door.dispatchEvent(new Event('ring'));
Nothing happens yet.
Open the door for the ring
Open the door for the ring

L’ajout de l’écouteur ne fait rien immédiatement. Chaque ring appelle la fonction une fois. Node.js possède aussi EventTarget, donc vous pouvez l’essayer ici. Dans le navigateur, chaque élément est une cible d’événement. Un bouton reçoit des événements click (clic), un champ reçoit des événements input (saisie). Un formulaire reçoit un événement submit (envoi) quand on l’envoie. Chaque événement s’accompagne d’un objet qui le décrit, ici event, avec event.type et d’autres propriétés.

Dans certains restaurants, vous commandez au comptoir et vous recevez un avertisseur. Vous vous asseyez et vous discutez. Quand le repas est prêt, l’avertisseur sonne et vous allez le chercher. Si la cuisine n’a plus ce que vous avez commandé, on vous le signale plutôt. Vous ne restez pas au comptoir pendant la cuisson de la soupe.

Une requête à une API ressemble à cette commande. Elle prend du temps : environ 60 ms pour la liste simulée, et plusieurs secondes pour un brouillon produit par l’IA. Si la page s’arrêtait pour attendre, l’agent ne pourrait ni écrire ni faire défiler la page pendant ce temps. Ainsi, fetch, la fonction du navigateur qui envoie une requête, ne renvoie pas la réponse. Elle renvoie une promesse : un objet qui représente une valeur à venir. Une promesse est d’abord en attente, puis tenue avec une valeur, ou rejetée avec une erreur.

Voyez d’abord le problème. Ce programme envoie une requête à l’API simulée et utilise le résultat immédiatement :

try/forgot.mjs
// A mistake on purpose: no await.
const response = fetch('http://127.0.0.1:8100/v1/tickets?limit=2');
console.log(response);
console.log(response.status);
Promise { <pending> }
undefined

response n’est pas la réponse : c’est l’avertisseur. Son status est undefined, car une promesse n’a pas de status. Voyez maintenant l’ordre des événements avec un avertisseur qui sonne après 500 ms :

try/buzzer.mjs
// A promise is a buzzer: you get it at once, and it buzzes later.
console.log('1. Order the food');
const buzzer = new Promise((resolve) => setTimeout(() => resolve('soup'), 500));
console.log('2. Sit down. The buzzer is', buzzer);
buzzer.then((food) => console.log('4. Collect the', food, '- the buzzer is now', buzzer));
console.log('3. Talk with a friend');
1. Order the food
2. Sit down. The buzzer is Promise { <pending> }
3. Talk with a friend
4. Collect the soup - the buzzer is now Promise { 'soup' }

La ligne 3 s’affiche avant la ligne 4, même si elle vient plus tard dans le fichier. Le programme n’a pas attendu. then indique quoi faire quand la promesse est tenue.

then fonctionne, mais les longues chaînes de then sont difficiles à lire. JavaScript permet d’écrire la même chose plus brièvement : async et await. Dans une fonction marquée async, await promise suspend seulement cette fonction jusqu’à ce que la promesse soit tenue. Il donne ensuite sa valeur. Le reste de la page continue de fonctionner. Si la promesse est rejetée, await lance l’erreur, et try … catch l’intercepte, comme try … except en Python.

try/wait.mjs
// The same request, with await: wait for the answer, then use it.
async function loadTickets(limit) {
const response = await fetch(`http://127.0.0.1:8100/v1/tickets?limit=${limit}`);
if (!response.ok) {
throw new Error(`The API answered ${response.status}`);
}
const page = await response.json();
return page.items;
}
const started = performance.now();
const waiting = loadTickets(2);
console.log('1. asked; the answer is', waiting);
const items = await waiting;
console.log('2. answered after', Math.round(performance.now() - started), 'ms');
console.log(items.map((t) => t.ticket_id));
try {
await loadTickets(500);
} catch (error) {
console.log('3. failed:', error.message);
}
1. asked; the answer is Promise { <pending> }
2. answered after 80 ms
[ 'T-80010', 'T-80009' ]
3. failed: The API answered 422

Suivez les valeurs. Une fonction async renvoie toujours une promesse, donc waiting est d’abord en attente. Les lignes à l’extérieur de la fonction utilisent aussi await. Un fichier module (.mjs) permet d’utiliser await au niveau supérieur. await waiting donne le tableau après 80 ms sur l’ordinateur de l’auteur; votre durée sera différente. Il y a deux attentes à l’intérieur : une pour le début de la réponse et une pour son corps. response.json() lit le corps et transforme le texte JSON en objet.

Le dernier appel demande 500 billets. L’API en permet au plus 100, donc elle répond 422. fetch ne rejette pas une promesse pour un code d’état d’erreur : une réponse 422 reste une réponse. C’est pourquoi loadTickets vérifie response.ok, qui vaut true seulement pour un code d’état 2xx, et lance sa propre erreur. fetch rejette la promesse seulement si aucune réponse n’arrive.

Assemblez maintenant les éléments dans la page. Créez bridge/app.js :

bridge/app.js
// Module 1's JavaScript: show the newest tickets and send the form to the mock API.
// The page and the API come from the same address (http://127.0.0.1:8100), so the paths start with /.
/** Reads one page of tickets from the API. */
async function loadTickets(limit) {
const response = await fetch(`/v1/tickets?limit=${limit}`);
if (!response.ok) {
throw new Error(`The API answered ${response.status}`);
}
const page = await response.json();
return page.items;
}
/** Makes one list item for a ticket. */
function ticketItem(ticket) {
const item = document.createElement('li');
const title = document.createElement('strong');
title.textContent = `${ticket.ticket_id}: ${ticket.subject}`;
const meta = document.createElement('div');
meta.className = 'meta';
meta.textContent = `${ticket.customer_name} · ${ticket.team} · ${ticket.status}`;
item.append(title, meta);
return item;
}
async function showTickets() {
const list = document.querySelector('#tickets');
try {
const tickets = await loadTickets(10);
list.replaceChildren(...tickets.map(ticketItem));
} catch (error) {
list.replaceChildren(`Could not load the tickets. ${error.message}`);
}
}
const form = document.querySelector('#new-ticket');
const answer = document.querySelector('#answer');
form.addEventListener('submit', async (event) => {
event.preventDefault(); // stay on this page: JavaScript sends the form
const data = Object.fromEntries(new FormData(form));
answer.textContent = 'Sending…';
try {
const response = await fetch('/v1/tickets', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(data),
});
const body = await response.json();
if (response.ok) {
answer.textContent = `Saved as ${body.ticket_id}. AI work: ${body.state} (job ${body.job_id}).`;
form.reset();
showTickets();
} else {
answer.textContent = `Not saved: ${body.error.message} Fields: ${body.error.fields.join(', ')}`;
}
} catch (error) {
answer.textContent = `The API did not answer. Is it running? (${error.message})`;
}
});
showTickets();

loadTickets est la fonction de wait.mjs, avec un changement : le chemin commence par /. La page vient de http://127.0.0.1:8100, donc /v1/tickets désigne la même adresse. Deux nouveaux éléments demandent une explication.

La page sous forme d’objets. Le navigateur transforme le HTML en un arbre d’objets, un par élément. JavaScript lit et modifie la page à travers cet arbre, appelé DOM (Document Object Model, ou modèle objet du document). document.querySelector('#tickets') trouve l’élément avec id="tickets", avec les mêmes sélecteurs qu’en CSS. document.createElement('li') crée un élément, et textContent définit son texte. replaceChildren remplace l’élément « Loading… » par les nouveaux éléments. Les trois points dans replaceChildren(...items) décomposent le tableau : chaque élément devient un argument distinct, comme avec *items en Python. Navigateur et outils de construction examine le DOM dans les outils du navigateur.

Trois boîtes de gauche à droite. Première boîte : texte de l'API, le JSON du billet T-80010 avec customer_name Test Customer, subject Return label for my order LK-300210, team other, status open. Une flèche étiquetée await response.json() mène à la deuxième boîte : un objet JavaScript ticket avec les mêmes champs. Une flèche étiquetée ticketItem(ticket) mène à la troisième boîte : un nouvel élément li avec un élément strong T-80010: Return label for my order LK-300210, et un div de classe meta, Test Customer · other · open. Une note : page.items.map(ticketItem) fait l'étape 3 pour chacun des 10 billets, et list.replaceChildren place les 10 nouveaux éléments li dans la page.
Le trajet d'un billet, du texte de l'API à l'écran : texte JSON, puis objet JavaScript, puis nouvel élément de liste dans le DOM.
Description textuelle du diagramme

L’API envoie du texte. await response.json() transforme le texte en objets JavaScript. ticketItem(ticket) crée un nouvel élément <li> avec l’identifiant et le sujet en gras. Il ajoute aussi une ligne avec le client, l’équipe et l’état. map fait cela pour les dix billets, et replaceChildren place les dix nouveaux éléments dans la liste de la page.

L’événement d’envoi. L’écouteur du formulaire s’exécute à chaque submit. Sa première ligne, event.preventDefault(), empêche l’envoi habituel du formulaire par le navigateur. C’est le GET vers la même page que vous avez vu dans la dernière leçon. Ensuite, new FormData(form) lit chaque champ à partir de son name. Object.fromEntries en fait un objet : {customer_id: 'C-0022', subject: '…', body: '…'}. JSON.stringify le transforme en texte pour le POST. Chaque réponse va dans <p id="answer" role="status">, qu’un lecteur d’écran lit quand son contenu change.

Notez aussi textContent. Le sujet est un texte écrit par un client. textContent l’affiche toujours comme du texte, même s’il contient < et >. Une leçon ultérieure sur la sécurité du navigateur montre les problèmes causés par l’insertion d’un tel texte comme du HTML.

  1. Enregistrez bridge/app.js, puis rechargez http://127.0.0.1:8100/. La liste affiche les dix billets les plus récents.

  2. Remplissez le formulaire : C-0022, Parcel lost (colis perdu), It did not arrive. (il n’est pas arrivé). Sélectionnez Send ticket.

  3. Lisez la réponse sous le bouton et le premier élément de la liste.

La première page avec la liste remplie : dix billets de T-80010 Return label for my order LK-300210 à T-80001, chacun avec le client, l'équipe et l'état en gris sous son sujet.
Après app.js : les dix billets les plus récents de l'API simulée, du plus récent au plus ancien. L’image est en anglais.
La même page après l'envoi du formulaire : sous le bouton Send ticket, le texte Saved as T-500001. AI work : queued (job 1). La liste commence maintenant par T-500001: Parcel lost, Customer C-0022, other, open.
Après Send ticket : l'API a enregistré T-500001, et son traitement par l'IA attend dans une file. La page a redemandé la liste, donc le nouveau billet est en premier. L’image est en anglais.

La réponse dit Saved as T-500001. AI work: queued (job 1). (enregistré sous T-500001. Traitement par l’IA : en file d’attente, tâche 1). L’API a enregistré le billet, et son traitement par l’IA attend dans une file comme tâche en arrière-plan. Le module 4 montre cette tâche. Le terminal 1 consigne chaque requête de la page, dans l’ordre :

GET / 200 2 ms
GET /styles.css 200 1 ms
GET /app.js 200 1 ms
GET /v1/tickets?limit=10 200 63 ms
POST /v1/tickets 202 1 ms
GET /v1/tickets?limit=10 200 62 ms

Le diagramme place ces requêtes sur une ligne du temps, avec ce que la page fait entre elles.

Un diagramme de séquence entre le navigateur, avec la page et app.js, et l'API de billets simulée à 127.0.0.1:8100. Le navigateur demande /, reçoit index.html, demande styles.css et app.js, puis les reçoit. Une note : app.js s'exécute, showTickets appelle fetch, reçoit une promesse et attend; la page répond toujours aux clics et à la saisie. Le navigateur envoie GET /v1/tickets?limit=10 et reçoit 200 avec le JSON de 10 billets après environ 60 ms. Une note : la promesse est tenue et le code affiche 10 éléments de liste. Une note : plus tard, l'agent sélectionne Send ticket, un événement submit. Le navigateur envoie POST /v1/tickets avec un corps JSON et reçoit 202 avec ticket_id T-500001 et state queued. Il envoie de nouveau GET /v1/tickets?limit=10 et reçoit 200, avec T-500001 en premier.
Les requêtes de la page dans l'ordre. Entre elles, la page attend des promesses et des événements, et reste utilisable.
Description textuelle du diagramme

D’abord, le navigateur reçoit les trois fichiers de la page. Ensuite, app.js s’exécute, et son fetch envoie la requête pour la liste. Pendant que la promesse est en attente, la page fonctionne toujours. Après environ 60 ms (temps serveur simulé), la réponse arrive et le code affiche dix éléments. Plus tard, l’agent envoie le formulaire : un événement d’envoi. Le script envoie POST /v1/tickets, reçoit 202 avec T-500001, puis redemande la liste.

Vous pouvez voir les mêmes requêtes dans le navigateur. Ouvrez les outils de développement (F12, ou Cmd+Option+I sur macOS), sélectionnez l’onglet Network (réseau), puis rechargez la page. Vous connaissez cet onglet grâce à Examiner une requête.

La première page à gauche, et le panneau Network de Chrome à droite avec quatre lignes, toutes avec le code d'état 200 : le document 127.0.0.1, styles.css et app.js, tous deux demandés par la page index, et tickets?limit=10 de type fetch, demandé par app.js à la ligne 6. La ligne du bas indique 4 requests, 8.7 kB transferred.
Le panneau Network de Chrome après un rechargement : la page, ses deux fichiers et la requête pour la liste envoyée par app.js. La colonne Initiator (initiateur) montre quel fichier a demandé chaque élément. L’image est en anglais.

Utilisez JavaScript pour ce que HTML et CSS ne peuvent pas faire : demander des données à un serveur, réagir aux événements et modifier la page ouverte. Ne l’utilisez pas pour ce que HTML fait déjà. Un <button> dans un <form> déclenche l’envoi avec Enter (Entrée); required vérifie si un champ est vide. Recréer ces fonctions ajoute du code à tester et rend souvent la page moins accessible.

JavaScript a des coûts. Le navigateur doit télécharger et exécuter chaque ligne avant que la page puisse l’utiliser. Cela compte sur un téléphone lent; le module 5 le mesure. Et chaque ligne s’exécute sur l’ordinateur de l’utilisateur, où celui-ci peut la lire et la modifier. Un script de navigateur ne peut jamais garder un secret.

Erreur courante

L'API ne fonctionne pas : Failed to fetch

Symptôme : vous arrêtez l’API simulée, puis vous envoyez le formulaire. La page affiche :

La carte New ticket (nouveau billet) avec le formulaire rempli et, sous le bouton Send ticket (envoyer le billet), le texte The API did not answer. Is it running? (Failed to fetch). (L'API n'a pas répondu. Fonctionne-t-elle? Échec de la récupération.)
La réponse quand aucun serveur ne répond : fetch a rejeté sa promesse, et le bloc catch a écrit le message. L’image est en anglais.

Cause : aucune réponse n’est arrivée. fetch a donc rejeté sa promesse avec TypeError: Failed to fetch (erreur de type : échec de la récupération). await a levé l’erreur, et le bloc catch l’a affichée. Dans Node.js, la même erreur donne TypeError: fetch failed (erreur de type : échec de la récupération), avec la cause connect ECONNREFUSED 127.0.0.1:8100 (connexion refusée).

Solution : démarrez l’API dans le terminal 1, puis envoyez le formulaire de nouveau. La page elle-même fonctionne toujours : chaque await qui peut échouer se trouve dans un try. Sans le try, la page n’afficherait rien. L’erreur apparaîtrait seulement dans l’onglet Console (console) des outils de développement.

Erreur courante

Un objet composé d'espaces : le navigateur l'accepte, mais pas l'API

Symptôme : vous tapez trois espaces comme objet. Le navigateur envoie le formulaire, et la page affiche :

Not saved: The request is not valid. Fields: subject

Cause : pour required (obligatoire), trois espaces ne sont pas une valeur vide. La vérification du navigateur réussit donc. L’API retire les espaces, ne trouve rien et répond 422 avec fields: ["subject"]. Le script affiche cette erreur en mots.

Solution : ne changez rien dans l’API : elle a raison de refuser. C’est pourquoi la page doit afficher l’erreur de l’API, et pas seulement les vérifications du navigateur. Dans Bases de React, le formulaire vérifie aussi le texte dans la page avant de l’envoyer.

Erreur courante

Un await manquant : undefined au lieu des billets

Symptôme : une valeur s’affiche sous la forme Promise { <pending> } (promesse en attente). Ou le code s’arrête avec une erreur concernant undefined (valeur non définie). L’équipe du cours a retiré un await de loadTickets, dans une copie nommée try/noawait.mjs :

const page = response.json(); // the mistake: no await
return page.items;
TypeError: Cannot read properties of undefined (reading 'map')

Cause : la ligne utilise une promesse comme si elle était sa valeur, comme dans forgot.mjs. Sans await, page est une promesse, et une promesse n’a pas de items. Donc, loadTickets renvoie undefined. L’appel à .map sur undefined échoue une étape plus tard, loin de la véritable erreur. Dans la page, le bloc catch de showTickets placerait le même message dans la liste.

Solution : placez await devant chaque appel qui renvoie une promesse (fetch, response.json()), dans une fonction async.

Modifiez bridge/app.js pour que la liste affiche les cinq billets les plus récents. La ligne grise de chaque élément doit aussi afficher la priorité, par exemple Test Customer · other · priority 2 · open (Test Customer · autre · priorité 2 · ouvert). Faites d’abord une prédiction : combien de requêtes la page envoie-t-elle au chargement, et quelle ligne du terminal 1 change?

Afficher la réponse

Deux lignes changent. Dans showTickets, demandez cinq billets :

const tickets = await loadTickets(5);

Dans ticketItem, ajoutez la priorité à la ligne grise :

meta.textContent = `${ticket.customer_name} · ${ticket.team} · priority ${ticket.priority} · ${ticket.status}`;

La page envoie toujours quatre requêtes au chargement. Seule la requête de la liste change : le terminal 1 affiche GET /v1/tickets?limit=5 200. L’exécution de l’équipe du cours a affiché cinq éléments. Le premier était T-80010: Return label for my order LK-300210 | Test Customer · other · priority 2 · open (T-80010 : étiquette de retour pour ma commande LK-300210 | Test Customer · autre · priorité 2 · ouvert). L’instantané conserve dix billets et aucune priorité; rétablissez les deux lignes avant de continuer. Le dossier try/ ne fait pas non plus partie de l’instantané : supprimez-le quand vous n’avez plus besoin des petits programmes.

Vérifiez votre compréhension

Prédisez l'ordre des lignes affichées : console.log('A'); fetch(url).then(function () { console.log('B'); }); console.log('C');

Afficher la réponse

A, puis C, puis B. fetch renvoie immédiatement une promesse en attente, et then indique seulement quoi faire plus tard. Le programme n’attend pas, donc C s’affiche ensuite. B s’affiche quand la réponse arrive, après l’exécution du reste du code. C’est comme le téléavertisseur : vous vous asseyez et discutez, puis vous récupérez votre repas quand il sonne.

Vérifiez votre compréhension

L'API répond 422 au formulaire. Est-ce que fetch rejette sa promesse? Quelle ligne de app.js affiche l'erreur, et d'où vient le message?

Afficher la réponse

Non. fetch rejette sa promesse seulement si aucune réponse n’arrive, par exemple quand l’API ne fonctionne pas. Une réponse 422 reste une réponse. La promesse est donc résolue, et response.ok vaut false (faux). La branche else affiche Not saved: … (non enregistré : …). Elle utilise body.error.message et body.error.fields, qui viennent de la structure d’erreur de l’API. Le bloc catch sert seulement au cas où aucune réponse n’arrive.

Vérifiez votre compréhension

Pourquoi l'écouteur de submit appelle-t-il event.preventDefault()? Que se passe-t-il sans cet appel?

Afficher la réponse

Par défaut, le navigateur envoie lui-même le formulaire, ce qui recharge la page. Sans script, la première page envoyait une requête GET à /?customer_id=…, et aucun billet n’était enregistré. Avec le script, mais sans preventDefault(), le navigateur commencerait ce rechargement pendant que fetch envoie la requête POST. La page disparaîtrait, et la réponse de l’API ne serait jamais affichée. preventDefault() empêche le rechargement. Ainsi, seul le script envoie le formulaire.

Récapitulatif

  • Les objets et les tableaux JavaScript correspondent aux dictionnaires et aux listes Python. Un nom manquant donne undefined, pas une erreur.
  • Les méthodes de tableau reçoivent des fonctions et des fonctions fléchées : filter conserve des éléments, map produit un résultat par élément.
  • Un module exporte des noms, et un autre module les importe. <script type="module"> charge app.js comme module.
  • Un événement appelle un écouteur quand il se produit : le submit (envoi) du formulaire, avec event.preventDefault() pour empêcher le rechargement.
  • fetch renvoie une promesse : en attente, puis résolue ou rejetée. await, dans une fonction async, l’attend sans bloquer la page. Une réponse 4xx ou 5xx ne rejette pas la promesse : vérifiez response.ok.
  • bridge/app.js charge dix billets, construit un <li> pour chacun avec le DOM, et envoie le formulaire : POST /v1/tickets → 202, Saved as T-500001 (enregistré sous T-500001).

Ensuite, vous transférerez la même page vers les outils d’un vrai projet : npm, un serveur de développement et TypeScript.

Leçon suivante : Navigateur et outils de construction