Catégories
Astuces et Design

Deno Built-in Tools: Un aperçu et un guide d'utilisation

Une différence surprenante entre Deno et Node.js est le nombre d'outils intégrés au runtime. Hormis une console REPL (Read-Eval-Print Loop), Node.js nécessite des modules tiers pour gérer la plupart indirect activités de codage telles que les tests et le peluchage. Les outils intégrés de Deno fournissent presque tout ce dont vous avez besoin.

Avant de commencer, une note. Deno est nouveau! Utilisez ces outils avec prudence. Certains peuvent être instables. Rares sont ceux qui ont des options de configuration. D'autres peuvent avoir des effets secondaires indésirables tels que le traitement récursif de chaque fichier dans chaque sous-répertoire. Il est préférable de tester les outils à partir d’un répertoire de projet dédié.

Installez Deno

Installez Deno sur macOS ou Linux à l'aide de la commande de terminal suivante:

curl -fsSL https://deno.land/x/install/install.sh | sh

Ou depuis Windows Powershell:

iwr https://deno.land/x/install/install.ps1 -useb | iex

D'autres options d'installation sont fournies dans le manuel Deno.

Entrer deno --version pour vérifier que l'installation a réussi. Les numéros de version du moteur JavaScript V8, du compilateur TypeScript et de Deno lui-même sont affichés.

Mettre à niveau Deno

Mettez à niveau Deno vers la dernière version avec:

deno upgrade

Ou mise à niveau vers une version spécifique telle que la v1.3.0:

deno upgrade --version 1.30.0

La plupart des outils ci-dessous sont disponibles dans toutes les versions, mais les éditions ultérieures peuvent avoir plus de fonctionnalités et de corrections de bogues.

Aide Deno

Une liste d'outils et d'options peut être visualisée en entrant:

deno help

Boucle lecture-évaluation-impression (REPL)

Comme Node.js, une console d'évaluation d'expression REPL est accessible en entrant deno dans votre terminal. Chaque expression que vous entrez renvoie un résultat ou undefined:

$ deno

Deno 1.3.0
exit using ctrl+d or close()
> const w = 'World';
undefined
> w
World
> console.log(`Hello ${w}!`);
Hello World!
undefined
> close()

$

Les expressions précédemment saisies peuvent être réintroduites à l'aide des touches de curseur pour naviguer dans l'historique des expressions.

Inspecteur de dépendances

Une arborescence de toutes les dépendances de module peut être visualisée en entrant deno info est le chemin / URL d'un script d'entrée.

Considérer ce qui suit lib.js code de bibliothèque avec exporté hello et sum les fonctions:

// general library: lib.js

/**
 * return "Hello !" string
 * @module lib
 * @param {string} name
 * @returns {string} Hello !
 */
export function hello(name = 'Anonymous') {

  return `Hello ${ name.trim() }!`;

};

/**
 * Returns total of all arguments
 * @module lib
 * @param {...*} args
 * @returns {*} total
 */
export function sum(...args) {

  return (...args).reduce((a, b) => a + b);

}

Ceux-ci peuvent être utilisés à partir d'un script d'entrée principal, index.js, dans le même répertoire:

// main entry script: index.js

// import lib.js modules
import { hello, sum } from './lib.js';

const
  spr = sum('Site', 'Point', '.com', ' ', 'reader'),
  add = sum(1, 2, 3);

// output
console.log( hello(spr) );
console.log( 'total:', add );

Le résultat de la course deno run ./index.js:

$ deno run ./index.js

Hello SitePoint.com reader!
total: 6

Les dépendances utilisées par index.js peut être examiné avec deno info ./index.js:

$ deno info ./index.js

local: /home/deno/testing/index.js
type: JavaScript
deps:
file:///home/deno/testing/index.js
  └── file:///home/deno/testing/lib.js

De même, les dépendances requises par n'importe quelle URL de module peuvent être examinées, mais sachez que le module sera téléchargé et mis en cache localement lors de la première utilisation. Par exemple:

