Heute lernen wir Rust

Ich habe vor ca. 1 Woche angefangen mich mit der Programmiersprache Rust zu beschäftigen. Als ich vor gut 1 Jahr wieder mit programmieren angefangen hatte, hatte ich die Sprachen Go und Rust in die engere Auswahl genommen. Letztendlich viel meine Entscheidung hier auf Go.

Der Grund warum ich nach gut einem Jahr jetzt doch noch einmal in Rust vorbeischaue ist reine Neugierde. Ich habe viel Gutes über die Sprache gehört und man wird dadurch ja auch nicht dümmer 😇.

#100DaysOfCode sollten machbar sein

Ich habe mir vorgenommen das ganze im Rahmen der #100DaysOfCode Challenge zu machen. 1 Stunde am Tag zu programmieren ist jetzt nicht sooooo schwer für mich, das mache ich meistens sowieso. Ob ich das aber konsequent 100 Tage durchhalte wird sich zeigen.

Tag 1 - Rust, Methoden und Ownership

Wie gesagt, ich habe vor einer Woche mit Rust angefangen. D.h. ich habe das Buch gelesen (Klasse übrigens) und den Rustlings Kurs gemacht. Heute habe ich angefangen ein kleines Programm in Rust neu zu schreiben. Dabei habe ich ein paar Dinge über Ownership in Rust gelernt. Am besten verdeutlicht das glaube ich der Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

use std::string::String;

#[derive(Debug)]
struct Person {
    name: String,
    age: i32,
}

impl Person {
    fn hello(self) {
        println!("Hello {}, your age is {}", self.name, self.age);
    }
}

fn main() {
    let bob = Person {
        name: String::from("Bob"),
        age: 32,
    };
    bob.hello();
    println!("{:?}", bob)
}

Das sieht auf den ersten Blick richtig aus. Lässt man das Programm laufen bekommt man allerdings einen Fehler gezeigt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

error[E0382]: borrow of moved value: `bob`
  --> src/main.rs:21:22
   |
16 |     let bob = Person {
   |         --- move occurs because `bob` has type `Person`, which does not implement the `Copy` trait
...
20 |     bob.hello();
   |         ------- `bob` moved due to this method call
21 |     println!("{:?}", bob)
   |                      ^^^ value borrowed here after move
   |
note: this function consumes the receiver `self` by taking ownership of it, which moves `bob`
  --> src/main.rs:10:14
   |
10 |     fn hello(self) {
   |   
     ^^^^

In Go würde man die Person einmal initialisieren und könnte dann beliebig oft die Methoden verwenden. Go würde hier lediglich zwischen einem Pointer und Nicht-Pointer Receiver unterscheiden, aber die Funktion wäre trotzdem immer verwendbar.

In Rust verbraucht die Verwendung der Methode das Objekt, da Sie durch die Verwendung von self Eigentümer des Objektes ist.

Da ich die Person nach Verwendung der Methode gerne noch nutzen möchte, muss ich diese an die Methode verleihen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// ...

impl Person {
    fn hello(&self) {
        println!("Hello" {}, your age is {}", self.name, self.age");
    }
}

//...

Und schon funktioniert alles. Nach Beendigung des Codeblocks in der hello Methode wird self wieder zurückgegeben.

Ich werde wahrscheinlich ein wenig brauchen bis ich mich daran gewöhnt habe und auch noch das eine oder andere Mal darüber stopern.

Dieser Beitrag ist Teil 6 von 100 Days To Offload. Wenn Du mitmachen willst, besuche https://100daystooffload.com

Dies ist Tag 1 / 100 von #100DaysOfCode