Lorsque nous démarrons un nouveau projet Web dans lequel JavaScript sera utilisé, la première chose que nous faisons est souvent de configurer les outils de construction et de développement. Par exemple, Vite, qui est populaire de nos jours. Vous ne savez peut-être pas qu'un outil de construction complexe n'est pas nécessaire pour tous les projets JavaScript (Web). En fait, il est désormais plus facile que jamais de s’en passer, comme je le montrerai dans cet article.

Créez un nouveau projet avec un fichier index.html.

  
  
  
    
Hello world
  

Si vous utilisez VS Code, installez l'extension Live Preview. Exécuter. Il s'agit d'un simple serveur de fichiers avec rechargement en direct. Vous pouvez utiliser n'importe quel serveur de fichiers, Python en est fourni avec un :

python3 -m http.server

J'aime l'aperçu en direct, car il actualise automatiquement la page après avoir apporté des modifications à un fichier.

Vous devriez maintenant pouvoir accéder à votre fichier index.html depuis le navigateur et voir « Bonjour tout le monde ».

Ensuite, créez un fichier index.js :

console.log("Hello world");

export {};

Incluez-le dans votre index.html :

Ouvrez la console du développeur dans votre navigateur. Si vous voyez « Hello World », vous savez qu'il se charge correctement.

Les navigateurs prennent désormais en charge les modules ECMAScript. Vous pouvez importer d'autres fichiers pour leurs effets secondaires :

import "./some-other-script.js";

ou pour leurs exportations

import { add, multiply } "./my-math-lib.js";

Plutôt cool, non ? Reportez-vous au guide MDN ci-dessus pour plus d'informations.

Paquets

Vous ne voulez probablement pas réinventer la roue, votre projet utilisera donc probablement des packages tiers. Cela ne signifie pas que vous devez maintenant commencer à utiliser un gestionnaire de packages.

Disons que nous voulons utiliser superstruct pour la validation des données. Nous ne pouvons pas simplement charger des modules depuis notre propre serveur de fichiers (local), mais depuis n'importe quelle URL. esm.sh fournit facilement des modules pour presque tous les packages disponibles sur npm.

Lorsque vous visitez https://esm.sh/superstruct, vous pouvez voir que vous êtes redirigé vers la dernière version. Vous pouvez inclure ce package comme suit dans votre code :

import { assert } from "https://esm.sh/superstruct";

Si vous voulez être prudent, vous pouvez épingler des versions.

Les types

Je ne sais pas pour vous, mais TypeScript m'a gâté (et m'a rendu paresseux). Écrire du JavaScript simple sans l'aide du vérificateur de type, c'est comme écrire sur une corde raide. Heureusement, nous ne devons pas non plus renoncer à la vérification de type.

