Debuter avec Deno

Débuter avec Deno

Pourquoi Deno ?

Deno est un runtime JavaScript et TypeScript moderne qui vise à résoudre les problèmes de sécurité et de gestion des packages existants. Au quotidien, un développeur a besoin d'un environnement sûr et efficace pour développer des applications web, des API backend ou même des outils CLI. Deno offre une solution innovante en utilisant un système de modules sécurisé par défaut.

Un cas d'usage concret est la création d'une application simple qui récupère le contenu d'un site Web et l'affiche dans la console. Avec Deno, ce processus peut être réalisé efficacement et avec des garanties de sécurité accrues en comparaison avec les autres runtimes JavaScript.

Prérequis

Avant de commencer, il est nécessaire de disposer des éléments suivants :

• Node.js : Version recommandée >= 14.0
• Deno : Installez la dernière version en utilisant le script d'installation officiel.

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

Concepts fondamentaux

1. Environnement de Développement (Deno)

Deno est un runtime intégré qui comprend les outils nécessaires pour exécuter du code JavaScript et TypeScript.

## Exécutez un script Deno simple
deno run hello.ts

2. Modules en Deno

Les modules sont importés et exportés à l'aide de l'instruction import et export. Tous les fichiers sont considérés comme des modules par défaut.

// hello.ts
console.log("Bonjour, Deno!");

3. Types et Validation

Deno prend en charge le type de données TypeScript, ce qui permet une meilleure validation du code et une meilleure lisibilité.

// types.ts
function greet(name: string): void {
    console.log(`Bonjour, ${name}!`);
}

greet("Deno");

4. Gestion des Packages

Deno utilise un registre de packages publics qui est similaire à npm, mais avec une gestion de permissions plus restrictive.

## Installez le package 'uuid'
deno install -A https://deno.land/std@0.106.0/uuid/mod.ts

Mise en pratique : Projet fil rouge

Mini-Projet : Gestionnaire de Tâches

Créeons un simple gestionnaire de tâches qui permet d'ajouter, afficher et supprimer des tâches.

Étape 1 : Création du Fichier Principal

## Créez le fichier 'app.ts'
touch app.ts

Étape 2 : Définition des Tâches

// app.ts
interface Task {
    id: number;
    title: string;
    completed: boolean;
}

let tasks: Task[] = [];

function addTask(title: string): void {
    const newTask: Task = { id: Date.now(), title, completed: false };
    tasks.push(newTask);
    console.log(`Tâche ajoutée : ${newTask.title}`);
}

function listTasks(): void {
    console.log("Liste des tâches:");
    tasks.forEach(task => {
        console.log(`${task.id}: ${task.title} - ${task.completed ? 'Terminée' : 'En cours'}`);
    });
}

function deleteTask(id: number): void {
    const index = tasks.findIndex(task => task.id === id);
    if (index !== -1) {
        tasks.splice(index, 1);
        console.log(`Tâche supprimée : ${id}`);
    } else {
        console.log("Tâche non trouvée");
    }
}

// Ajout de tâches pour tester
addTask("Faire les courses");
addTask("Nettoyer la maison");

listTasks();

deleteTask(1);

listTasks();

Étape 3 : Exécution du Projet

## Exécutez le script avec Deno
deno run app.ts

Ce mini-projet illustre comment vous pouvez créer un simple système de gestion de tâches en utilisant Deno. Il comprend des fonctions pour ajouter, afficher et supprimer des tâches.

Erreurs fréquentes et debugging

1. Erreur de Syntaxe

## ❌ Mauvais
let tasks = []

## ✅ Correct
let tasks: Task[] = [];

2. Erreur d'Importation

## ❌ Mauvais
import { addTask } from "./tasks";

## ✅ Correct
import { addTask } from "./tasks.ts";

3. Erreur de Compilation TypeScript

## ❌ Mauvais
function greet(name): void {
    console.log(`Bonjour, ${name}!`);
}

greet("Deno");

## ✅ Correct
function greet(name: string): void {
    console.log(`Bonjour, ${name}!`);
}

greet("Deno");

Pour aller plus loin

1. Utilisation de l'API Asynchrone

Vous pouvez utiliser les promesses et les async/await pour gérer des opérations asynchrones.

// async.ts
async function fetchData(url: string): Promise<string> {
    const response = await fetch(url);
    return response.text();
}

fetchData("https://jsonplaceholder.typicode.com/posts/1").then(data => {
    console.log(data);
});

2. Utilisation de Middleware en Express

Deno n'a pas de middleware intégré comme dans Express, mais vous pouvez créer votre propre système.

// middleware.ts
import { Application } from "https://deno.land/x/oak@v10.0.0/mod.ts";

const app = new Application();

app.use(async (ctx, next) => {
    console.log("Méthode:", ctx.request.method);
    await next();
});

app.use((ctx) => {
    ctx.response.body = "Hello Deno!";
});

await app.listen({ port: 8000 });

3. Création d'un CLI Tool

Vous pouvez créer des outils en ligne de commande (CLI) avec Deno.

// cli.ts
import { Command } from "https://deno.land/x/cliffy@v1.0.2/mod.ts";

const command = new Command();

command
  .name("my-cli")
  .description("Ma CLI simple")
  .action(() => {
    console.log("Bienvenue dans ma CLI!");
  });

await command.parse(Deno.args);

Défi Pratique

Défi : Créer une API de Blog

Créez une API de blog simple qui permet d'ajouter des articles, de les récupérer et de les supprimer. Utilisez Deno pour le serveur et le middleware pour la gestion des routes.

N'hésitez pas à consulter les documents officiels de Deno et de Oak pour plus d'informations sur ces concepts.