石頭智能洗地機A10 Plus體驗：雙向自清潔治好了我的懶癌
一、前言和介紹專為家庭請假懶人而生的石頭科技在近日又帶來了自己的全新旗艦新品，石頭智能洗地機A10 Plus。從這個產(chǎn)品名上就不難看出，這次石頭推出的并不是常見的掃地機器
我們在Rust環(huán)境配置和入門指南中詳細介紹了
下面，我們就之間直入主題了。
通過創(chuàng)建一個名為 main.rs 的文件并將以下代碼放入其中來編寫我們的第一個 Rust 代碼：
fn main() { println!("Hello, Front789!");}然后通過運行 rustc main.rs 和 ./main.exe 來運行這個程序，就像運行 C 程序一樣。
Cargo 是 Rust 的構(gòu)建系統(tǒng)和包管理器
我們也可以使用 cargo 創(chuàng)建項目。
在 Rust 中，默認情況下「變量是不可變」的，這意味著一旦給變量賦值，其值就不會改變。
所以如果想要一個可變的，即可改變的值，使用 mut。
let a = 5;let mut b = 5; // 可變的
圖片
let number: i32 = 42;
圖片
let pi: f64 = 3.14159;let is_rust_cool: bool = true;let heart_emoji: char = '?';
圖片
let mut s = String::from("front789");let s1: &str = "front789";let array: [i32; 3] = [1, 2, 3];let a = [3; 5]; // 用值 3 初始化大小為 5 的數(shù)組
圖片
為了從元組中獲得單個的值，可以使用「模式匹配」來解構(gòu)元組
還可以通過「索引」并使用點號(.)來訪問元組中的值
let tup = (500, 6.4, 1);let (x, y, z) = tup;let aa = tup.0; // 引用元組中的第一個項目
圖片
指針是一個變量，它存儲了一個值的「內(nèi)存地址」
Rust 中最常見的指針是引用。引用以 & 符號為標志并「借用了它們所指向的值」。除了引用數(shù)據(jù)沒有任何其他特殊功能。它們也沒有任何額外開銷，所以應用得最多。
fn main() { // 標量類型 let number: i32 = 42; let pi: f64 = 3.14159; let is_rust_cool: bool = true; let heart_emoji: char = '?'; // 復合類型 let array: [i32; 3] = [1, 2, 3]; let tuple: (i32, f64, char) = (10, 3.14, 'a'); let slice: &[i32] = &[1, 2, 3]; let string: String = String::from("Hello, Front789!"); let string_slice: &str = "Hello, Front789!"; // 特殊類型 let reference_to_number: &i32 = &number; let optional_value: Option<i32> = Some(42); let result_value: Result<i32, &str> = Ok(42);}以上內(nèi)容就是Rust中所涉及到的各種數(shù)據(jù)類型，我們可以從以下的鏈接中找到更為詳細的解釋
不可變數(shù)組在 Rust 中用 [T; N] 語法來聲明,其中 T 表示數(shù)組元素的類型,而 N 表示數(shù)組的長度。
對于不可變數(shù)組,我們可以使用下標訪問其元素,但不能修改元素的值。
let array = [1, 2, 3, 4, 5];let first_element = array[0]; // 訪問第一個元素arr[0] = 6; // 這行代碼會導致編譯錯誤,因為數(shù)組是不可變的// 迭代// 使用 for 循環(huán)for &num in &array { println!("{}", num);}// 另一種迭代器array.iter().for_each(|&num| { println!("{}", num);});let slice = &array[1..3]; // 從索引 1 到索引 2（包括）切片Vec<T> 是 Rust 中可變長數(shù)組的實現(xiàn),它允許您動態(tài)地增加或減少數(shù)組的大小。
let mut array = [1, 2, 3, 4, 5];array[0] = 10; // 修改第一個元素let mut vec = Vec::new(); // 創(chuàng)建一個空 Vecvec.push(1); // 向 Vec 中添加一個元素vec.push(2);vec.push(3);// 使用 iter() 遍歷元素for item in array.iter() { println!("{}", item);}// iter_mut() 方法返回一個可變的迭代器,允許修改 Vec 中的元素for item in array.iter_mut() { *item += 1; // 對每個元素加 1}// maplet doubled_array: Vec<_> = array.iter() .map(|&num| num * 2) .collect();// filterlet even_elements: Vec<_> = array.iter() .filter(|&&num| num % 2 == 0) .collect();// len() 方法返回 Vec 中元素的數(shù)量array.len()// remove() 方法移除指定索引位置的元素,并返回該元素。如果索引越界,它將導致 panic。let removed_item = array.remove(2) // removed_item 為3let s1 = String::from("Hello, ");let s2 = String::from("Front789!");let combined = s1 + &s2; // 注意：s1 在這里被移動，之后不能再使用println!("{}", combined); // 打印 "Hello, Front789!"let mut s = String::from("Hello, ");s.push_str("Front789!");println!("{}", s); // 打印 "Hello, Front789!"http:// 獲取字符let s = String::from("hello");let first_char = s.chars().nth(0); // 訪問第一個字符// 子字符串let s = String::from("hello Front789");let substring = &s[0..5]; // 提取 "hello"http:// len()let s = String::from("hello");let length = s.len(); // 字符串的長度// replacelet s = String::from("hello");let replaced = s.replace("l", "z"); // 替換 "l" 為 "z"http:// splitlet s = String::from("hello Front789");let words: Vec<&str> = s.split_whitespace().collect(); // 分割成單詞// 轉(zhuǎn)換 &str 和 Stringlet s = String::from("hello");let s_ref: &str = &s; // 將 String 轉(zhuǎn)換為 &strlet s_copy: String = s_ref.into(); // 將 &str 轉(zhuǎn)換為 Stringlet mut v1 = vec![1, 2, 3]; // 使用 vec![] 宏let mut v2: Vec<i32> = Vec::new(); // 使用 Vec::new() 構(gòu)造函數(shù)let mut v = Vec::new();v.push(1);v.push(2);let first_element = v[0]; // 訪問第一個元素// 迭代// 使用 for 循環(huán)for num in &v { println!("{}", num);}// 使用迭代器v.iter().for_each(|&num| { println!("{}", num);});// slicelet slice = &v[1..3]; // 從索引 1 到索引 2（包括）提取元素// removelet removed_element = v.remove(1); // 移除索引為 1 的元素（返回被移除的元素）// sort()v.sort();// joinlet tt= vec!["hello", "Front789"];let joined_string = tt.join(", "); // 使用逗號和空格連接元素Rust代碼使用「蛇形命名法」來作為規(guī)范函數(shù)和變量名稱的風格。蛇形命名法「只使用小寫的字母進行命名，并以下畫線分隔單詞」。
fn 函數(shù)名(參數(shù)1: 類型1, 參數(shù)2: 類型2) -> 返回類型 { // 函數(shù)體 // 可選的表達式}最后一行返回值時不需要調(diào)用 return。
fn add_numbers(x: i32, y: i32) -> i32 { let sum = x + y; sum // 函數(shù)中的最后一個表達式會隱式返回}如果想要一個無返回值的函數(shù)，不要定義返回類型。
我們可以在基礎概念_函數(shù)部分查看更詳細的解釋
要讀取一個值，使用 io stdin 并給出變量的值，在失敗時需要提供 expect 消息，否則會出錯。
let mut guess = String::new(); io::stdin().read_line(&mut guess).expect("該行讀取失敗");println!("輸出對應的變量信息 {}", guess); // 這里的 guess 是變量名。你也可以在末尾有變量
let y = 10;println!("y + 2 = {}", y + 2);在Rust中，一個「新的聲明變量可以覆蓋掉舊的同名變量」，我們把這一個現(xiàn)象描述為：「第一個變量被第二個變量遮蔽Shadow了」。這意味著隨后使用這個名稱時，它指向的將會是第二個變量。
fn main() { let x = 5; // 定義值為 5 的變量 x println!("原始值 x: {}", x); // 打印 "原始值 x: 5" let x = 10; // Shadowing：定義一個新的值為 10 的變量 x println!("Shadowed x: {}", x); // 打印 "Shadowed x: 10"}
圖片
圖片
if condition1 { // 如果 condition1 為真，則執(zhí)行的代碼} else if condition2 { // 如果 condition2 為真，則執(zhí)行的代碼} else { // 如果 condition1 和 condition2 都為假，則執(zhí)行的代碼}Rust提供了3種循環(huán)
loop { println!("永無止境的執(zhí)行");}let mut count = 0;while count < 5 { println!("Count: {}", count); count += 1;}for i in 0..5 { println!("{}", i);}當然也少不了對數(shù)值的遍歷操作。
(1..=5).for_each(|num| { println!("Number: {}", num);});// Number: 1// Number: 2// Number: 3// Number: 4// Number: 5..:它表示一個擴展運算符，表示從第一個數(shù)字到最后一個數(shù)字生成。
我們也可以在循環(huán)中使用 continue 和 break。
圖片
這個概念是需要特別注意和反復觀看的部分。
當變量值被重新分配時，值會給新的所有者，并且舊的所有者被丟棄。
這種行為在字符串中經(jīng)常看到，而不是其他類型，如下所示：
let s1 = String::from("hello");let s2 = s1;println!("{}, world!", s1);這將導致錯誤，因為 s1 在 s2=s1 之后不再有效。
如何解決上面的問題呢，我們可以使用 Clone：
let s1 = String::from("hello");let s2 = s1.clone();println!("s1 = {}, s2 = {}", s1, s2);某些類型隱式實現(xiàn)了 Clone。
let x = 5; // x 擁有整數(shù) 5let y = x; // 將 x 的值復制到 y，不傳遞所有權例如，整數(shù)隱式實現(xiàn)了 Clone，因此這段代碼不會報錯。
圖片
fn main() { let s = String::from("hello"); // s 進入作用域 takes_ownership(s); // s 的值移動進入函數(shù)... // ... 所以這里不再有效 let x = 5; // x 進入作用域 makes_copy(x); // x 會移入函數(shù)， // 但 i32 是 Copy，所以在之后繼續(xù)使用 x 是可以的} // 在這里，x 超出作用域，然后是 s。但因為 s 的值被移動了，所以沒有什么特別的發(fā)生。fn takes_ownership(some_string: String) { // some_string 進入作用域 println!("{}", some_string);} // 在這里，some_string 超出作用域，調(diào)用 drop。內(nèi)存被釋放。fn makes_copy(some_integer: i32) { // some_integer 進入作用域 println!("{}", some_integer);} // 在這里，some_integer 超出作用域。沒有什么特別的發(fā)生。如果我們像在變量被移動后，繼續(xù)使用，那么我們就使用 takes_ownership(s.clone()); （或者）在 takes_ownership 函數(shù)中返回值，像這樣：
fn main() { let s2 = String::from("hello"); // s2 進入作用域 let s3 = takes_and_gives_back(s2); // s2 移入并被返回}fn takes_and_gives_back(a_string: String) -> String { a_string // 返回并移出到調(diào)用函數(shù)}傳遞變量的引用，所有權不會被傳遞。
我們稱「創(chuàng)建引用的操作為借用」。就像現(xiàn)實生活中，如果一個人擁有一樣東西，你可以從他們那里借來。借了之后，你必須歸還。你不擁有它。
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{}' is {}.", s1, len);}fn calculate_length(s: &String) -> usize { s.len()}針對此處更詳細的內(nèi)容，可以翻看我們之前的所有權
struct，或者 structure，是一個「自定義數(shù)據(jù)類型」，允許我們命名和包裝多個相關的值，從而形成一個有意義的組合。
圖片
struct User { active: bool, username: String, email: String, sign_in_count: u64,}fn main() { let mut user1 = User { active: true, username: String::from("front789"), email: String::from("front789@example.com"), sign_in_count: 1, }; user1.email = String::from("anotheremail@example.com"); let user2 = User { email: String::from("another@example.com"), ..user1 };}在 user2 中，你會看到 ..，它是擴展運算符，將 user1 中剩余的值傳遞給 user2（除了已經(jīng)定義的 email）。
使用 impl 結(jié)構(gòu)體名，并在其中定義函數(shù)。
#[derive(Debug)]struct Rectangle { width: u32, height: u32,}impl Rectangle { fn area(&self) -> u32 { self.width * self.height }}fn main() { let rect1 = Rectangle { width: 30, height: 50, }; println!( "長方形的面積為 {}", rect1.area() );}
圖片
針對此處更詳細的內(nèi)容，可以翻看我們之前的結(jié)構(gòu)體
枚舉，也被稱作 enums。枚舉允許你通過「列舉可能的成員variants來定義一個類型」
enum IpAddrKind { V4, V6,}let four = IpAddrKind::V4;let six = IpAddrKind::V6;枚舉的成員位于其標識符的「命名空間中」，并「使用兩個冒號分開」。
這是類似于 switch 的東西，
enum Coin { Penny, Nickel, Dime, Quarter,}fn value_in_cents(coin: Coin) -> u8 { match coin { Coin::Penny => 1, Coin::Nickel => 5, Coin::Dime => 10, Coin::Quarter => 25, } let number = 5; match number { 1 => println!("One"), 2 => println!("Two"), 3 | 4 | 5 => println!("Three, Four, or Five"), _ => println!("Other"), // 默認情況 }}每個分支相關聯(lián)的代碼是一個表達式，而表達式的結(jié)果值將作為整個 match 表達式的返回值。
圖片
這是一種使用 if 的花式方式，我們在其中定義一個表達式。
fn main() { let optional_number: Option<i32> = Some(5); // 使用 if let 匹配 Some 變體并提取內(nèi)部值 if let Some(num) = optional_number { println!("Value: {}", num); } else { println!("No value"); }}
圖片
為了創(chuàng)建一個新線程，需要調(diào)用 thread::spawn 函數(shù)并「傳遞一個閉包」，并在其中包含希望在新線程運行的代碼。
可以通過將 thread::spawn 的「返回值儲存在變量中來修復新建線程部分沒有執(zhí)行或者完全沒有執(zhí)行的問題」。thread::spawn 的返回值類型是 JoinHandle。JoinHandle 是一個「擁有所有權的值」，當「對其調(diào)用 join 方法時，它會等待其線程結(jié)束」。
use std::thread;fn main() { // 數(shù)據(jù) let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // 將數(shù)據(jù)分成兩部分 let mid = numbers.len() / 2; let (left, right) = numbers.split_at(mid); // 生成兩個線程來計算每一半的總和 let handle1 = thread::spawn(move || sum(left)); let handle2 = thread::spawn(move || sum(right)); // 等待線程完成并獲取它們的結(jié)果 let result1 = handle1.join().unwrap(); let result2 = handle2.join().unwrap(); // 計算最終總和 let total_sum = result1 + result2; println!("Total sum: {}", total_sum);}fn sum(numbers: &[i32]) -> i32 { let mut sum = 0; for &num in numbers { sum += num; } sum}thread::spawn 要求閉包具有 'static 生命周期，這意味著它不會從周圍范圍借用任何東西，并且可以在整個程序的持續(xù)時間內(nèi)存在。
因此，我們使用move 閉包，其經(jīng)常與 thread::spawn 一起使用，因為它允許我們「在一個線程中使用另一個線程的數(shù)據(jù)」。
本文鏈接：http://www.www897cc.com/showinfo-26-85705-0.html一網(wǎng)打盡 Rust 語法
聲明：本網(wǎng)頁內(nèi)容旨在傳播知識，若有侵權等問題請及時與本網(wǎng)聯(lián)系，我們將在第一時間刪除處理。郵件：2376512515@qq.com
Copyright ? 2016-2023 天津谷騏科技有限公司 版權所有 sitemap.xml
違法及侵權請聯(lián)系：2376512515@qq.com 津ICP備18001702號
津公網(wǎng)安備 12010102000574號