Introduction à Rust pour les développeurs JavaScript

Rust en est à sa sixième année d’être le langage de programmation le plus populaire (selon l’enquête Stack Overflow Developer Survey). Apprenons pourquoi !

Écrire du code JavaScript est incroyable. Les possibilités de ce que nous pouvons faire avec la langue aujourd’hui sont vastes. Des sites Web simples aux applications puissantes pouvant s’exécuter sur n’importe quelle plate-forme, JavaScript est devenu un langage étonnant pour les débutants.

Rust est un langage différent de JavaScript mais il est à la mode dans la communauté du développement. Les développeurs adorent Rust – l’adoption et le nombre d’entreprises et de projets utilisant le langage augmentent chaque jour.

Ce n’est pas une surprise quand on voit que le langage est le plus aimé (depuis 2016) parmi les centaines de milliers de développeurs qui participent au Enquête auprès des développeurs Stack Overflow chaque année.

Il existe de nombreuses raisons pour lesquelles Rust devient si populaire et nous allons comprendre quelles sont ces raisons.

Rouiller

Rouiller est un langage de programmation système créé par Mozilla. Le langage a pour objectif principal d’aider les développeurs à écrire au niveau du système sans avoir à se soucier de la mémoire et de la sécurité des threads.

Rust est un langage de programmation système rapide, fiable et puissant, économe en mémoire. Il n’a pas d’exécution ni de ramasse-miettes et peut facilement s’intégrer à d’autres langages (dites bonjour, JavaScript !).

Sécurité de la mémoire

Les langages de programmation sont un ensemble d’instructions permettant à un système d’effectuer certaines tâches. Nous avons différents langages de programmation pour de nombreux objectifs différents. En plus de tout cela, on peut dire qu’en fin de compte, il existe deux types de langages de programmation : bas niveau et haut niveau.

Les langages de haut niveau sont plus faciles à comprendre. La plupart du temps, la syntaxe est très conviviale et on voit bien ce qui se passe sous le capot. Nous avons de nos jours de nombreux langages de programmation de haut niveau tels que Java, Python et JavaScript.

L’une des principales caractéristiques d’un langage de haut niveau est le manque d’efficacité pour gérer la mémoire. Habituellement, un langage de haut niveau ne gère pas très bien la mémoire et consomme plus de mémoire que nécessaire.

Les langages de bas niveau sont difficiles à maintenir – la syntaxe n’est pas facile à comprendre pour les humains, mais les machines la comprennent assez bien. Les langages de bas niveau sont très compatibles avec les machines.

Le plus grand avantage des langages de bas niveau est la façon dont ils gèrent la mémoire. Les langages de bas niveau ont une efficacité mémoire très élevée. Cela signifie qu’ils consomment moins d’énergie par rapport à n’importe quel langage de haut niveau.

Pourquoi parlons-nous de langages de haut niveau ou de bas niveau ? Parce que Rust est un langage de programmation système qui est à la fois de haut niveau et de bas niveau.

Rust est un langage puissant conçu pour être sécurisé en mémoire. Il n’autorise pas les pointeurs nuls, les pointeurs pendants ou les courses de données. Les valeurs de données ne peuvent être initialisées que via un ensemble fixe de formulaires, qui nécessitent tous que leurs entrées soient déjà initialisées.

Comprenons mieux comment Rust gère si bien la mémoire et empêche erreurs de segmentation (types spécifiques d’erreurs causées par l’accès à de la mémoire qui « ne vous appartient pas »).

Immutabilité

Comme JavaScript, dans Rust, nous avons le let et const mots-clés pour déclarer des variables. Nous avons cependant quelques différences sur leur fonctionnement dans Rust.

Nous devrions ajouter un mut mot-clé après le let mot-clé lorsque nous voulons réaffecter. Le mut mot-clé signifie que la valeur de cette variable est modifiable.

fn main() {
  let age = 24;
  let mut name = "Leonardo";
}

Pour le const mot-clé, nous devons toujours ajouter le type de variable devant le nom de la variable.

fn main() {
  const FINAL_AGE: i32 = 24;
}