$ deno info https://deno.land/std/hash/mod.ts

Download https://deno.land/std/hash/mod.ts
Download https://deno.land/std@0.65.0/hash/mod.ts
Download https://deno.land/std@0.65.0/hash/_wasm/hash.ts
Download https://deno.land/std@0.65.0/hash/hasher.ts
Download https://deno.land/std@0.65.0/hash/_wasm/wasm.js
Download https://deno.land/std@0.65.0/encoding/hex.ts
Download https://deno.land/std@0.65.0/encoding/base64.ts
deps:
https://deno.land/std/hash/mod.ts
  └─┬ https://deno.land/std@0.65.0/hash/_wasm/hash.ts
    ├─┬ https://deno.land/std@0.65.0/hash/_wasm/wasm.js
    │ └── https://deno.land/std@0.65.0/encoding/base64.ts
    ├── https://deno.land/std@0.65.0/encoding/hex.ts
    └── https://deno.land/std@0.65.0/encoding/base64.ts

Pour plus d'informations, consultez le Deno Manual: Dependency Inspector.

Linter (Vérificateur de syntaxe)

Deno fournit un linter pour valider le code JavaScript et TypeScript. Il s'agit d'une fonction instable qui nécessite le --unstable drapeau, mais aucun fichier ne sera modifié lors de son utilisation.

Le peluchage est utile pour repérer les erreurs de syntaxe moins évidentes et garantir que le code respecte les normes de votre équipe. Vous utilisez peut-être déjà un linter tel que ESLint dans votre éditeur ou à partir de la ligne de commande, mais Deno propose une autre option dans n’importe quel environnement où il est installé.

Pour pelucher récursivement tout .js et .ts fichiers dans les répertoires courant et enfant, entrez deno lint --unstable:

$ deno lint --unstable

(no-extra-semi) Unnecessary semicolon.
};
 ^
    at /home/deno/testing/lib.js:13:1

Found 1 problem

Vous pouvez également spécifier un ou plusieurs fichiers pour limiter le peluchage. Par exemple:

$ deno lint --unstable ./index.js
$

Pour plus d'informations, consultez le manuel Deno: Linter. Il comprend une liste de règles que vous pouvez ajouter aux commentaires de code pour ignorer ou appliquer des syntaxes spécifiques.

Testeur

Deno a un exécuteur de test intégré pour les fonctions JavaScript ou TypeScript de test unitaire.

Les tests sont définis dans n'importe quel fichier nommé test avec un .js, .mjs, .ts, .jsx, ou .tsx extension. Il doit passer un ou plusieurs appels à Deno.test et passez une chaîne de nom de test et une fonction de test. La fonction peut être synchrone ou asynchrone et utiliser une variété d'utilitaires d'assertion pour évaluer les résultats.

Créer un nouveau test sous-répertoire avec un fichier nommé lib.test.js:

// test lib.js library

// assertions
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';

// lib.js modules
import { hello, sum } from '../lib.js';

// hello function
Deno.test('lib/hello tests', () => {

  assertEquals( hello('Someone'), 'Hello Someone!');
  assertEquals( hello(), 'Hello Anonymous!' );

});

// sum integers
Deno.test('lib/sum integer tests', () => {

  assertEquals( sum(1, 2, 3), 6 );
  assertEquals( sum(1, 2, 3, 4, 5, 6), 21 );

});

// sum strings
Deno.test('lib/sum string tests', () => {

  assertEquals( sum('a', 'b', 'c'), 'abc' );
  assertEquals( sum('A', 'b', 'C'), 'AbC' );

});

// sum mixed values
Deno.test('lib/sum mixed tests', () => {

  assertEquals( sum('a', 1, 2), 'a12' );
  assertEquals( sum(1, 2, 'a'), '3a' );
  assertEquals( sum('an', null, (), 'ed'), 'annulled' );

});

Pour exécuter tous les tests à partir de tous les répertoires, entrez deno test. Ou exécutez des tests stockés dans un répertoire spécifique avec deno test

