🦀 Start Rust · เริ่มเขียน Rust · 开始学 Rust

🎯 What this lesson gives you · สิ่งที่คุณจะได้จากบทเรียนนี้ · 本课能给你什么

🎬 Where Rust comes from · Rust มาจากไหน · Rust 是从哪来的

1️⃣ The words Rust people use · คำศัพท์ที่คน Rust ใช้ · Rust 的人常说的词

3️⃣ Your first program — and the entry point · โปรแกรมแรก และจุดเริ่มต้น · 第一个程序，和入口点

cargo new hello
cd hello

fn main() {
    println!("Sawadee from Chiang Mai!");
}

4️⃣ The three cargo commands · สามคำสั่งของ cargo · cargo 的三个命令

5️⃣ Variables cannot change — unless you say so · ตัวแปรเปลี่ยนค่าไม่ได้ ถ้าไม่บอกไว้ก่อน · 变量不能改 —— 除非你说可以

fn main() {
    let city = "Chiang Mai";
    let year = 1296;

    println!("{} was born in {}", city, year);

    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

fn main() {
    let count = 0;
    count = count + 1;
    println!("{}", count);
}

error[E0384]: cannot assign twice to immutable variable `count`
 --> src/main.rs:3:5
  |
2 |     let count = 0;
  |         ----- first assignment to `count`
3 |     count = count + 1;
  |     ^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut count = 0;
  |         +++

6️⃣ Types are written down · ต้องเขียนชนิดข้อมูล · 类型要写出来

fn main() {
    let age: i32 = 14;
    let price: f64 = 45.5;
    let open: bool = true;
    let name: &str = "Ploy";
    let owned: String = String::from("Nong Mee");

    println!("{} {} {} {} {}", age, price, open, name, owned);
}

7️⃣ Functions · ฟังก์ชัน · 函数

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn greet(name: &str) -> String {
    format!("Sawadee, {}!", name)
}

fn main() {
    println!("{}", add(2, 3));
    println!("{}", greet("Ploy"));
}

8️⃣ structs — your own kind of thing · struct — สร้างชนิดข้อมูลของคุณเอง · struct —— 自己定义的东西

struct Creep {
    name: String,
    speed: f64,
    hit_points: u32,
}

impl Creep {
    fn new(name: &str, speed: f64, hit_points: u32) -> Creep {
        Creep { name: name.to_string(), speed, hit_points }
    }

    fn is_alive(&self) -> bool {
        self.hit_points > 0
    }
}

fn main() {
    let mut a = Creep::new("fast one", 3.0, 1);
    let b = Creep::new("tough one", 1.0, 3);

    println!("{} moves at {}", a.name, a.speed);
    println!("{} has {} hit points", b.name, b.hit_points);

    a.hit_points -= 1;
    println!("{} alive? {}", a.name, a.is_alive());
}

9️⃣ Owning and borrowing · การเป็นเจ้าของและการยืม · 拥有与借用

fn shout(text: &String) -> String {
    text.to_uppercase()
}

fn main() {
    let name = String::from("Chiang Mai");

    // we lend it with &, so we can still use it afterwards
    println!("{}", shout(&name));
    println!("{} is still here", name);
}

fn take(text: String) -> usize {
    text.len()
}

fn main() {
    let name = String::from("Chiang Mai");
    let n = take(name);
    println!("{} has {} letters", name, n);
}

error[E0382]: borrow of moved value: `name`
 --> src/main.rs:8:37
  |
6 |     let name = String::from("Chiang Mai");
  |         ---- move occurs because `name` has type `String`
7 |     let n = take(name);
  |                  ---- value moved here
8 |     println!("{} has {} letters", name, n);
  |                                   ^^^^ value borrowed here after move

1️⃣0️⃣ When there might be nothing — Option · เมื่ออาจไม่มีค่า — Option · 可能什么都没有 —— Option

fn find_price(fruit: &str) -> Option<u32> {
    match fruit {
        "mango" => Some(45),
        "durian" => Some(200),
        _ => None,
    }
}

fn main() {
    match find_price("mango") {
        Some(price) => println!("mango costs {} baht", price),
        None => println!("we do not sell that"),
    }

    match find_price("apple") {
        Some(price) => println!("apple costs {} baht", price),
        None => println!("we do not sell that"),
    }
}

1️⃣1️⃣ When something can fail — Result · เมื่อบางอย่างอาจล้มเหลว — Result · 可能会失败 —— Result

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        return Err(String::from("cannot divide by zero"));
    }
    Ok(a / b)
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(answer) => println!("the answer is {}", answer),
        Err(problem) => println!("problem: {}", problem),
    }

    match divide(10.0, 0.0) {
        Ok(answer) => println!("the answer is {}", answer),
        Err(problem) => println!("problem: {}", problem),
    }
}

1️⃣2️⃣ The ? shortcut — and the dangerous one · ทางลัด ? และตัวที่อันตราย · ? 这个捷径 —— 和那个危险的

fn to_number(text: &str) -> Result<i32, std::num::ParseIntError> {
    let number: i32 = text.parse()?;
    Ok(number * 2)
}

fn main() {
    match to_number("21") {
        Ok(n) => println!("double is {}", n),
        Err(e) => println!("bad number: {}", e),
    }

    match to_number("cat") {
        Ok(n) => println!("double is {}", n),
        Err(e) => println!("bad number: {}", e),
    }
}

fn main() {
    let text = "cat";
    let number: i32 = text.parse().unwrap();
    println!("{}", number);
}

thread 'main' panicked at src/main.rs:3:36:
called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

1️⃣3️⃣ The whole program · โปรแกรมทั้งหมด · 完整的程序

// scores.rs - read some lines, keep the good ones, say why the rest failed.

#[derive(Debug)]
struct Student {
    name: String,
    score: u32,
}

fn parse_line(line: &str) -> Result<Student, String> {
    let parts: Vec<&str> = line.split(',').collect();

    if parts.len() != 2 {
        return Err(format!("a line needs a name and a score: \"{}\"", line));
    }

    let name = parts[0].trim().to_string();
    if name.is_empty() {
        return Err(String::from("the name is empty"));
    }

    let score: u32 = parts[1]
        .trim()
        .parse()
        .map_err(|_| format!("\"{}\" is not a number", parts[1].trim()))?;

    Ok(Student { name, score })
}

fn average(students: &Vec<Student>) -> Option<u32> {
    if students.is_empty() {
        return None;
    }
    let total: u32 = students.iter().map(|s| s.score).sum();
    Some(total / students.len() as u32)
}

fn main() {
    let lines = ["Ploy, 82", "Aroon, 91", "Nong Mee, ninety", "Somchai", ", 70"];

    let mut good: Vec<Student> = Vec::new();

    for line in lines {
        match parse_line(line) {
            Ok(student) => {
                println!("ok      {} scored {}", student.name, student.score);
                good.push(student);
            }
            Err(problem) => println!("skipped {}", problem),
        }
    }

    match average(&good) {
        Some(mean) => println!("\naverage of {} students = {}", good.len(), mean),
        None => println!("\nno good lines, so no average"),
    }
}

ok      Ploy scored 82
ok      Aroon scored 91
skipped "ninety" is not a number
skipped a line needs a name and a score: "Somchai"
skipped the name is empty

average of 2 students = 86

1️⃣4️⃣ Where to go next · ไปต่อที่ไหน · 接下来去哪

1️⃣5️⃣ Check yourself · ทดสอบตัวเอง · 自我检测