Pour rendre visible une variable ou une fonction, il suffit de l’exporter, en la rajoutant à la propriété exports du module, comme indiqué ci-dessous. On peut modifier le nom de ce qui est exporté, mais cela n’est pas forcément souhaitable :

function maFonction(x) { return x+1; }
module.exports.maFonction = maFonction;         // même nom
module.exports.maFonctionExportee = maFonction; // autre nom

let   maVar1 = 1; module.exports.maVar1 = maVar1;
var   maVar2 = 1; module.exports.maVar2 = maVar2;
const maVar3 = 1; module.exports.maVar3 = maVar3;

console.log(module);

{
  id: '.',
  path: '/home/gonzales/enseignement/projdev2-24-25/prog',
  exports: {
    maFonction: [Function: maFonction],
    maFonctionExportee: [Function: maFonction],
    maVar1: 1,
    maVar2: 1,
    maVar3: 1
  },
  filename: '/home/gonzales/enseignement/projdev2-24-25/prog/exportation.js',
  loaded: false,
  children: [],
  paths: [
    '/home/gonzales/enseignement/projdev2-24-25/prog/node_modules',
    '/home/gonzales/enseignement/projdev2-24-25/node_modules',
    '/home/gonzales/enseignement/node_modules',
    '/home/gonzales/node_modules',
    '/home/node_modules',
    '/node_modules'
  ],
  [Symbol(kIsMainSymbol)]: true,
  [Symbol(kIsCachedByESMLoader)]: false,
  [Symbol(kIsExecuting)]: true
}

Comme en PHP, le mot clef pour importer du code d’un autre fichier est require (ici, il n’y a pas de require_once, les require ne sont exécutés qu’une seule fois). Dans l’exemple ci-dessous, on récupère ainsi un objet qui contient précisément ce qui a été exporté. En principe, il est d’usage de donner à cet objet le même nom que le module importé. Ci-dessous, on crée l’objet en const afin d’éviter qu’on puisse le modifier par inadvertence.

const exportation = require('./exportation');

console.log("========================");
console.log(exportation);
console.log('appel fonction:', exportation.maFonction(exportation.maVar1));

{
  id: '/home/gonzales/enseignement/projdev2-24-25/prog/exportation.js',
  path: '/home/gonzales/enseignement/projdev2-24-25/prog',
  exports: {
    maFonction: [Function: maFonction],
    maFonctionExportee: [Function: maFonction],
    maVar1: 1,
    maVar2: 1,
    maVar3: 1
  },
  filename: '/home/gonzales/enseignement/projdev2-24-25/prog/exportation.js',
  loaded: false,
  children: [],
  paths: [
    '/home/gonzales/enseignement/projdev2-24-25/prog/node_modules',
    '/home/gonzales/enseignement/projdev2-24-25/node_modules',
    '/home/gonzales/enseignement/node_modules',
    '/home/gonzales/node_modules',
    '/home/node_modules',
    '/node_modules'
  ],
  [Symbol(kIsMainSymbol)]: false,
  [Symbol(kIsCachedByESMLoader)]: false,
  [Symbol(kIsExecuting)]: true
}
========================
{
  maFonction: [Function: maFonction],
  maFonctionExportee: [Function: maFonction],
  maVar1: 1,
  maVar2: 1,
  maVar3: 1
}
appel fonction: 2

Notez que l’on n’indique pas l’extension .js du fichier importé et que, pour l’importation des fichiers « locaux », c’est-à-dire ceux qui ne sont pas des packages node installés, on préfixe le nom du fichier par le répertoire courant « ./ ». L’affichage de la console ci-dessus montre que lorsque l’on require un fichier, on exécute toutes ses instructions (cf. les lignes avant la démarcation « ======================== »).

Le programme suivant permet d’afficher la liste des fichiers du répertoire courant. Dans la variable files, on récupère cette liste, puis on l’affiche. C’est donc un programme synchrone.

// on importe le package fs pour pouvoir interagir avec le système de fichiers
const fs = require('fs');

// lecture du répertoire courant et stockage de la liste des fichiers
// dans la variable files
const files = fs.readdirSync('.');
console.log(files);

Notez qu’ici, fs est le nom d’un package de node. Quand on l’inclut avec l’instruction require(), on ne préfixe pas avec « ./ » puisque c’est un fichier du répertoire node_modules.

La version asynchrone de ce programme est la suivante :

const fs = require('fs');

fs.readdir('.', function (err, files) {
  // arrivé dans cette fonction, soit le readdir s'est bien passé et on a la liste
  // des fichiers dans files et err n'est pas défini (null), soit il y a eu une
  // erreur et files est null
  // => on traite systématiquement les 2 cas :
  if (err)
    console.log('Erreur :', err);
  else
    console.log('fichiers :', files);
});

Dans les versions asynchrones, on a systématiquement un 2ème argument qui est une callback. Celle-ci a toujours un 1er paramètre qui permet de gérer les erreurs produites par la fonction asynchrone.