. Par exemple:

$ deno test ./test

running 4 tests
test lib/hello tests ... ok (4ms)
test lib/sum integer tests ... ok (2ms)
test lib/sum string tests ... ok (2ms)
test lib/sum mixed tests ... ok (2ms)

test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out (11ms)

$

UNE --filter une chaîne ou une expression régulière peut également être spécifiée pour limiter les tests par nom. Par exemple:

$ deno test --filter "hello" ./test

running 1 tests
test lib/hello tests ... ok (4ms)

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out (5ms)

Les tests plus longs peuvent être arrêtés au premier échec en passant un --failfast option.

Pour plus d'informations, consultez le Deno Manual: Testing. Quelques modules de test tiers sont également disponibles, y compris Merlin et Ruhm, mais ceux-ci utilisent toujours Deno.test sous la surface.

Débogueur V8

Deno fournit le même moteur V8 et le même débogueur que Node.js. Il est possible de se connecter au débogueur à l'aide du navigateur Chrome ou de VS Code, puis de parcourir le code pour afficher les modifications apportées aux variables et aux objets.

Pour lancer le débogueur, exécutez un script avec --inspect ou --inspect-brk pour s'arrêter sur la première ligne. Si vous devez vous connecter au débogueur à partir d'un autre appareil de votre réseau, ajoutez son adresse IP et un port ou autorisez une connexion de n'importe où en utilisant --inspect=0.0.0.0:9229. Par exemple:

$ deno run --inspect-brk=0.0.0.0:9229 ./index.js

Debugger listening on ws://0.0.0.0:9229/ws/ceb123...
Debugger session started.

Ouvert dans un nouvel onglet Chrome et le deno le script apparaîtra comme un nouveau Cible distante:

Chrome inspecter

Remarque: les «DevTools dédiés pour Node» ne se connecteront pas au débogueur de Deno, même s'ils sont similaires.

Cliquez sur la cible inspecter lien pour lancer DevTools. Cela vous sera familier si vous avez utilisé le débogage côté client. le Sources tab est le plus utile et vous permet de parcourir l'exécution du code:

Débogueur Deno V8 DevTools

Pour plus d'informations, consultez le Deno Manual: Debugger.

Formateur de code

Le formateur de code intégré formate automatiquement le code JavaScript et TypeScript de la même manière que Prettier. Le formateur de Deno est également avisé et il n’est actuellement pas possible de configurer les options.

Pour l'utiliser, entrez deno fmt formater récursivement chaque fichier dans chaque sous-répertoire. Par exemple:

$ deno fmt

/home/deno/testing/index.js
/home/deno/testing/test/lib.test.js
/home/deno/testing/lib.js

Vous pouvez également formater un ou plusieurs fichiers individuels – par exemple, deno fmt ./index.js.

