control flows addition

Author: venopyX

05. control_flow.md

@@ -0,0 +1,109 @@
+### 5. Control Flow: Conditional Statements and Loops
+
+#### Conditional Statements: `if`, `else if`, `else`
+
+Conditional statements in Rust allow you to execute different blocks of code based on certain conditions. The basic syntax for `if` statements is as follows:
+
+```rust
+let number = 10;
+
+if number > 0 {
+    println!("Number is positive");
+} else if number < 0 {
+    println!("Number is negative");
+} else {
+    println!("Number is zero");
+}
+```
+
+- The `if` statement checks the condition and executes the block of code if the condition is true.
+- The `else if` statement allows you to check additional conditions if the previous condition is false.
+- The `else` statement is optional and executes if none of the previous conditions are true.
+
+#### Pattern Matching with `match`
+
+Pattern matching in Rust provides a concise way to compare values against a series of patterns and execute code based on the matched pattern. Here's an example:
+
+```rust
+let number = 42;
+
+match number {
+    0 => println!("Zero"),
+    1 => println!("One"),
+    _ => println!("Other"),
+}
+```
+
+- The `match` keyword is followed by the value to match against.
+- Each arm of the match consists of a pattern followed by the `=>` operator and the code to execute if the pattern matches.
+- The `_` wildcard pattern matches any value and is often used as a catch-all case.
+
+#### Looping Constructs: `loop`, `while`, `for`
+
+Rust provides several looping constructs for executing code repeatedly.
+
+##### `loop`
+
+The `loop` keyword creates an infinite loop that continues until explicitly interrupted with a `break` statement.
+
+```rust
+let mut counter = 0;
+
+loop {
+    println!("Counter: {}", counter);
+    counter += 1;
+
+    if counter >= 10 {
+        break;
+    }
+}
+```
+
+##### `while`
+
+The `while` loop executes a block of code as long as the specified condition is true.
+
+```rust
+let mut counter = 0;
+
+while counter < 10 {
+    println!("Counter: {}", counter);
+    counter += 1;
+}
+```
+
+##### `for`
+
+The `for` loop iterates over elements of an iterator.
+
+```rust
+let numbers = [1, 2, 3, 4, 5];
+
+for number in numbers.iter() {
+    println!("Number: {}", number);
+}
+```
+
+#### Early Exit with `break` and `continue`
+
+- The `break` statement exits the current loop immediately.
+- The `continue` statement skips the rest of the current iteration and proceeds to the next iteration of the loop.
+
+#### Iterating Over Collections with `for` Loop and Iterators
+
+- Rust's `for` loop is particularly useful for iterating over collections like arrays, vectors, and ranges.
+- You can also use iterators, which provide a powerful way to work with sequences of elements in Rust.
+
+#### Best Practices
+
+- Use `if`, `else if`, and `else` for simple conditional branching, and `match` for more complex pattern matching scenarios.
+- Prefer `for` loops and iterators for iterating over collections, as they are more concise and idiomatic in Rust.
+- Use `loop` when you need to create an infinite loop with explicit exit conditions.
+
+#### Real-World Example
+
+Imagine you're developing a text adventure game in Rust. You use conditional statements to handle different player choices and looping constructs to manage game flow and interactions.
+
+#### Conclusion
+
+Understanding control flow constructs in Rust is essential for writing expressive and efficient code. By mastering these concepts, you'll have the tools to build complex algorithms and applications with confidence.