【Rust学习】03_常用编程概念

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}")
}

$ cargo run 
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` (bin "variables") due to 1 previous error

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}")
}

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.38s
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

fn main() {
    let spaces = "  ";
    let spaces = spaces.len();
    println!("spaces: {spaces}")
}

fn main() {
    let mut spaces = "  ";
    spaces = spaces.len();
    println!("spaces: {spaces}")
}

$cargo run
	Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
error[E0308]: mismatched types
  --> src/main.rs:39:14
   |
38 |     let mut spaces = "  ";
   |                      ---- expected due to this value
39 |     spaces = spaces.len();
   |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` (bin "variables") due to 1 previous error

let guess: u32 = "42".parse().expect("Not a number!");

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
error[E0284]: type annotations needed
  --> src/main.rs:46:9
   |
46 |     let guess = "42".parse().expect("Not a number!");
   |         ^^^^^        ----- type must be known at this point
   |
   = note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `guess` an explicit type
   |
46 |     let guess: /* Type */ = "42".parse().expect("Not a number!");
   |              ++++++++++++

For more information about this error, try `rustc --explain E0284`.
error: could not compile `variables` (bin "variables") due to 1 previous error

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
    println!("x: {x}, y: {y}")
}

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 4.67s
     Running `target/debug/variables`
x: 2, y: 3

fn main() {
    let sum = 5 + 10;
    let difference = 95.5 - 4.3;
    let product = 4 * 30;
    let quotient = 56.7 / 32.2;
    let floored = 2 / 3;
    let remainder = 43 % 5;
    println!("sum: {sum}, difference: {difference}, product: {product}, quotient: {quotient}, floored: {floored}, remainder: {remainder}")
}

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/variables`
sum: 15, difference: 91.2, product: 120, quotient: 1.7608695652173911, floored: 0, remainder: 3

fn main() {
    let t = true;
    let f: bool = false; // 显式类型标注
    println!("t: {t}, f: {f}")
}

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
    println!("c: {c}, z: {z}, heart_eyed_cat: {heart_eyed_cat}")
}

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

fn main() {
    let tup = (500, 6.4, 1);
    let (x, y, z) = tup;
    println!("x:{x}, y: {y}, z: {z}");
}

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/variables`
x:500, y: 6.4, z: 1

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);
    let five_hundred = x.0;
    let six_point_four = x.1;
    let one = x.2;
    println!("five_hundred: {five_hundred}, six_point_four: {six_point_four}, one: {one}")
}

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/variables`
five_hundred: 500, six_point_four: 6.4, one: 1

fn main() {
    let a = [1, 2, 3, 4, 5];
    println!("a:{:?}", a);
}

$ cargo run
   Compiling variables v0.1.0 (/Users/wangyang/Documents/project/rust-learn/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.11s
     Running `target/debug/variables`
a:[1, 2, 3, 4, 5]

let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

fn main() {
    let a:[i32;6] = [1, 2, 3, 4, 5, 6];
    println!("a:{:?}", a);
}

fn main() {
    let a = [3; 5];
    println!("a:{:?}", a);
}

fn main() {
    let a:[i32;6] = [1, 2, 3, 4, 5, 6];
    let first = a[0];
    let second = a[1];
    println!("a:{:?}", a);
    println!("first: {first}, second: {second}")
}

use std::io;
// 无效的数组访问
fn  main() {
    let a = [1,2,3,4,5,6];
    println!("Please enter an array index：");
    let mut index = String::new();
    io::stdin().read_line(&mut index)
        .expect("Failed to read line");
    let index: usize = index.trim().parse()
        .expect("Index entered was not a number");
    let element = a[index];
    println!("The value of the element at index {index} is: {element}");
}

    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/variables`
Please enter an array index：
10
thread 'main' panicked at src/main.rs:121:19:
index out of bounds: the len is 6 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

fn main() {
    println!("Hello, world!");
    author_function();
}

fn author_function() {
    println!("author function")
}

$ cargo run
   Compiling function v0.1.0 (/Users/wangyang/Documents/project/rust-learn/function)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.19s
     Running `target/debug/function`
Hello, world!
author function

fn main() {
    author_function("Tim");
}

fn author_function(name: &str) {
    println!("author function: {}", name)
}

$ cargo run
   Compiling function v0.1.0 (/Users/wangyang/Documents/project/rust-learn/function)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/function`
author function: Tim

fn main() {
    author_function("Tim", 10);
}

fn author_function(name: &str, age: i32) {
    println!("author function name: {}, age:{}", name, age)
}

$ cargo run
   Compiling function v0.1.0 (/Users/wangyang/Documents/project/rust-learn/function)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/function`