Il est temps de supprimer npm (même si nous n'enverrons aucun code fourni).

npm init --yes
npm install typescript

Vous pouvez très bien utiliser le compilateur TypeScript sur du code JavaScript ! Il bénéficie d’un support de premier ordre. Créez un jsconfig.json :

{
  "compilerOptions": {
    "strict": true,
    "checkJs": true,
    "allowJs": true,
    "noImplicitAny": true,
    "lib": ["ES2022", "DOM"],
    "module": "ES2022",
    "target": "ES2022"
  },
  "include": ["**/*.js"],
  "exclude": ["node_modules"]
}

Maintenant, exécutez

npm run tsc --watch -p jsconfig.json

et faites une erreur de type dans votre code. Le compilateur TypeScript devrait se plaindre :

/** @type {number} **/
const num = "hello";

Au fait, le commentaire que vous voyez ci-dessus est JSDoc. Vous pouvez annoter votre JavaScript avec des types de cette façon. Bien que ce soit un peu plus verbeux que l'utilisation de TypeScript, on s'y habitue assez rapidement. Il est également très puissant, tant que vous n'écrivez pas de types fous (ce que vous ne devriez pas faire pour la plupart des projets), tout devrait bien se passer.

Si vous avez besoin d'un type compliqué (helper), vous pouvez toujours ajouter du TypeScript dans un fichier .d.ts.

JSDoc n'est-il qu'un tremplin pour les personnes coincées avec de grands projets JavaScript afin de pouvoir migrer progressivement vers TypeScript ? Je ne pense pas! L'équipe TypeScript continue également d'ajouter des fonctionnalités intéressantes à JSDoc TypeScript, comme dans la prochaine version de TypeScript. La saisie semi-automatique fonctionne également très bien dans VS Code.

Importer des cartes

Nous avons appris à ajouter des packages externes à notre projet sans outil de build. Cependant, si vous divisez votre code en plusieurs modules, écrire l'URL complète encore et encore peut s'avérer un peu verbeux.

Nous pouvons ajouter une carte d'importation à la section d'en-tête de notre index.html :

Maintenant, nous pouvons simplement importer ce package avec

import {} from "superstruct"

Comme un projet « normal ». Un autre avantage est que la complétion et la reconnaissance des types fonctionneront comme prévu si vous installez le package localement.

npm install --save-dev superstruct

Notez que la version dans votre répertoire node_modules ne sera pas utilisée. Vous pouvez le supprimer et votre projet continuera à s'exécuter.

Une astuce que j'aime utiliser est d'ajouter :

      "cdn/": "https://esm.sh/",

Vers ma carte d'importation. Ensuite, n'importe quel projet disponible via esm.sh peut être utilisé en l'important simplement. Par exemple.:

import Peer from "cdn/peerjs";

Si vous souhaitez également extraire des types de node_modules pour le développement de ce type d'importation, vous devez ajouter ce qui suit aux options du compilateur de votre jsconfig.json :

    "paths": {
      "cdn/*": ["./node_modules/*", "./node_modules/@types/*"]
    },

Déploiement

Pour déployer votre projet, copiez tous les fichiers sur un hôte de fichiers statiques et le tour est joué ! Si vous avez déjà travaillé sur un projet JavaScript existant, vous connaissez la difficulté de mettre à jour des outils de construction qui n'ont même pas 1 à 2 ans. Vous ne subirez pas le même sort avec cette configuration de projet.

Essai

Si votre JavaScript ne dépend pas des API du navigateur, vous pouvez simplement utiliser le programme d'exécution de tests fourni avec Node.js. Mais pourquoi ne pas écrire votre propre programme d'exécution de tests qui s'exécute directement dans le navigateur ?

/** @type {[string, () => Promise | void][]} */
const tests = [];

/**
 *
 * @param {string} description
 * @param {() => Promise | void} testFunc
 */
export async function test(description, testFunc) {
  tests.push([description, testFunc]);
}

export async function runAllTests() {
  const main = document.querySelector("main");
  if (!(main instanceof HTMLElement)) throw new Error();
  main.innerHTML = "";

  for (const [description, testFunc] of tests) {
    const newSpan = document.createElement("p");

    try {
      await testFunc();
      newSpan.textContent = `✅ ${description}`;
    } catch (err) {
      const errorMessage =
        err instanceof Error && err.message ? ` - ${err.message}` : "";
      newSpan.textContent = `❌ ${description}${errorMessage}`;
    }
    main.appendChild(newSpan);
  }
}

/**
 * @param {any} val
 */
export function assert(val, message = "") {
  if (!val) throw new Error(message);
}

Créez maintenant un fichier example.test.js.

import { test, assert } from "@/test.js";

test("1 1", () => {
  assert(1   1 === 2);
});

Et un fichier dans lequel vous importez tous vos tests :

import "./example.test.js";

console.log("This should only show up when running tests");

Exécutez ceci lors du chargement de la page :

await import("@/test/index.js"); // file that imports all tests
(await import("@/test.js")).runAllTests();

Et vous avez une configuration TDD parfaite. Pour exécuter uniquement une section des tests, vous pouvez commenter quelques importations .test.js, mais la vitesse d'exécution des tests ne devrait commencer à devenir un problème que lorsque vous avez accumulé beaucoup de tests.

Avantages

Pourquoi voudriez-vous faire cela? Eh bien, utiliser moins de couches d’abstraction rend votre projet plus facile à déboguer. Il y a aussi le crédo « utiliser la plateforme ». Les compétences que vous acquérez seront mieux transférées à d’autres projets. Un autre avantage est que lorsque vous revenez sur un projet construit comme celui-ci dans 10 ans, cela fonctionnera toujours et vous n'avez pas besoin de faire de l'archéologie pour essayer de faire revivre un outil de construction disparu depuis 8 ans. Une expérience avec laquelle de nombreux développeurs Web ayant travaillé sur des projets existants sont familiers.

Voir plainvanillaweb.com pour plus d'idées.