Rost - Iterator und Verschluss

In diesem Kapitel erfahren Sie, wie Iteratoren und Abschlüsse in RUST funktionieren.

Iteratoren

Ein Iterator hilft beim Durchlaufen einer Sammlung von Werten wie Arrays, Vektoren, Karten usw. Iteratoren implementieren das Iterator-Merkmal, das in der Rust-Standardbibliothek definiert ist. Die iter () -Methode gibt ein Iteratorobjekt der Auflistung zurück. Werte in einem Iteratorobjekt werden als Elemente bezeichnet. Die next () -Methode des Iterators kann verwendet werden, um die Elemente zu durchlaufen. Die next () -Methode gibt am Ende der Auflistung den Wert None zurück.

Im folgenden Beispiel wird ein Iterator verwendet, um Werte aus einem Array zu lesen.

fn main() {
   //declare an array
   let a = [10,20,30];

   let mut iter = a.iter(); 
   // fetch an iterator object for the array
   println!("{:?}",iter);

   //fetch individual values from the iterator object
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
}

Ausgabe

Iter([10, 20, 30])
Some(10)
Some(20)
Some(30)
None

Wenn eine Sammlung wie ein Array oder ein Vektor ein Iterator-Merkmal implementiert, kann sie mit der for ... in-Syntax wie unten gezeigt durchlaufen werden.

fn main() {
   let a = [10,20,30];
   let iter = a.iter();
   for data in iter{
      print!("{}\t",data);
   }
}

Ausgabe

10 20 30

Die folgenden 3 Methoden geben ein Iteratorobjekt aus einer Sammlung zurück, wobei T die Elemente in einer Sammlung darstellt.

Sr.Nr.	Methoden & Beschreibung
1	iter() gibt einen Iterator über & T (Verweis auf T)
2	into_iter() gibt einen Iterator über T.
3	iter_mut() gibt einen Iterator über & mut T.

Abbildung: iter ()

Die Funktion iter () verwendet das Konzept der Ausleihe. Es gibt einen Verweis auf jedes Element der Sammlung zurück, wobei die Sammlung unberührt bleibt und nach der Schleife wieder verwendet werden kann.

fn main() {
   let names = vec!["Kannan", "Mohtashim", "Kiran"];
   for name in names.iter() {
      match name {
         &"Mohtashim" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   println!("{:?}",names); 
   // reusing the collection after iteration
}

Ausgabe

Hello Kannan
There is a rustacean among us!
Hello Kiran
["Kannan", "Mohtashim", "Kiran"]

Illustration - into_iter ()

Diese Funktion verwendet das Konzept des Eigentums. Es verschiebt Werte in der Sammlung in ein Iter-Objekt, dh die Sammlung wird verbraucht und steht nicht mehr zur Wiederverwendung zur Verfügung.

fn main(){
   let names = vec!["Kannan", "Mohtashim", "Kiran"];
   for name in names.into_iter() {
      match name {
         "Mohtashim" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   // cannot reuse the collection after iteration
   //println!("{:?}",names); 
   //Error:Cannot access after ownership move
}

Ausgabe

Hello Kannan
There is a rustacean among us!
Hello Kiran

Illustration - für und iter_mut ()

Diese Funktion ähnelt der Funktion iter () . Diese Funktion kann jedoch Elemente in der Sammlung ändern.

fn main() {
   let mut names = vec!["Kannan", "Mohtashim", "Kiran"];
   for name in names.iter_mut() {
      match name {
         &mut "Mohtashim" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   println!("{:?}",names);
   //// reusing the collection after iteration
}

Ausgabe

Hello Kannan
There is a rustacean among us!
Hello Kiran
["Kannan", "Mohtashim", "Kiran"]

Schließung

Schließen bezieht sich auf eine Funktion innerhalb einer anderen Funktion. Dies sind anonyme Funktionen - Funktionen ohne Namen. Mit Closure kann einer Variablen eine Funktion zugewiesen werden. Dadurch kann ein Programm eine Funktion als Parameter an andere Funktionen übergeben. Das Schließen wird auch als Inline-Funktion bezeichnet. Auf Variablen in der äußeren Funktion kann über Inline-Funktionen zugegriffen werden.

Syntax: Definieren eines Abschlusses

Eine Abschlussdefinition kann optional Parameter haben. Die Parameter sind in zwei vertikalen Balken eingeschlossen.

let closure_function = |parameter| {
   //logic
}

Die Syntax, die ein Closure aufruft, wird implementiert FnZüge. Es kann also mit aufgerufen werden() Syntax.

closure_function(parameter);    //invoking

Illustration

Das folgende Beispiel definiert einen Abschluss is_even innerhalb der Funktion main () . Der Abschluss gibt true zurück, wenn eine Zahl gerade ist, und false, wenn die Zahl ungerade ist.

fn main(){
   let is_even = |x| {
      x%2==0
   };
   let no = 13;
   println!("{} is even ? {}",no,is_even(no));
}

Ausgabe

13 is even ? false

Illustration

fn main(){
   let val = 10; 
   // declared outside
   let closure2 = |x| {
      x + val //inner function accessing outer fn variable
   };
   println!("{}",closure2(2));
}

Die Funktion main () deklariert einen variablen Wert und einen Abschluss. Der Abschluss greift auf die in der äußeren Funktion main () deklarierte Variable zu .

Ausgabe