L’utilisation de mysql2 est assez similaire à celle de PDO. Pour se connecter, il faut utiliser la fonction createConnection() :

const mysql = require('mysql2');

const db = mysql.createConnection({  // connexion à la BD. Cela produit une
  host     : 'localhost',            // instance qui sera utilisée pour les
  user     : 'polytech',             // queries.
  password : 'polytech',             // A noter que cet objet continuera d'exister
  database : 'polytech'              // jusqu'à ce qu'on applique sa méthode end()
});
db.connect(); // réalisation de la connexion à la base de données

Une fois la connexion réalisée, comme dans PDO, dans les requêtes SQL, on ne fournit pas directement les valeurs de certains paramètres mais plutôt des ?. La différence principale avec PDO, c’est que les requêtes sont asynchrones. Ainsi, la fonction query() prend en arguments 3 paramètres :

1. la commande SQL à exécuter, mais dans laquelle les valeurs communiquées par l’utilisateur sont remplacées par des ? ;

2. un tableau contenant les valeurs correspondant aux ?, dans le même ordre que les ? ;

3. une callback (fonction) qui indique ce qu’il faudra faire quand le serveur SQL aura transmis sa réponse. Cette callback possède 2 arguments : le 1er correspond à l’erreur qui s’est produite (si le serveur SQL renvoie une erreur) et le 2ème contient le résultat de la requête si elle s’est bien passée.

db.query( // on exécute une requête SQL
    'SELECT * FROM courses WHERE id <= ?', // même syntaxe qu'en PDO !
    [2],                                   // ici, ce sont les data de PDO
    (error, results) => {                  // les requêtes sont réalisées de manière
      if (error) console.log(error);       // asynchrone => on récupère le résultat
      else console.log(results);           // via une callback, permettant de gérer
    });                                    // également les erreurs

Notez que la connexion à la base de données est effective jusqu’à ce qu’on exécute db.end(). Pourquoi est-ce important ? Parce que, comme les db.query() sont asynchrones, tant que vous n’exécutez pas db.end(), votre programme ne peut pas se terminer.

Le programme complet d’interrogation de la base de données est alors :

const mysql = require('mysql2');

const db = mysql.createConnection({  // connexion à la BD. Cela produit une
  host     : 'localhost',            // instance qui sera utilisée pour les
  user     : 'polytech',             // queries.
  password : 'polytech',             // A noter que cet objet continuera d'exister
  database : 'polytech'              // jusqu'à ce qu'on applique sa méthode end()
});
db.connect(); // réalisation de la connexion à la base de données

db.query( // on exécute une requête SQL
    'SELECT * FROM courses WHERE id <= ?', // même syntaxe qu'en PDO !
    [2],                                   // ici, ce sont les data de PDO
    (error, results) => {                  // les requêtes sont réalisées de manière
      if (error) console.log(error);       // asynchrone => on récupère le résultat
      else console.log(results);           // via une callback, permettant de gérer
    });                                    // également les erreurs

console.log('les queries sont asynchrones'); // ceci s'affichera avant les résultats
db.end();  // afin de terminer le programme, il faut arrêter l'attente de l'objet db

Lorsque l’on exécute le script ci-dessus, on obtient un affichage similaire à :

les queries sont asynchrones
[
  { id: 1, nom: 'applis web et mobiles', nbEtuds: 45 },
  { id: 2, nom: 'robotique', nbEtuds: 20 }
]

Notez que le message indiquant que les queries sont asynchrones est écrit avant le tableau contenant les données de la base de données, alors même que l’instruction db.query() a été exécutée avant le console.log(), ce qui prouve bien que les requêtes SQL sont asynchrones.

L’avantage des requêtes asynchrones réside dans le fait qu’elles ne font pas perdre de temps au backend : pendant que l’on attend le résultat d’une requête SQL, le backend s’occupe des autres clients qui lui sont connectés. L’inconvénient majeur c’est que, quand on a plusieurs requêtes à exécuter séquentiellement, on a des callbacks imbriquées les unes dans les autres, ce qui devient rapidement pénible à lire.

En Angular, vous avez vu les Observables, qui permettaient, dans une requête asynchrone, de retourner immédiatement un objet, une coquille vide qui, à terme, contiendrait le résultat de la requête. En Javascript, il existe un autre mécanisme relativement similaire : les promesses (Promise en anglais).

L’idée va alors être d’encapsuler la requête SQL dans une promesse et d’inclure le tout dans une fonction. Exécuter cette fonction revient à exécuter la requête. On récupère alors immédiatement une Promise, qui est une coquille vide. Comme pour les Observables, on a un mécanisme qui permet, quand on a la réponse, de l’exploiter : ce n’est plus un subscribe() mais un then. Voici donc une première amélioration du code de notre fichier mysql.js :

const mysql = require('mysql2');

const db = mysql.createConnection({ // connexion à la BD. Cela produit une
  host     : 'localhost',           // instance qui sera utilisée pour les
  user     : 'polytech',            // queries.
  password : 'polytech',            // A noter que cet objet continuera d'exister
  database : 'polytech'             // jusqu'à ce qu'on applique sa méthode end()
});
db.connect(); // réalisation de la connexion à la base de données

