Maison >interface Web >js tutoriel >Développement Web sans outils (de construction)

Développement Web sans outils (de construction)

WBOYoriginal: 2024-08-05 19:11:221133parcourir

Web Development Without (Build) Tooling

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.

<!doctype html>
<html>
  <head>
  </head>
  <body>
    <p>Hello world</p>
  </body>
</html>

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

python3 -m http.server

J'aime Live Preview, 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 :

<script type="module" src="./index.js"></script>

Ouvrez la console 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.

Forfaits

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

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.

Espèces

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 sortir 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, courez

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. C'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), ça devrait aller.

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 être un peu verbeux.

Nous pouvons ajouter une carte d'importation à la section head de notre index.html :

<script type="importmap">
  {
    "imports": {
      "superstruct": "https://esm.sh/superstruct@1.0.4"
    }
  }
</script>

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 à fonctionner.

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 pour 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ébergeur 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.

Testing

If your JavaScript does not depend on browser APIs, you could just use the test runner that comes bundled with Node.js. But why not write your own test runner that runs right in the browser?

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

/**
 *
 * @param {string} description
 * @param {() => Promise<void> | 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);
}

Now create a file example.test.js.

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

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

And a file where you import all your tests:

import "./example.test.js";

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

Run this on page load:

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

And you got a perfect TDD setup. To run only a section of the tests you can comment out a few .test.js import, but test execution speed should only start to become a problem when you have accumulated a lot of tests.

Benefits

Why would you do this? Well, using fewer layers of abstraction makes your project easier to debug. There is also the credo to "use the platform". The skills you learn will transfer better to other projects. Another advantage is, when you return to a project built like this in 10 years, it will still just work and you don't need to do archeology to try to revive a build tool that has been defunct for 8 years. An experience many web developers that worked on legacy projects will be familiar with.

See plainvanillaweb.com for some more ideas.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Python JavaScript typescript json ecmascript html npm Static if for while include try Directory Error auto continue using class copy map JS console this https tdd Access

Déclaration：

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article précédent：Pourquoi choisir des types plutôt que des interfacesArticle suivant：Pourquoi choisir des types plutôt que des interfaces

Articles Liés

Voir plus