类似于滴滴的网站商城建设,采集规则wordpress,网页游戏排行榜梦幻西游,wordpress get category name【Rust】001-基础语法#xff1a;变量声明及数据类型 文章目录 【Rust】001-基础语法#xff1a;变量声明及数据类型一、概述1、学习起源2、依托课程 二、入门程序1、Hello World2、交互程序代码演示执行结果 3、继续上难度#xff1a;访问链接并打印响应依赖代码执行命令 三…【Rust】001-基础语法变量声明及数据类型 文章目录 【Rust】001-基础语法变量声明及数据类型一、概述1、学习起源2、依托课程 二、入门程序1、Hello World2、交互程序代码演示执行结果 3、继续上难度访问链接并打印响应依赖代码执行命令 三、数据类型1、标量类型整型标量类型其它 2、复合类型 四、变量声明与使用1、常量代码演示执行结果 2、变量代码演示执行结果 3、变量名复用代码演示执行结果 4、声明时指定变量类型代码演示执行结果 5、元组的使用代码演示执行结果 6、数组的使用代码演示执行结果 7、字符串代码演示执行结果 五、演示 Ownership所有权、Borrowing借用 和 Lifetime生命周期 的基本概念的示例代码演示执行结果 六、const 和 let 的区别1. 可变性Mutability2. 类型注解3. 初始化表达式4. 作用域和生命周期5. 内联 一、概述
1、学习起源
“一切能用 Rust 重写的项目都将或者正在用 Rust 重写”
2、依托课程
Rust 入门与实践https://juejin.cn/book/7269676791348854839?utm_sourcecourse_list
二、入门程序
1、Hello World
fn main() {// 打印字符串println!(Hello, world!);
}2、交互程序
代码演示
use std::io; // 使用标准库中的 io 这个模块fn main() {// 打印字符串println!(Hello, world!);// 打印字符串println!(请输入一个数字: );// 在这里我们创建了一个新的 String用来接收下面的输入let mut input String::new();io::stdin().read_line(mut input) // 读取一行.expect(Failed to read input!); // 比较粗暴的错误处理// 打印输入的原始内容println!(Your raw input is: {:?}., input);// trim 把前后的空格、换行符这些空白字符都去掉parse 将输入的字符串解析为 i64 类型如果解析失败就报错let number: i64 input.trim().parse().expect(Input is not a number!);// 打印 parse 之后的 i64 数字println!(Your input is: {}., number);
}执行结果
C:/Users/Administrator/.cargo/bin/cargo.exe run --coloralways --package hello_rust --bin hello_rustFinished dev [unoptimized debuginfo] target(s) in 0.01sRunning target\debug\hello_rust.exe
Hello, world!
请输入一个数字:
100
Your raw input is: 100\n.
Your input is: 100.进程已结束退出代码为 03、继续上难度访问链接并打印响应
依赖 Cargo.toxml [package]
name hello_rust
version 0.1.0
edition 2021[dependencies]
clap { version 4, features [derive] }
reqwest { version 0.11, features [blocking] }
代码
// 使用 use 引入一个标准库的包或者第三方的包
use std::error::Error;// clap 是一个 Rust 社区开发的命令行参数解析库
use clap::Parser;// reqwest 是一个 Rust 社区开发的 HTTP 客户端库
use reqwest::blocking::Client;
use reqwest::header::HeaderMap;// 使用 derive 宏用于自动生成 Parser 的实现
// 在高级特性章节中我们会学到宏的用法及原理
#[derive(Parser)]
#[command(
author,
version,
about Sends HTTP requests and prints detailed information
)]
struct Cli {// arg 宏用于标记命令行参数这里标记了一个必须的 URL 参数#[arg(short, long, help Target URL, required true)]url: String,
}/// Rust 程序入口
fn main() - Result(), Boxdyn Error {// 解析命令行参数let cli Cli::parse();// 发起 HTTP 请求// ? 是 Rust 中的错误传播语法糖我们会在接下来的章节中学习let response send_request(cli.url)?;// 打印 HTTP 响应的详细信息print_response_details(response)?;Ok(())
}/// 发起一个 HTTP 请求
/// 参数是目标 URL 的引用
/// 返回值是一个 Result如果请求成功返回 Response否则返回一个动态 Error
fn send_request(url: str) - Resultreqwest::blocking::Response, Boxdyn Error {// 创建一个 HTTP 客户端let client Client::builder().build()?;// 使用 GET 方法发起请求let response client.get(url).send()?;Ok(response)
}/// 打印出 HTTP 响应的详细信息
/// 参数是 Response 对象
/// 返回值是一个 Result用于错误处理
fn print_response_details(response: reqwest::blocking::Response) - Result(), Boxdyn Error {// 打印 HTTP 状态码println!(Status: {}, response.status());// 打印 HTTP 响应头println!(Headers:);print_headers(response.headers());// 读取并打印 HTTP 响应体let body response.text()?;println!(Body:\n{}, body);Ok(())
}/// 打印出 HTTP 响应头
/// 参数是 HeaderMap 的引用
fn print_headers(headers: HeaderMap) {for (key, value) in headers.iter() {// 打印每个响应头的键和值// 如果值不是 UTF-8 字符串就打印 [unprintable]println!( {}: {}, key, value.to_str().unwrap_or([unprintable]));}
}执行命令 根目录执行 cargo run -- --url https://juejin.cn/三、数据类型
1、标量类型
整型标量类型 只要记得最低从 8 开始到 128 结束当然正常情况下我们最多用到 64128 在很多平台上需要软件模拟而不是硬件支持不推荐大家用在赋值的时候除了直接十进制数字赋值外还支持以下语法大家了解一下就好不用死记硬背 其它
浮点数f32 / f64boolchar这个比较特殊Rust 中一个 char 占 4 字节存放的是一个 UTF-32而不像 C/C 那样本质上是个 u8
2、复合类型
元组 tuplelet a (1, 2); let (a, b) (1, 2)数组 array: let a [1, 2, 3]; let a [0; 5] // 这个声明中 0 是默认值5 是长度等价于 let a [0, 0, 0, 0, 0]
四、变量声明与使用
1、常量
代码演示
fn main() {// 声明常量表示年龄const AGE: u32 18;// 声明常量表示名字let name 张三;// 打印名字和年龄println!({}的年龄是{}, name, AGE);
}执行结果
张三的年龄是182、变量
代码演示
fn main() {// 声明变量表示年龄let mut age 18;// 打印变量println!(age {}, age);// 修改变量age 20;// 打印变量println!(age {}, age);
}执行结果
age 18
age 203、变量名复用
代码演示
fn main() {// 声明常量表示年龄let age 18;// 打印年龄println!(age {}, age);// 再次声明 age 变量此时不会报错let age 20;// 打印年龄println!(age {}, age);
}执行结果
age 18
age 204、声明时指定变量类型
代码演示
fn main() {// 声明常量表示年龄let age: i32 18;// 打印年龄println!(age {}, age);
}执行结果
age 18
age 205、元组的使用
代码演示
fn main() {// 声明一个包含三个元素的元组let my_tuple (1, hello, 3.14);// 使用索引访问元组中的元素println!(第一个元素是{}, my_tuple.0); // 输出 第一个元素是1println!(第二个元素是{}, my_tuple.1); // 输出 第二个元素是helloprintln!(第三个元素是{}, my_tuple.2); // 输出 第三个元素是3.14// 使用模式匹配解构元组let (x, y, z) my_tuple;println!(解构后 x 的值是{}, x); // 输出 解构后 x 的值是1println!(解构后 y 的值是{}, y); // 输出 解构后 y 的值是helloprintln!(解构后 z 的值是{}, z); // 输出 解构后 z 的值是3.14// 忽略元组中不需要的值let (a, _, _) my_tuple;println!(只需要第一个元素{}, a); // 输出 只需要第一个元素1// 嵌套元组let nested_tuple (1, (2, 3), 4);let (_, (b, c), _) nested_tuple;println!(嵌套元组中 b 的值和 c 的值分别是{} 和 {}, b, c); // 输出 嵌套元组中 b 的值和 c 的值分别是2 和 3
}执行结果
第一个元素是1
第二个元素是hello
第三个元素是3.14
解构后 x 的值是1
解构后 y 的值是hello
解构后 z 的值是3.14
只需要第一个元素1
嵌套元组中 b 的值和 c 的值分别是2 和 36、数组的使用
代码演示
fn main() {// 声明一个包含5个元素的整数数组let int_array [1, 2, 3, 4, 5];// 声明一个包含5个元素的浮点数数组同时指定类型let float_array: [f64; 5] [1.0, 2.0, 3.0, 4.0, 5.0];// 使用索引访问数组中的元素println!(整数数组的第一个元素是{}, int_array[0]); // 输出 整数数组的第一个元素是1println!(浮点数数组的第二个元素是{}, float_array[1]); // 输出 浮点数数组的第二个元素是2.0// 使用循环遍历整数数组println!(整数数组的所有元素);for num in int_array.iter() {print!({} , num); // 输出 1 2 3 4 5 }println!();// 使用循环遍历浮点数数组并获取索引println!(浮点数数组的所有元素和对应的索引);for (index, num) in float_array.iter().enumerate() {println!(索引{}, 元素{}, index, num);// 输出 索引0, 元素1.0// 输出 索引1, 元素2.0// ...}// 声明一个全部元素为0的数组let zero_array: [i32; 5] [0; 5];println!(全为0的数组{:?}, zero_array); // 输出 全为0的数组[0, 0, 0, 0, 0]
}执行结果
整数数组的第一个元素是1
浮点数数组的第二个元素是2
整数数组的所有元素
1 2 3 4 5
浮点数数组的所有元素和对应的索引
索引0, 元素1
索引1, 元素2
索引2, 元素3
索引3, 元素4
索引4, 元素5
全为0的数组[0, 0, 0, 0, 0]7、字符串
代码演示
fn main() {// 使用字符串字面量声明一个不可变字符串let hello_str Hello, world!;println!(不可变字符串字面量{}, hello_str); // 输出 不可变字符串字面量Hello, world!// 使用 String::from 创建一个可变字符串let mut hello_string String::from(Hello);println!(可变字符串{}, hello_string); // 输出 可变字符串Hello// 在可变字符串后追加字符串hello_string.push_str(, world!);println!(追加后的可变字符串{}, hello_string); // 输出 追加后的可变字符串Hello, world!// 字符串拼接let concat_str [hello_str, , hello_string].concat();println!(拼接后的字符串{}, concat_str); // 输出 拼接后的字符串Hello, world! Hello, world!// 使用索引获取字符串中的字符注意这种方式不推荐因为会导致错误或崩溃// let first_char hello_str[0]; // 这样是错误的// Rust 的字符串是 UTF-8 编码的直接索引可能会导致字符被截断。// 使用 chars 方法遍历字符串中的字符println!(使用 chars 方法遍历字符串);for ch in hello_str.chars() {print!({} , ch); // 输出 H e l l o , w o r l d ! }println!();// 使用 bytes 方法遍历字符串中的字节println!(使用 bytes 方法遍历字符串字节);for byte in hello_str.bytes() {print!({} , byte); // 输出对应的 ASCII 或 UTF-8 编码的字节值}println!();// 获取字符串长度println!(字符串 {} 的长度是{}, hello_str, hello_str.len()); // 输出 字符串 Hello, world! 的长度是13
}执行结果
不可变字符串字面量Hello, world!
可变字符串Hello
追加后的可变字符串Hello, world!
拼接后的字符串Hello, world! Hello, world!
使用 chars 方法遍历字符串
H e l l o , w o r l d !
使用 bytes 方法遍历字符串字节
72 101 108 108 111 44 32 119 111 114 108 100 33
字符串 Hello, world! 的长度是13五、演示 Ownership所有权、Borrowing借用 和 Lifetime生命周期 的基本概念的示例
代码演示
// 定义一个函数演示所有权的转移
fn takes_ownership(some_string: String) {println!(函数内部{}, some_string);
} // 这里 some_string 离开作用域所有权也随之释放// 定义一个函数演示借用不可变
fn borrows_immutable(s: String) {println!(函数内部不可变借用{}, s);
}// 定义一个函数演示借用可变
fn borrows_mutable(s: mut String) {s.push_str(, world!); // 修改字符串println!(函数内部可变借用{}, s);
}// 定义一个函数演示生命周期
// 注a 是生命周期标注表明 x 和 y 的生命周期相同并且与返回值的生命周期也相同
fn longesta(x: a str, y: a str) - a str {if x.len() y.len() {x} else {y}
}fn main() {// 所有权Ownershiplet s1 String::from(hello); // s1 获取了字符串 hello 的所有权takes_ownership(s1); // 所有权转移到函数 takes_ownership// println!(main 函数{}, s1); // 错误因为 s1 的所有权已经被转移// 借用Borrowinglet s2 String::from(hello); // s2 获取了字符串 hello 的所有权borrows_immutable(s2); // 不可变借用所有权仍在 s2println!(main 函数不可变借用后{}, s2);let mut s3 String::from(hello); // s3 获取了字符串 hello 的所有权并且是可变的borrows_mutable(mut s3); // 可变借用所有权仍在 s3但内容已经被修改println!(main 函数可变借用后{}, s3);// 生命周期Lifetimelet str1 Rust;let str2 Programming;let result longest(str1, str2);println!(更长的字符串是{}, result); // 输出 更长的字符串是Programming
}执行结果
函数内部hello
函数内部不可变借用hello
main 函数不可变借用后hello
函数内部可变借用hello, world!
main 函数可变借用后hello, world!
更长的字符串是Programming六、const 和 let 的区别
1. 可变性Mutability let: 默认情况下使用 let 声明的变量是不可变的但您可以使用 mut 关键字来使其可变。 let x 5; // 不可变
let mut y 6; // 可变const: 使用 const 声明的常量始终是不可变的并且不能使用 mut。 const X: i32 5; // 始终不可变2. 类型注解 let: 可以选择是否添加类型注解。 let x 5; // 类型推断为 i32
let y: i64 6; // 显示类型注解const: 必须添加类型注解。 const X: i32 5; // 必须提供类型3. 初始化表达式 let: 可以使用任何类型的表达式进行初始化。 let x 5 5; // 算术表达式const: 只能使用常量表达式进行初始化。 const X: i32 5 5; // 常量表达式但不能是函数调用、运行时计算等4. 作用域和生命周期
let: 局部变量作用范围仅限于声明它的代码块。const: 可以在模块级别使用生命周期可跨越整个程序。
5. 内联
const: 在编译时常量的值会被直接内联到使用它的表达式中。let: 取决于编译器优化。
总体来说const 主要用于那些在编译时就能确定并且永远不会改变的值而 let 则用于运行时可能会改变的值。希望这能帮助您更好地理解这两者之间的区别
