【Rust】001-基础语法:变量声明及数据类型

【Rust】001-基础语法:变量声明及数据类型

文章目录

  • 【Rust】001-基础语法:变量声明及数据类型
  • 一、概述
    • 1、学习起源
    • 2、依托课程
  • 二、入门程序
    • 1、Hello World
    • 2、交互程序
      • 代码演示
      • 执行结果
    • 3、继续上难度:访问链接并打印响应
      • 依赖
      • 代码
      • 执行命令
  • 三、数据类型
    • 1、标量类型
      • 整型标量类型
      • 其它
    • 2、复合类型
  • 四、变量声明与使用
    • 1、常量
      • 代码演示
      • 执行结果
    • 2、变量
      • 代码演示
      • 执行结果
    • 3、变量名复用
      • 代码演示
      • 执行结果
    • 4、声明时指定变量类型
      • 代码演示
      • 执行结果
    • 5、元组的使用
      • 代码演示
      • 执行结果
    • 6、数组的使用
      • 代码演示
      • 执行结果
    • 7、字符串
      • 代码演示
      • 执行结果
  • 五、演示 `Ownership(所有权)`、`Borrowing(借用)` 和 `Lifetime(生命周期)` 的基本概念的示例
      • 代码演示
      • 执行结果
  • 六、const 和 let 的区别
      • 1. 可变性(Mutability)
      • 2. 类型注解
      • 3. 初始化表达式
      • 4. 作用域和生命周期
      • 5. 内联

一、概述

1、学习起源

“一切能用 Rust 重写的项目都将或者正在用 Rust 重写”

2、依托课程

Rust 入门与实践:https://juejin.cn/book/7269676791348854839?utm_source=course_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 --color=always --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.进程已结束,退出代码为 0

3、继续上难度:访问链接并打印响应

依赖

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<(), Box<dyn 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) -> Result<reqwest::blocking::Response, Box<dyn 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<(), Box<dyn 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、标量类型

整型标量类型

image-20230902162358238

只要记得最低从 8 开始,到 128 结束(当然,正常情况下我们最多用到 64,128 在很多平台上需要软件模拟而不是硬件支持,不推荐大家用);在赋值的时候除了直接十进制数字赋值外,还支持以下语法(大家了解一下就好,不用死记硬背):

image-20230902162458543

其它

  • 浮点数:f32 / f64
  • bool
  • char:这个比较特殊,Rust 中一个 char 占 4 字节,存放的是一个 UTF-32,而不像 C/C++ 那样本质上是个 u8

2、复合类型

  • 元组 tuple:let 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);
}

执行结果

张三的年龄是18

2、变量

代码演示

fn main() {// 声明变量,表示年龄let mut age = 18;// 打印变量println!("age = {}", age);// 修改变量age = 20;// 打印变量println!("age = {}", age);
}

执行结果

age = 18
age = 20

3、变量名复用

代码演示

fn main() {// 声明常量,表示年龄let age = 18;// 打印年龄println!("age = {}", age);// 再次声明 age 变量,此时不会报错let age = 20;// 打印年龄println!("age = {}", age);
}

执行结果

age = 18
age = 20

4、声明时指定变量类型

代码演示

fn main() {// 声明常量,表示年龄let age: i32 = 18;// 打印年龄println!("age = {}", age);
}

执行结果

age = 18
age = 20

5、元组的使用

代码演示

