CodeBlanks Logo Icon CodeBlanks
Login Register

Reading commands

Read command-line arguments with std::env::args.

Reading commands

In a real CLI, commands come from the program arguments: cargo run -- ekle "Süt al". std::env::args() gives the program path as its first element:

let args: Vec<String> = std::env::args().collect();
match args.get(1).map(|s| s.as_str()) {
    Some("ekle") => { /* args[2] */ }
    Some("liste") => { /* ... */ }
    _ => println!("Kullanım: todo <ekle|liste|bitir>"),
}

In the exercise we'll give the commands in an array and split each command into a name and an argument with split_once(' ').

Matching commands

Commands without arguments, like "liste", have no space; with unwrap_or((k, "")) we take the whole text as the name and the argument as empty. Then a match on the name:

for k in komutlar {
    let (ad, arg) = k.split_once(' ').unwrap_or((k, ""));
    match ad {
        "ekle" => { liste.ekle(arg); }
        "bitir" => { /* arg.parse() */ }
        "liste" => liste.listele(),
        _ => println!("Bilinmeyen komut: {ad}"),
    }
}

Practice Command handler

Process the commands ["ekle Süt al", "ekle Kod yaz", "bitir 1", "liste", "sil 3"] in order. Run ekle, bitir (parse the id) and liste with the methods you support; for anything else print Bilinmeyen komut: AD.

Starter code

main.rs
struct Gorev {
    id: u32,
    metin: String,
    bitti: bool,
}

struct Liste {
    gorevler: Vec<Gorev>,
    sonraki_id: u32,
}

fn main() {
    // buraya yaz
}

Sample solution

main.rs
struct Gorev {
    id: u32,
    metin: String,
    bitti: bool,
}

struct Liste {
    gorevler: Vec<Gorev>,
    sonraki_id: u32,
}

impl Liste {
    fn ekle(&mut self, metin: &str) -> u32 {
        self.sonraki_id += 1;
        self.gorevler.push(Gorev {
            id: self.sonraki_id,
            metin: metin.to_string(),
            bitti: false,
        });
        self.sonraki_id
    }
    fn tamamla(&mut self, id: u32) -> bool {
        match self.gorevler.iter_mut().find(|g| g.id == id) {
            Some(g) => {
                g.bitti = true;
                true
            }
            None => false,
        }
    }
    fn listele(&self) {
        for g in &self.gorevler {
            let isaret = if g.bitti { "x" } else { " " };
            println!("[{}] {}: {}", isaret, g.id, g.metin);
        }
    }
}

fn main() {
    let mut liste = Liste {
        gorevler: Vec::new(),
        sonraki_id: 0,
    };
    let komutlar = ["ekle Süt al", "ekle Kod yaz", "bitir 1", "liste", "sil 3"];
    for k in komutlar {
        let (ad, arg) = k.split_once(' ').unwrap_or((k, ""));
        match ad {
            "ekle" => {
                liste.ekle(arg);
            }
            "bitir" => {
                let tamam = arg.parse().map(|id| liste.tamamla(id)).unwrap_or(false);
                if !tamam {
                    println!("Görev yok: {}", arg);
                }
            }
            "liste" => liste.listele(),
            _ => println!("Bilinmeyen komut: {}", ad),
        }
    }
}

Expected output

[x] 1: Süt al
[ ] 2: Kod yaz
Bilinmeyen komut: sil

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What does <code>"bitir 1".split_once(' ')</code> return?

  • ("bitir", "1")
  • None
  • Some(("bitir", "1")) Correct answer
  • ["bitir", "1"]

Explanation: split_once splits at the first separator and returns a pair inside an Option; None if there is no separator.

2 Name and argument

Question 
let (ad, arg) = k.____(' ').unwrap_or((k, ""));
Answer 
let (ad, arg) = k.split_once(' ').unwrap_or((k, ""));

Explanation: split_once splits the text into two pieces at the first space.

3 Command and action

Term Meaning
ekle Süt al Adds a task
bitir 1 Marks number 1
liste Prints the list
sil 3 Unknown command

All lessons in Beginner

1 Rust basics

  1. What is Rust?
  2. Project with Cargo
  3. Your first program
  4. println! and formatting
  5. Comments
  6. Summary - Rust basics

2 Variables

  1. Variables with let
  2. Mutability with mut
  3. Constants with const
  4. Static variables
  5. Shadowing
  6. Summary - Variables

3 Data types

  1. Integers
  2. Floating point
  3. Bool and char
  4. Tuple
  5. Array
  6. Summary - Data types

4 Strings

  1. &str vs String
  2. Creating a String
  3. Concatenating strings
  4. format! macro
  5. String length
  6. Summary - Strings

5 Project: Calculator

  1. Project skeleton
  2. Reading input
  3. Computing
  4. Error handling
  5. Loop and exit

6 Functions

  1. Defining with fn
  2. Parameters
  3. Return value
  4. Expressions and statements
  5. Early return
  6. Summary - Functions

7 Control flow

  1. if-else
  2. match basics
  3. loop
  4. while loop
  5. for loop
  6. Summary - Control flow

8 Ownership

  1. What is ownership?
  2. Move semantics
  3. Copy trait
  4. Functions and ownership
  5. Return and ownership
  6. Summary - Ownership

9 Borrowing

  1. References
  2. Mutable reference
  3. Borrowing rules
  4. Dangling reference
  5. References and functions
  6. Summary - Borrowing

10 Slices

  1. String slices
  2. Slice syntax
  3. Array slices
  4. Slices and functions
  5. Range types
  6. Summary - Slices

11 Project: Guessing game

  1. Game skeleton
  2. Reading input
  3. Comparing numbers
  4. Random number
  5. Loop and exit

12 Structs

  1. Struct definition
  2. Creating an instance
  3. Tuple struct
  4. Unit-like struct
  5. Field update
  6. Summary - Structs

13 Methods

  1. impl block
  2. self parameter
  3. &mut self
  4. Associated functions
  5. Multiple impl blocks
  6. Summary - Methods

14 Enums

  1. Enum definition
  2. Variants
  3. Variants with data
  4. Option<T>
  5. Option instead of null
  6. Summary - Enums

15 Pattern matching

  1. match patterns
  2. Value binding
  3. if let
  4. while let
  5. _ wildcard
  6. Summary - Pattern matching

16 Project: To-do CLI

  1. Task model
  2. Adding
  3. Listing
  4. Marking done
  5. Reading commands

17 Vectors

  1. Vec<T>
  2. Push and pop
  3. Index and get
  4. Looping a vector
  5. with_capacity
  6. Summary - Vectors

18 Advanced strings

  1. String and &str conversion
  2. chars and bytes
  3. Slicing strings
  4. contains and replace
  5. split and join
  6. Summary - Advanced strings

19 Error handling

  1. Result<T, E>
  2. panic!
  3. ? operator
  4. match and Result
  5. unwrap and expect
  6. Summary - Error handling

20 Beginner final

  1. Vowel counter
  2. Average calculator
  3. Bank account
  4. Temperature converter