Was ist der Unterschied zwischen dem selbst und dem Selbst?

Self ist der Typ des aktuellen Objekts. Sie erscheinen entweder in einer trait oder eine impl, scheint aber am häufigsten in trait wo es ist ein stand-in für jede Art wird am Ende der Umsetzung der trait (die unbekannten bei der Festlegung der trait):

trait Clone {
    fn clone(&self) -> Self;
}

Wenn ich dann umsetzen Clone:

impl Clone for MyType {
    //I can use either the concrete type (known here)
    fn clone(&self) -> MyType;

    //Or I can use Self again, it's shorter after all!
    fn clone(&self) -> Self;
}

Ich könnte es auch verwenden, in regelmäßigen impl wenn ich faul bin (es ist kürzer!):

impl MySuperLongType {
    fn new(a: u32) -> Self { ... }
}

self ist der name verwendet, der in einem trait oder eine impl für das erste argument einer Methode. Mit einem anderen Namen ist möglich, allerdings gibt es einen wesentlichen Unterschied:

• wenn mit self, die Funktion wird eine Methode vorgestellt,
• wenn Sie einen anderen Namen, wird die Funktion eingeführt wird, eine zugehörige Funktion

In Rost, es gibt keine implizite this argument übergeben werden, geben die Methoden: Sie müssen explizit übergeben Sie das "current object" als parameter der Methode. Das Ergebnis wäre:

impl MyType {
    fn doit(this: &MyType, a: u32) { ... }
}

Wie wir gesehen haben, als eine kürzere form dieses könnte auch (noch verbose):

impl MyType {
    fn doit(this: &Self, a: u32) { ... }
}

Welches ist eigentlich das, was &self läuft darauf hinaus, unter der Decke.

impl MyType {
    fn doit(&self, a: u32) { ... }
}

Damit der Korrespondenz-Tabelle:

self => self: Self
&self => self: &Self
&mut self => self: &mut Self

Dem Weg zum aufrufen dieser Funktionen jedoch ändern:

impl MyType {
    fn doit(&self, a: u32) {
        //...
    }
    fn another(this: &Self, a: u32) {
        //...
    }
}

fn main() {
    let m = MyType;

    //Both can be used as an associated function
    MyType::doit(&m, 1);
    MyType::another(&m, 2);

    //But only `doit` can be used in method position
    m.doit(3);     //OK: `m` is automatically borrowed
    m.another(4);  //ERROR: no method named `another`
}