author function name: Tim, age:10

fn main() {
    let y = 6;
}

fn main() {
    let x = (let y = 6);
}

$ cargo run
 Compiling function v0.1.0 (/Users/wangyang/Documents/project/rust-learn/function)
error: expected expression, found `let` statement
  --> src/main.rs:15:14
   |
15 |     let x = (let y = 6);
   |              ^^^
   |
   = note: only supported directly in conditions of `if` and `while` expressions

warning: unnecessary parentheses around assigned value
  --> src/main.rs:15:13
   |
15 |     let x = (let y = 6);
   |             ^         ^
   |
   = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
   |
15 -     let x = (let y = 6);
15 +     let x = let y = 6;
   |

warning: `function` (bin "function") generated 1 warning
error: could not compile `function` (bin "function") due to 1 previous error; 1 warning emitted

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {}", y);
}

{
  let x = 3;
  x + 1
};

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {}", x);
}

$ cargo run
 Compiling function v0.1.0 (/Users/wangyang/Documents/project/rust-learn/function)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/function`
The value of x is: 5

let x = 5;

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

$ cargo run
	Compiling function v0.1.0 (/Users/wangyang/Documents/project/rust-learn/function)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/function`
The value of x is: 6

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1;
}

   Compiling function v0.1.0 (/Users/wangyang/Documents/project/rust-learn/function)
error[E0308]: mismatched types
  --> src/main.rs:43:24
   |
43 | fn plus_one(x: i32) -> i32 {
   |    --------            ^^^ expected `i32`, found `()`
   |    |
   |    implicitly returns `()` as its body has no tail or `return` expression
44 |     x + 1;
   |          - help: remove this semicolon to return this value

For more information about this error, try `rustc --explain E0308`.
error: could not compile `function` (bin "function") due to 1 previous error

// 这是一个注释

// 注释一
// 注释二

fn main() {
    let lucky_number = 7; // I’m feeling lucky today
}

fn main() {
    // I’m feeling lucky today
    let lucky_number = 7; 
}

fn main() {
    let number = 6;
    if number > 5 {
        println!("Number is greater than 5");
    } else {
        println!("Number is less than or equal to 5");
    }
}

$ cargo run
   Compiling branches v0.1.0 (/Users/wangyang/Documents/project/rust-learn/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 4.38s
     Running `target/debug/branches`
Number is greater than 5

let number = 4

$ cargon run
   Compiling branches v0.1.0 (/Users/wangyang/Documents/project/rust-learn/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/branches`
Number is less than or equal to 5

fn main() {
    let number = 4;
    if number {
        println!("Number is greater than 5")
    }
}

$ cargo run
   Compiling branches v0.1.0 (/Users/wangyang/Documents/project/rust-learn/branches)
error[E0308]: mismatched types
 --> src/main.rs:9:8
  |
9 |     if number {
  |        ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

fn main() {
    let number = 4;
    if number != 0 {
        println!("number was something other than zero");
    }
}

$ cargo run
   Compiling branches v0.1.0 (/Users/wangyang/Documents/project/rust-learn/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.51s
     Running `target/debug/branches`
number was something other than zero

fn main() {
    let number = 4;
    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

$cargo run
	Compiling branches v0.1.0 (/Users/wangyang/Documents/project/rust-learn/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/branches`
number is divisible by 4

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("The value of number is: {}", number);
}

/Users/wangyang/.cargo/bin/cargo run --color=always --package branches --bin branches
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/branches`
The value of number is: 5

Process finished with exit code 0

fn main() {
    let condition = true;

    let number = if condition { 5 } else { "six" };

    println!("The value of number is: {}", number);
}

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:44:44
   |
44 |     let number = if condition { 5 } else { "six" };
   |                                 -          ^^^^^ expected integer, found `&str`
   |                                 |
   |                                 expected because of this

fn main() {
    loop {
        println!("Hello, world!");
    }
}

Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
He^C
Process finished with exit code 130 (interrupted by signal 2:SIGINT)

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

/Users/wangyang/.cargo/bin/cargo run --color=always --package loops --bin loops
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/loops`
The result is 20

Process finished with exit code 0

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

/Users/wangyang/.cargo/bin/cargo run --color=always --package loops --bin loops
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

Process finished with exit code 0

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

/Users/wangyang/.cargo/bin/cargo run --color=always --package loops --bin loops
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/loops`
3!
2!
1!
LIFTOFF!!!

Process finished with exit code 0

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {}", element);
    }
}

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

/Users/wangyang/.cargo/bin/cargo run --color=always --package loops --bin loops
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/loops`
3!
2!
1!
LIFTOFF!!!

Process finished with exit code 0