function myQuery() {
  // on retourne tout de suite une Promesse, sans attendre la réponse du serveur
  return new Promise((resolve, reject) => {
    db.query(
      'SELECT * FROM courses WHERE id <= ?',
      [2],
    (error, results) => {        // quand on a la réponse du serveur Mysql,
      if (error) reject(error);  // on rejette la promesse en cas d'erreur ou
      else resolve(results);     // on la résout si tout est OK
    });
  });
}

// l'argument du then est une fonction exécutée dès que la promesse est résolue,
// autrement dit, dès que l'on a la réponse du serveur Mysql
myQuery().then((results) => { console.log(results); });
db.end();

Note : Avec PDO, vous faisiez des fetchColumn, fetch ou fetchAll selon que vous souhaitiez obtenir juste une valeur, un vecteur ou une matrice. Ici, dans tous les cas, vous n’utilisez que db.query. Donc, il faut être vigilant à ce que vous « retournez » via le resolve. Imaginons que, dans le code ci-dessus, on savait qu’il n’y avait qu’un seul cours dont l’id était inférieur à une valeur donnée et que myQuery devait juste retourner l’id de ce cours. Dans ce cas, results doit être égal à quelque chose comme :

[ { id: 1, nom: 'applis web et mobiles', nbEtuds: 45 } ]

Et si l’on souhaite que ce soit l’id de 1 qui est retourné, on doit donc écrire :

function myQuery() {
  // on retourne tout de suite une Promesse, sans attendre la réponse du serveur
  return new Promise((resolve, reject) => {
    db.query(
      'SELECT * FROM courses WHERE id <= ?',
      [2],
    (error, results) => {
      if (error) reject(error);
      else {
         if (results.length != 1) reject(results);
         else resolve(results[0].id);
      }
    });
  });
}

Pour l’instant, on n’a pas gagné grand chose car à utiliser des Promises, on a juste déplacé le problème d’attente du retour du serveur SQL de db.query à myQuery.then. Cela dit, on a gagné sur un aspect : la fonction myQuery ne mélange pas l’appel au serveur SQL et la logique de mon application (le console.log()).

Mais l’avantage d’exploiter les Promises va apparaître quand on va les combiner avec le mot-clef await. Grâce à celui-ci, quand une instruction va récupérer une Promise, Javascript va attendre que la coquille vide de la Promise soit remplie avant de passer à l’instruction suivante. On aura donc, apparemment, un comportement séquentiel. Cela dit, en interne, Node ne va pas bêtement attendre, il va s’occuper des autres clients tant que la Promise n’aura pas été résolue. On aura donc, ainsi, un code qui s’apparente à un code séquentiel mais qui, en réalité, est un code asynchrone.

const mysql = require('mysql2');

const db = mysql.createConnection({ // connexion à la BD. Cela produit une
  host     : 'localhost',           // instance qui sera utilisée pour les
  user     : 'polytech',            // queries.
  password : 'polytech',            // A noter que cet objet continuera d'exister
  database : 'polytech'             // jusqu'à ce qu'on applique sa méthode end()
});
db.connect(); // réalisation de la connexion à la base de données

function myQuery() {
  return new Promise((resolve, reject) => {
    db.query(
      'SELECT * FROM courses WHERE id <= ?',
      [2],
      (error, results) => {        // quand on a la réponse du serveur Mysql,
        if (error) reject(error);  // on rejette la promesse en cas d'erreur ou
        else resolve(results);     // on la résout si tout est OK
      });
  });
}

// conserver les avantages de l'asynchronie en ayant un code apparemment séquentiel :
async function getResult() {      // async permet d'utiliser await: await attend la
  const result = await myQuery(); // la résolution de la promesse. Elle prend alors
  console.log(result);            // la valeur passée en argument du "resolve" et la
}                                 // place dans result. Ensuite, seulement, on passe
                                  // à l'instruction console.log
getResult(); // on appelle notre fonction pour interroger la base de données
db.end();

Notez que la fonction getResult() doit être indiquée comme étant asynchrone (mot-clef async) afin de pouvoir utiliser le mot-clef await. Ici, la fonction getResult() représente le code du backend qui interagit avec le frontend (le code des fichiers checkLogin.php, getCourses.php, etc.).

Le mot-clef async induit plus de choses qu’on ne pourrait le croire. Dans l’exemple ci-dessous, la fonction myFunc renvoie directement la valeur 3, donc on pourrait légitimement penser que son type de retour est number. En fait, c’est une Promise parce que la fonction est préfixée du mot-clef async :

async function myFunc() {
  return 3;
}

// async => toute valeur de retour est transformée en promesse
const x = myFunc();
console.log('x =', x);

async function bof() {
  if (myFunc() === 3) console.log('pas ok');
  if (await myFunc() === 3) console.log('ok');
}
bof();

x = Promise { 3 }
ok