Si vous examinez le lib.test.js fichier, vous verrez que le formateur a supprimé certains espacements et converti les chaînes pour utiliser des guillemets doubles ("):

// hello function
Deno.test("lib/hello tests", () => {
  assertEquals(hello("Someone"), "Hello Someone!");
  assertEquals(hello(), "Hello Anonymous!");
});

Des blocs de code individuels peuvent être ignorés en ajoutant un // deno-fmt-ignore commentaire. Par exemple:

// deno-fmt-ignore
const bin = (
              1, 0, 0,
              0, 1, 0,
              0, 0, 1,
            );

Des fichiers entiers peuvent être ignorés en ajoutant un // deno-fmt-ignore-file commentaire en haut du code.

Pour plus d'informations, consultez le Deno Manual: Code Formatter.

Avertissement! Le formatage automatisé peut nuire aux commentaires JSDoc.

Générateur de documentation

Deno peut générer de la documentation à partir des commentaires JSDoc dans le code source, qui expliquent le but, les paramètres et la valeur de retour d’une fonction. Actuellement, Deno ne générera de la documentation que pour les modules qui export les fonctions. Par exemple:

$ deno doc ./lib.js

Defined in file:///home/deno/testing/lib.js:9:0

function hello(name)
  return "Hello !" string
  @module lib
  @param {string} name
  @returns {string} Hello !

Defined in file:///home/deno/testing/lib.js:21:0

function sum(...args)
  Returns total of all arguments
  @module lib
  @param {...*} args
  @returns {*} total

$

Ajout d'un --json flag génère la documentation au format JSON.

Pour plus d'informations, consultez le Deno Manual: Documentation Generator.

Regroupement de scripts

Votre script principal et toutes ses dépendances peuvent être regroupés dans un seul fichier en utilisant:

deno bundle  

Par exemple:

$ deno bundle ./index.js ./index.bundle.js

Bundle file:///home/deno/testing/index.js
Emit "./index.bundle.js" (3.13 KB)

Le script résultant peut alors être exécuté:

$ deno run ./index.bundle.js

Hello SitePoint.com reader!
total: 6

Cela peut être utile lors de la distribution de scripts aux utilisateurs finaux ou du déploiement d'une base de code finale sur un serveur actif.

Remarque: niveau supérieur await les appels peuvent échouer lors du regroupement, donc un async la fonction wrapper doit être ajoutée. Il s'agit d'un problème connu qui sera résolu dans les prochaines versions de Deno.

Pour plus d'informations, consultez le Deno Manual: Bundling.

Installateur de script

Un script Deno peut être installé globalement pour pouvoir être exécuté à partir de n'importe quel emplacement du système de fichiers. C'est similaire à l'installation de modules globaux Node.js, mais un peu plus simple et plus facile à utiliser.

le deno install la commande doit être passée:

  1. Tous les indicateurs d'autorisation d'exécution requis tels que --allow-read, --allow-write, ou --allow-net.
  2. Un nom de script installé facultatif avec --name .
  3. Un dossier racine d'installation facultatif avec --root . Si ce n'est pas défini, Deno installe le script dans le chemin défini dans le DENO_INSTALL_ROOT variable d'environnement ou $HOME/.deno/bin/.
  4. Le chemin ou l'URL du module.

L'exemple de script ci-dessus peut être installé avec:

$ deno install --name myscript ./index.js

✅ Successfully installed myscript
/home/deno/.deno/bin/myscript

UNE myscript le fichier est créé dans le .deno/bin/ répertoire avec le contenu suivant:

#!/bin/sh
# generated by deno install
deno "run" "file:///home/deno/testing/index.js" "$@"

myscript peut maintenant être exécuté de n'importe où sur le système. Par exemple:

cd ~
$ myscript

Hello SitePoint.com reader!
total: 6

Ce processus permet d'indiquer facilement aux utilisateurs comment installer votre application à partir d'une URL publiée. Par exemple:

deno install --name myapp https://myserver.com/myapp.js
myapp

Deno ne propose pas actuellement de uninstall ou remove commander. La seule façon de supprimer le script est de supprimer manuellement le fichier généré du .deno/bin/ répertoire ou partout où il a été installé.

Pour plus d'informations, consultez le Deno Manual: Script Installer.

Les outils de Deno sont nouveaux et certains sont rudimentaires, mais une approche «standard» documentée présente des avantages. Node.js offre de nombreuses options tierces, mais cela peut entraîner une paralysie des choix ou un changement de solution continu. Êtes-vous resté avec la même suite de tests Node.js?

Cependant, méfiez-vous: ces outils intégrés peuvent évoluer rapidement à mesure que l'utilisation de Deno se développe.

Fondations Deno

Soyez au courant avec Deno. Notre collection Deno Foundations vous aide à faire vos premiers pas dans le monde Deno et au-delà, et nous y ajoutons constamment. Nous vous apporterons les tutoriels dont vous avez besoin pour devenir un pro. Vous pouvez toujours vous référer à notre index tel qu'il est mis à jour à la fin de notre introduction à Deno:

➤ Fondations Deno

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *