Reflexionen über die Programmiersprache Rust 10

*Mathematische Operatoren

Gerade jetzt bei der if-Anweisung habe ich bemerkt, dass es nötig ist einen genaueren Blick auf mathematische Operatoren zu werfen. Sonst ist es schwierig irgendwelche Vergleiche zu ziehen, oder vernünftige Bedingungen zu stellen. Alles was möglich ist, werde ich nicht durchmachen, da fehlt mir zT selbst noch die Erfahrung. Aber die Bekannten und Wichtigen auf alle Fälle!

Die Grundrechnungsarte +,-,/,* können wir uns wohl sparen. Dann gibt es den

Modulo Operator

Der wird mit einem Prozentzeichen geschrieben. Wozu ist der gut?
Er gibt immer den ersten Rest einer Division aus.

Bsp.5/2=2 geht in 5 2 mal, Rest 1. Also Modulo 1. Momentan kenne ich den Nutzen nur in zwei Punkten. Dadurch lässt sich prüfen, ob es eine Ganze oder gerade Zahl ist und ob die Zahl ohne Rest teilbar ist.
Es gibt aber noch einiges mehr, das von mir noch nicht genutzt wird.

Dann gibt es die
Vergleichsoperatoren

>   größer als
>=  größer gleich
<   kleiner als
<=  kleiner gleich
==  ident, gleich
!=  nicht gleich, ungleich

Logische Operatoren

&& logisches UND
Abfrage ist gültig, wenn alle Werte den Anforderungen entsprechen.

|| logisches ODER
Abfrage ist gültig, wenn ein Wert den Anforderungen entspricht.

!logische NEGATION
Wandelt den Wahrheitswert

und

Bereichsoperatoren

.. von bis
..= von bis gleich

Damit diese auch zur Geltung kommen, wie angekündigt ein paar Beispiele mit if-Anweisungen. Im vorherigen Abschnitt hatten wir einen ident Vergleich.
Die Unterscheidung liegt im zweiten Istgleichzeichen daneben, zu einer normalen Wertzuweisung.

fn main (){
    let x=7;
    if x == 5{
    println! ("Ja,das war die richtige Zahl");
    }
    else {
        println! ("Nein, die Zahl war falsch");
        
    }  
}

Ausgabe

weiter zu den Vergleichsoperatoren

let x =5;
    if x<5{
        println!("x ist kleiner als erwartet."); //nicht gültig
    }
    else if x>5{
        ("x ist größer als erwartet.");//nicht gültig
    }
    else if x !=6 {
        println!("Wenn x nicht 6 ist, muss es wohl etwas anderes sein. 5 vielleicht?");//richtig! wird ausgeben
    }
    else {
        println!("keine Ahnung!"); // wird nicht ausgegeben, weil !=6 bereits richtig war.
    }

logische Operatoren

logisches ODER

let mut x = 20;
    if x == 10 || x == 15 ||x == 20 || x == 25{
        println!("x war innerhalb der Werte und wird nun um 5 erhöht.");
        x = x+3;
        println!("x ist nun {}",x);
    }

logisches UND. Alle Werte müssen richtig sein.

   let mut x = 20;
   if x == 10 && x == 20{//x ist nur eine einzige Zahl, also vom Prinzip her falsch.
       println!("Ja, x besteht aus 10 und 20");
   }
   else{
       println!("x ist eine andere Zahl"); //das hier wird ausgegeben.
   }

//Wahrheitswert wandeln
    let a=false;
    let b=!a;

    if b == true {
        println!("b ist nicht a und deshalb stimmt es "); //das wird ausgebeben
    }
    else if b == false{
        println!("b ist falsch");
    }

Ich hoffe, dass ich diesen Bereich einigermaßen erklären konnte. Zum Schluss wieder die Zusammenfassung.

fn main (){
    //Modulo
    let x=5;
    if x%2==0{
        println!("{} ist eine gerade Zahl",x);
    }
    else{
        println!("{} ist eine ungerade Zahl",x); //Das hier wird augegeben.
    }

    //ident
    let x=7;
    if x == 5{
    println! ("Ja,das war die richtige Zahl");
    }
    else {
        println! ("Nein, die Zahl war falsch");

    }

    //Bereichsoperatoren

    let x =5;
    if x<5{
        println!("x ist kleiner als erwartet."); //nicht gültig
    }
    else if x>5{
        ("x ist größer als erwartet.");//nicht gültig
    }
    else if x !=6 {
        println!("Wenn x nicht 6 ist, muss es wohl etwas anderes sein. 5 vielleicht?");//richtig! wird ausgeben
    }
    else {
        println!("keine Ahnung!"); // wird nicht ausgegeben, weil !=6 bereits richtig war.
    }

    //logisches ODER. Nur 1 Wert muss richtig sein. Mehrere möglich.

    let mut x = 20;
    if x == 10 || x == 15 ||x == 20 || x == 25{//hier werten einige Werte auf einmal geprüft
        println!("x war innerhalb der Werte und wird nun um 5 erhöht.");
        x = x+3;
        println!("x ist nun {}",x);
    }

    //logisches UND. Alle Werte müssen richtig sein.
    let mut x = 20;
    if x == 10 && x == 20{//x ist nur eine einzige Zahl, also vom Prinzip her falsch.
        println!("Ja, x besteht aus 10 und 20");
    }
    else{
        println!("x ist eine andere Zahl"); //das hier wird ausgegeben.
    }

    //Wahrheitswert wandeln
    let a=false;
    let b=!a;

    if b == true {
        println!("b ist nicht a und deshalb stimmt es "); //das wird ausgebeben
    }
    else if b == false{
        println!("b ist falsch");
    }


}

Ausgabe