Section courante

A propos

Section administrative du site

Self

 Soi
Rust

Syntaxe

fn nom_de_la_methode(&self)
fn nom_de_la_methode(&mut self)
fn nom_de_la_methode(self)
impl MaStruct {
   fn nouvelle() -> Self {
      Self { champ: 0 }
   }
}

Paramètres

Nom Description
&self Ce paramètre permet de passer une référence immuable à l'instance actuelle dans une méthode.
&mut self Ce paramètre permet de passer une référence mutable à l'instance actuelle dans une méthode.
self Ce paramètre permet de transférer la possession de l'instance à la méthode.
Self Ce paramètre permet de faire référence au type dans lequel l'implémentation est en cours, notamment pour les constructeurs ou types associés.

Description

Ce mot réservé permet d'indiquer un alias de type pour le type que vous définissez ou mettez en oeuvre.

Remarques

Permet d'indiquer le récepteur d'une méthode, ou le module courant.

self est utilisé dans deux situations : pour référencer le module courant et pour marquer le récepteur d'une méthode.

Dans les chemins, self peut être utilisé pour faire référence au module courant, soit dans une instruction use, soit dans un chemin d'accès à un élément :

  1. use std::io::{self, Read};

Est fonctionnellement le même que :

  1. use std::io;
  2. use std::io::Read;

Utilisation de self pour accéder à un élément du module actuel :

  1. fn foo() {}
  2. fn bar() {
  3.     self::foo()
  4. }

Utiliser self comme récepteur courant d'une méthode permet généralement d'omettre le type du paramètre. À cette exception près, self s'utilise comme tout autre paramètre :

  1. struct Foo(i32);
  2.  
  3. impl Foo {
  4.     // No `self`.
  5.     fn new() -> Self {
  6.         Self(0)
  7.     }
  8.  
  9.     // Consuming `self`.
  10.     fn consume(self) -> Self {
  11.         Self(self.0 + 1)
  12.     }
  13.  
  14.     // Borrowing `self`.
  15.     fn borrow(&self) -> &i32 {
  16.         &self.0
  17.     }
  18.  
  19.     // Borrowing `self` mutably.
  20.     fn borrow_mut(&mut self) -> &mut i32 {
  21.         &mut self.0
  22.     }
  23. }
  24.  
  25. // Cette méthode doit être appelée avec un préfixe `Type::`.
  26. let foo = Foo::new();
  27. assert_eq!(foo.0, 0);
  28.  
  29. // Ces deux appels produisent le même résultat.
  30. let foo = Foo::consume(foo);
  31. assert_eq!(foo.0, 1);
  32. let foo = foo.consume();
  33. assert_eq!(foo.0, 2);
  34.  
  35. // L'emprunt est géré automatiquement avec la deuxième syntaxe.
  36. let borrow_1 = Foo::borrow(&foo);
  37. let borrow_2 = foo.borrow();
  38. assert_eq!(borrow_1, borrow_2);
  39.  
  40. // L'emprunt mutable est également géré automatiquement avec la deuxième syntaxe.
  41. let mut foo = Foo::new();
  42. *Foo::borrow_mut(&mut foo) += 1;
  43. assert_eq!(foo.0, 1);
  44. *foo.borrow_mut() += 1;
  45. assert_eq!(foo.0, 2);

Notez que cette conversion automatique lors de l'appel de foo.method() ne se limite pas aux exemples ci-dessus.



Dernière mise à jour : Vendredi, le 1er Août 2025