Comment compiler Rust dans WebAssembly et l'exécuter Deno

Ce didacticiel vous explique tout ce que vous devez savoir pour compiler un projet Rust vers WebAssembly, puis l'exécuter dans Deno.

Pourquoi Rust? Les applications Web peinent à atteindre et à conserver des performances fiables. Le système de type dynamique de JavaScript et les pauses de ramasse-miettes n'aident pas. Des changements de code apparemment minimes peuvent entraîner des régressions drastiques des performances si vous vous écartez accidentellement du chemin heureux du JIT (Just In Time Compiler).

Rust donne aux programmeurs un contrôle de bas niveau et des performances fiables. Il est exempt des pauses non déterministes de ramasse-miettes qui affligent JavaScript. Les programmeurs contrôlent l'indirection, la monomorphisation et la disposition de la mémoire.

Voici le contenu que nous allons couvrir, de l'installation des outils nécessaires pour compiler le code Rust et des outils pour le compiler au format WebAssembly, pour enfin charger et utiliser la bibliothèque dans Deno. Avant d'aller plus loin, les éléments suivants doivent être installés sur votre machine pour travailler avec Rust et Deno.

• rustc: Ceci est le compilateur pour le langage de programmation Rust, fourni par le projet lui-même. Les compilateurs prennent votre code source et produisent du code binaire, sous forme de bibliothèque ou d'exécutable.
• rustup: Ceci installe le langage de programmation Rust à partir des canaux de publication officiels, vous permettant de basculer facilement entre stable , bêta et compilateurs nocturnes et tenez-les à jour.
• cargo: Voici le gestionnaire de paquets Rust . Cargo télécharge les dépendances de votre package Rust compile vos packages, crée des packages distribuables et les télécharge sur crates.io le package de la communauté Rust Registry.
• deno: Ceci est un runtime JavaScript / TypeScript avec des valeurs par défaut sécurisées et une excellente expérience développeur .

Configurer WebAssembly pour Rust

Maintenant, nous devons installer le suivant les outils WebAssembly pour Rust.

      rustup target add wasm32-unknown-unknown
     installation de fret wasm-gc

• wasm32-unknown-unknown: La cible wasm32-unknown-unknown représente une sortie WebAssembly qui ne fait aucune hypothèse sur son environnement, d'où la unknown-unknown . La cible est destinée à encapsuler des cas d'utilisation qui ne reposent sur aucune fonctionnalité importée. Les binaires générés sont entièrement autonomes par défaut lors de l'utilisation de la bibliothèque standard.
• wasm-gc: Un petit outil pour ramasser un module WebAssembly et supprimer toutes les exportations, importations, fonctions, etc. inutiles

Remarque: Si vous utilisez Visual Studio Code pour le développement, installez les extensions suivantes.

• Better Toml bungcip.better-toml
• Rust rust-lang.rust

Créez un Cargo Lib

Tout d'abord, nous devons ouvrir Visual Studio Code dans notre espace de travail. Ensuite, nous devons créer une petite bibliothèque de chargement. Ouvrez le terminal et exécutez la commande suivante:

 cargo new --lib wasm_deno_example
 cd wasm_deno_example

Ensuite, ouvrez le fichier Cargo.toml et ajoutez les dépendances pour wasm.

 // Cargo.toml
    
[lib]
crate-type = ["cdylib"]

Note: cdylib rend notre projet utilisable avec d'autres langages comme C ou dans notre cas wasm . Il supprime également tous les éléments spécifiques nécessaires à la rouille.

Créer une fonction Rust

Collez le code suivant dans le fichier src / lib.rs .

 # [no_mangle]
 pub   extern   "C"   fn   âge  ( cy :  i32  yob :  i32 )   ->  i32  {
   cy  -  yob
} 

Il s'agit d'une fonction simple qui prend l'année en cours et votre année de naissance et renvoie votre âge.

Remarque: Nous avons ajouté le mot-clé extern pour que cette fonction peut être importé dans notre code Deno.

Compilation de Rust en WebAssembly

Maintenant, nous sommes prêts à compiler notre code rust en code wasm. Exécutez le code suivant pour le construire.

 $ cargo build --target wasm32-unknown-unknown

Ensuite, en utilisant le wasm-gc nous devons supprimer toutes les exportations, importations, fonctions, etc. inutiles.

 cible wasm-gc / wasm32-unknown-unknown / debug / wasm_deno_example.wasm

Maintenant, nous avons un binaire wasm prêt à être chargé dans Deno et exécuté.

Charger et exécuter un binaire avec Deno

Créer un fichier main.ts .

 touchez main.ts

Ajoutez le code suivant au fichier.

    
 const  wasmCode  =   await  Deno .  readFile  ( "./ target /wasm32-unknown-unknown/debug/wasm_deno_example.wasm"[19659032memories)[19659032[/[19659053 );[19659053Often(19459004] wasmModule  =   nouveau   WebAssembly .  Module 19659032] ( wasmCode ) ; 
 const  wasmInstance  =   new   WebAssembly .  Instance  ( wasmModule ) ; 
 const   {
   age 
}   =  wasmInstance .  exports ; 
 const  yourAge  =   age  ([19659070] 2020   1994 ) 
console .  journal  ( yourAge ) ; 

Le code ci-dessus charge le fichier brut. Ensuite, il crée un module wasm à partir de notre fichier afin que nous puissions travailler avec lui. Ensuite, il crée une instance de notre module afin que nous puissions utiliser les fonctions après lesquelles nous avons importé notre fonction wasm age () dans notre code Deno.

Pour exécuter le code, exécutez ce qui suit .

 deno exécuter --allow-read main.ts
    26 $

Conclusion

Et c’est tout! Vous venez d'écrire du code Rust, de le compiler dans WebAssembly, de charger le fichier WASM dans Deno et d'utiliser les fonctions.