Dans Rust, on ne peut réassigner qu’une variable du même type. Par exemple, si nous essayons de réaffecter une valeur de chaîne à une variable qui a un type numérique, cela ne fonctionnera pas et l’éditeur nous affichera une erreur « types incompatibles ».

fn main() {
  let age = 24;
  age = "24"; // Error: mismatched types, expected integer, found `&str`rustc(E0308)
}

La possession

Un ramasse-miettes est une partie très importante de nombreux langages de programmation (comme JavaScript). UNE Éboueur est un processus de gestion automatique de la mémoire. Le collecteur parvient à collecter le code poubelle ou la mémoire occupée par des objets qui ne sont plus utilisés. La récupération de place libère les développeurs de la gestion manuelle de la mémoire.

Rust n’a pas de ramasse-miettes. Au lieu de cela, il dispose d’une fonctionnalité appelée Propriété, qui est chargée de sécuriser la mémoire de la langue.

La propriété est un ensemble de règles qui régissent la façon dont un programme Rust gère la mémoire. Tous les programmes doivent gérer la façon dont ils utilisent la mémoire d’un ordinateur pendant leur exécution.
– Documentation sur la rouille

Voici les trois règles de propriété dans Rust (également tirées de la documentation Rust) :

1. Chaque valeur dans Rust a une variable qui s’appelle son propriétaire.
2. Il ne peut y avoir qu’un seul propriétaire à la fois.
3. Lorsque le propriétaire sort de la portée, la valeur est supprimée.

La relation entre les portées et les variables est assez similaire dans Rust lorsque nous la comparons à JavaScript. Il n’y a qu’une différence très importante : la valeur reste valide jusqu’à ce qu’elle disparaisse hors de portée.

Lorsque nous créons une variable à l’intérieur d’une portée, la valeur est valide jusqu’à ce qu’elle sorte de la portée. Si nous créons une variable dans une portée et essayons d’utiliser cette valeur en dehors de la portée, cela ne fonctionnera pas.

fn main() {
  let age = 24;

  // new_age is not valid here, it’s not yet declared
  { // new_age is valid from this point forward
    let mut new_age = 24;
    new_age = 25;
    // we can do anything that we want with new_age inside this scope because it's valid
  } // this scope is now over, and new_age is no longer valid
}

La propriété est un nouveau concept pour de nombreux développeurs, en particulier les développeurs JavaScript. Il faut un certain temps pour s’y habituer. Nous devons garder à l’esprit les trois règles du système de propriété chaque fois que nous codons en Rust.

Structures

En JavaScript, le paradigme OOP (programmation orientée objet) est très largement utilisé. De nombreux projets utilisent ce paradigme et il y a de fortes chances que vous ayez travaillé ou travaillerez à l’avenir avec la POO en JavaScript.

Rust n’est pas un langage POO, mais il émule certaines fonctionnalités du paradigme et struct est l’une de ces caractéristiques.

UNE struct est un type de données dans Rust qui nous permet de combiner des éléments de données de différents types, y compris une autre structure. Une structure définit les données comme une paire clé-valeur.

fn main() {
  struct Person {
    name: String,
    age: i32
  }

  impl Person {
    fn introduce(self: &Person) {
        println!("Hello, my name is {} and I am {} years old", self.name, self.age);
    }
  }
}

Chaque champ d’un struct doit être associé à un type de données. Le impl mot clé est utilisé pour définir une méthode dans le contexte d’une structure. Le premier paramètre d’une méthode sera toujours self, qui représente l’instance appelante de la structure. Les méthodes opèrent sur les données membres d’une structure. Nous pouvons utiliser un struct pour séparer à la fois les données et les méthodes et faciliter notre code.

Conclusion

Nous pouvons voir que Rust est un langage très puissant qui possède de nombreuses fonctionnalités pour aider les développeurs à créer du code sécurisé en mémoire.

En tant que développeurs JavaScript, nous pouvons voir que Rust partage de nombreuses similitudes avec JavaScript et pourtant est un langage différent. L’utilisation de Rust par les développeurs JavaScript augmente chaque jour et vous gagneriez beaucoup à essayer Rust.

Bien qu’il faille un certain temps pour s’habituer à comprendre comment certaines choses fonctionnent dans Rust, la récompense en vaut la peine.