fn main() {// 声明一个包含三个元素的元组let my_tuple = (1, "hello", 3.14);// 使用索引访问元组中的元素println!("第一个元素是:{}", my_tuple.0); // 输出 "第一个元素是:1"println!("第二个元素是:{}", my_tuple.1); // 输出 "第二个元素是:hello"println!("第三个元素是:{}", my_tuple.2); // 输出 "第三个元素是:3.14"// 使用模式匹配解构元组let (x, y, z) = my_tuple;println!("解构后 x 的值是:{}", x); // 输出 "解构后 x 的值是:1"println!("解构后 y 的值是:{}", y); // 输出 "解构后 y 的值是:hello"println!("解构后 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 和 3

6、数组的使用

代码演示

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]);  // 输出 "整数数组的第一个元素是:1"println!("浮点数数组的第二个元素是:{}", 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 longest<'a>(x: &'a str, y: &'a str) -> &'a str {if x.len() > y.len() {x} else {y}
}fn main() {// 所有权(Ownership)let s1 = String::from("hello");  // s1 获取了字符串 "hello" 的所有权takes_ownership(s1);  // 所有权转移到函数 takes_ownership// println!("main 函数:{}", s1);  // 错误!因为 s1 的所有权已经被转移// 借用(Borrowing)let 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);// 生命周期(Lifetime)let 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 则用于运行时可能会改变的值。希望这能帮助您更好地理解这两者之间的区别!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/119301.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Collections和CollectionUtils集合操作

0.引入依赖 <dependency><groupId>org.apache.commons</groupId><artifactId>commons-collections4</artifactId><version>4.4</version> </dependency> 一.Collections用法&#xff1a; 01、排序操作 reverse(List list)…

【摆烂之小左】Maven配置IDEA教程

Maven是什么 Maven项目对象模型(POM)&#xff0c;可以通过一小段描述信息来管理项目的构建&#xff0c;报告和文档的项目管理工具软件。 Maven 除了以程序构建能力为特色之外&#xff0c;还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性&#xff0c;所以常…

数学建模:模糊综合评价分析

&#x1f506; 文章首发于我的个人博客&#xff1a;欢迎大佬们来逛逛 数学建模&#xff1a;模糊综合评价分析 文章目录 数学建模&#xff1a;模糊综合评价分析综合评价分析常用评价方法一级模糊综合评价综合代码 多级模糊综合评价总结 综合评价分析 构成综合评价类问题的五个…

go语言基础操作--二

a : 10str : "mike"//匿名函数&#xff0c;没有函数名字 形成一个闭包,函数定义&#xff0c;还没有调用f1 : func() { //:自动推到类型fmt.Println("a ", a)fmt.Println("str ", str)}f1()//给一个函数类型起别名 这个写法不推荐type FuncType …

Flutter状态管理 — 探索Flutter中的状态

前言 随着响应式编程的理念&Flutter被大众所了解以来&#xff0c;状态管理一直是一个引人深思的话题。如果想要学习好Flutter这样的响应式的编程框架就一定是离不开状态管理的。我遇到过很多没有了解过响应式编程框架的&#xff0c;或者从事后端开发&#xff0c;自己想用F…

docker笔记4:高级复杂安装-mysql主从复制

1.主从搭建步骤 1.1新建主服务器容器实例3307 docker run -p 3307:3306 --name mysql-master \ -v /mydata/mysql-master/log:/var/log/mysql \ -v /mydata/mysql-master/data:/var/lib/mysql \ -v /mydata/mysql-master/conf:/etc/mysql \ -e MYSQL_ROOT_PASSWORDroot \ -d…

Linux的目录结构特点

Linux的目录结构特点 1、使用树形目录结构来组织和管理文件。 2、整个系统只有一个根目录&#xff08;树根&#xff09;&#xff0c;Linux的根目录用“/”表示。 3、其他所有分区以及外部设备&#xff08;如硬盘&#xff0c;光驱等&#xff09;都是以根目录为起点&#xff0…

【已解决】激活虚拟环境报错:此时不应有Anaconda3\envs\[envs]\Library\ssl\cacert.pem。

新建虚拟环境后&#xff0c;进入虚拟环境的时候出现这样的报错&#xff1a; 此时不应有Anaconda3 envs yolov5 Library ssl cacert.pem。 但是之前装的虚拟环境也还能再次激活&#xff0c;base环境也无任何问题&#xff0c;仅新装的虚拟环境无法激活。 查遍了百度谷歌&#xff…

ThreadLocal源码剖析(简单理解)

Thread部分源码 public class Thread implements Runnable {ThreadLocal.ThreadLocalMap threadLocals null; }ThreadLocal源码,其中ThreadLocal有一个静态内部类ThreadLocalMap,这个Map不是类似二叉树类型的,只是一个普通数组,其中具体使用什么算法其实我也不太理解. 然后对…

通过ref 操作dom , 点击按钮后跳转到页面指定图片位置

滚动图片到视图 定义了一个名为 scrollToIndex 的函数&#xff0c;它接受一个参数 index。当按钮被点击时&#xff0c;这个函数会被调用&#xff0c;并根据传入的 index 值来滚动到对应的图片。 以 alt 来标记图片位置 alt“Tom” import { useRef } from "react";c…

1.(python数模)单函数读取常用文件

Python单函数读取常用文件 代码如下&#xff1a; import pandas as pd# 读取数据文件 def readDataFile(readPath): # readPath: 数据文件的地址和文件名try:if (readPath[-4:] ".csv"):dfFile pd.read_csv(readPath, header0, sep",") # 间隔符为逗…

I2C与I3C的对比

I2C与I3C的对比 电气特性 I2C 1.半双工 2.串行数据线(SDA)和串行时钟线(SCL) 3.数据线漏极开路&#xff0c;即I2C接口接上拉电阻 4.I2C总线运行速度&#xff1a;**标准模式100kbit/s&#xff0c;快速模式400kbit/s&#xff0c;快速模式plus 1Mbit/s&#xff0c;**高速模式…

机器学习:可解释学习

文章目录 可解释学习为什么需要可解释机器学习可解释还是强模型可解释学习的目标可解释机器学习Local ExplanationGlobal Explanation 可解释学习 神马汉斯&#xff0c;只有在有人看的时候能够答对。 为什么需要可解释机器学习 贷款&#xff0c;医疗需要给出理由&#xff0c;让…

无涯教程-JavaScript - WEIBULL函数

WEIBULL函数取代了Excel 2010中的WEIBULL.DIST函数。 描述 该函数返回威布尔分布。在可靠性分析中使用此分布,如计算设备的平均故障时间。 语法 WEIBULL(x,alpha,beta,cumulative)争论 Argument描述Required/OptionalXThe value at which to evaluate the function.Requir…

深入探讨Java虚拟机(JVM):执行流程、内存管理和垃圾回收机制

目录 什么是JVM&#xff1f; JVM 执行流程 JVM 运行时数据区 堆&#xff08;线程共享&#xff09; Java虚拟机栈&#xff08;线程私有&#xff09; 什么是线程私有? 程序计数器&#xff08;线程私有&#xff09; 方法区&#xff08;线程共享&#xff09; JDK 1.8 元空…

网络编程 day 5

1、根据select TCP服务器流程图编写服务器 #include <myhead.h>#define ERR_MSG(msg) do{\fprintf(stderr, "__%d__:", __LINE__); \perror(msg);\ }while(0)#define PORT 8888 //端口号&#xff0c;范围1024~49151 #define IP "192.168.…

设计模式-原型模式详解

文章目录 前言理论基础1. 原型模式定义2. 原型模式角色3. 原型模式工作过程4. 原型模式的优缺点 实战应用1. 原型模式适用场景2. 原型模式实现步骤3. 原型模式与单例模式的区别 原型模式的变体1. 带有原型管理器的原型模式2. 懒汉式单例模式的原型模式实现3. 细粒度原型模式 总…

无涯教程-JavaScript - RANK函数

RANK函数取代了Excel 2010中的RANK.EQ函数。 描述 该函数返回数字列表中数字的等级。数字的等级是其相对于列表中其他值的大小。 如果对列表进行排序,则数字的排名将是其位置。 语法 RANK (number,ref,[order])争论 Argument描述Required/OptionalNumberThe number whose…

Elasticsearch 对比传统数据库:深入挖掘 Elasticsearch 的优势

当你为项目选择数据库或搜索引擎时&#xff0c;了解每个选项的细微差别至关重要。 今天&#xff0c;我们将深入探讨 Elasticsearch 的优势&#xff0c;并探讨它与传统 SQL 和 NoSQL 数据库的比较。 1. Elasticsearch简介 Elasticsearch 以强大的 Apache Lucene 库为基础&#…

山西电力市场日前价格预测【2023-09-04】

日前价格预测 预测明日&#xff08;2023-09-04&#xff09;山西电力市场全天平均日前电价为305.57元/MWh。其中&#xff0c;最高日前电价为349.83元/MWh&#xff0c;预计出现在19: 15。最低日前电价为226.28元/MWh&#xff0c;预计出现在13: 30。 价差方向预测 1&#xff1a; 实…