Rust 初体验1
Rust 初体验
安装
打开官网,下载 rustup-init.exe, 选择缺省模式(1)安装。
国内源设置
在 .Cargo
目录下新建 config 文件,添加如下内容:
[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"
# 指定镜像
replace-with = 'tuna' # 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"[net]
git-fetch-with-cli = true
第一个程序
使用任意代码编辑器,编写如下代码,保存为后缀是.rs的源文件,如 hello.rs。
fn main()
{println!("Hello World!");
}
了解C语言的同学,会发现这个程序和C语言的hello.c非常相似。不同之处在于,fn
表示函数,main
表示程序的入口,println!
表示输出。!
表示宏,即 println
是个宏,而不是函数。
在源文件文件夹里,运行 rustc hello.rs
进行编译,生成 hello.exe。
运行 hello.exe,输出:
Hello World!
使用 Cargo 管理
cargo new project_name
创建一个新项目
cd project_name
进入项目
cargo build
编译生成Debug版本
cargo build --release
编译并生成可执行文件
cargo run
运行
cargo check
检查错误(不编译)
cargo 常用命令
build, b Compile the current package
check, c Analyze the current package and report errors, but don't build object files
clean Remove the target directory
doc, d Build this package's and its dependencies' documentation
new Create a new cargo package
init Create a new cargo package in an existing directory
add Add dependencies to a manifest file
remove Remove dependencies from a manifest file
run, r Run a binary or example of the local package
test, t Run the tests
bench Run the benchmarks
update Update dependencies listed in Cargo.lock
search Search registry for crates
publish Package and upload this package to the registry
install Install a Rust binary. Default location is $HOME/.cargo/bin
uninstall Uninstall a Rust binary
变量
Rust 是强类型语言,使用关键字 let 声明变量后,具有自动判断变量类型的能力,如:
let a = 123;
则默认 a 为整型数字,且精度不允许变化,即 a 的值不可改变,可以理解为“只读”。
这与 C 语言中的 const 修饰符起到的效果一样。在 C 语言中 int const a = 10;
a 的值也不允许改变。
Rust 中如果要让变量可变,需要用 mut 关键词:
let mut a = 123;
a = 456;
指定数据类型
let a: u64 = 123; // 后面跟数据类型u64,表示无符号64位整型变量。
let y: f32 = 3.0; // 后面跟数据类型f32,表示32位浮点型变量。
Shadowing(影射)
变量名可以被重新使用,如:
let x = 5;
let x = x + 1;
let x = x * 2;
最终 x 的值为12。从语法上说, 变量 x 可以作为右值。
注释
可以使用 C/C++, Java 注释。
另外,可用 ///
表示文档开头注释
函数
定义函数,如需要参数,必须声明参数名称、类型。
fn another_function(x: i32, y: i32) { }
可在{}
包括的块里,编写较为复杂的表达式,即所谓的函数体表达式。注:函数体表达式,并不能等同于函数体,不能使用 return 关键字。
let y = {let x = 3;x + 1
};
返回值类型声明
在参数声明之后用->
来声明函数返回值的类型。 注:Rust 不支持自动返回值类型判断。
fn add(a: i32, b: i32) -> i32 {return a + b;
}
条件语句
if a > 0 {b = 1;
}
else if a < 0 {b = -1;
}
else {b = 0;
}
println!("b is {}", b);
if 后面不需要小括号,{}
必用。右括号 }
后不加 ;
。
条件表达式必须是 bool
类型,不同于 C/C++ 的非 0 即真。
可以使用 if-else 结构实现类似于三元条件运算表达式 (A ? B : C)
。如:
let number = if a > 0 { 1 } else { -1 };
注:此处编译报错,检测出来其中 0 为 i32,代码未指定数据类型。故将0
改为&0
:
let number = if a > &0 { 1 } else { -1 };
for 循环
最常用的循环结构。
let a = [10, 20, 30, 40, 50];
for i in a.iter() {println!("值为 : {}", i);
}
a.iter() 代表 a 的迭代器(iterator)
也可以通过下标来访问数组。如:
let a = [10, 20, 30, 40, 50];
for i in 0..5 {println!("a[{}] = {}", i, a[i]);
}
以上代码会报错。正确写法是:
const a: [i32; 5] = [10, 20, 30, 40, 50];
for i in 0..5 {println!("a[{}] = {}", i, a[i]);
}
可见,代码检查更严格。
while 循环
let mut number = 1; // mut 表示number 在循环体内可以改变。
while number != 4 {println!("{}", number);number += 1;
}
无限循环结构 loop
可以通过 break 关键字,起到类似 return 一样的作用,使整个循环退出并给予外部一个返回值。
let mut i = 0;
let location = loop {let ch = s[i];if ch == '*' {break i;}i += 1;
};
以上代码会报错,可以改为:
fn main() {let s = "hello world";let mut i = 0;let location = loop {let ch = s.chars().nth(i).unwrap();if ch == ' ' {break i;}i += 1;};println!("{}", location);
}
变量与数据交互
方式有移动(Move)和克隆(Clone)两种,前者不保存移动前的变量,后者继续保留移动前的变量。
let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1); // 错误!s1 已经失效let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2); //ok
引用(Reference)
& 运算符可以取变量的"引用"。当一个变量的值被引用时,变量本身不会被认定无效。注:C++中的概念。
引用不会获得值的所有权。引用只能租借(Borrow)值的所有权。
引用本身也是一个类型并具有一个值,这个值记录的是别的值所在的位置,但引用不具有所指值的所有权。
&mut 修饰可变的引用类型。
可变引用不允许多重引用,但不可变引用可以。
以上机制设计,主要出于对并发状态下发生数据访问碰撞的考虑,使得编译阶段就避免发生。
垂悬引用(Dangling References)
Rust 语言里不允许出现,如果有,编译器会发现它。
更多内容参看: https://www.runoob.com/rust/rust-ownership.html
字符串切片(String Slice)
let s = String::from("broadcast");
let part1 = &s[0..5];
let part2 = &s[5..9];
println!("{}={}+{}", s, part1, part2);
在 Rust 中有两种常用的字符串类型:str 和 String。
str 是 Rust 核心语言类型,凡用双引号包括的字符串常量整体的类型性质都是 &str。
String 类型是 Rust 标准公共库提供的一种数据类型,其功能更完善。String 和 str 都支持切片,切片的结果是 &str 类型的数据。
注:切片结果必须是引用类型,但开发者必须明示:
let slice = &s[0..3];
除了字符串,其他一些线性数据结构也支持切片操作,如:
let arr = [1, 3, 5, 7, 9];
let part = &arr[0..3];
for i in part.iter() {println!("{}", i);
}
结构体
定义结构体:
struct Site {domain: String,name: String,nation: String,found: u32
}
注:Rust 里 struct 语句仅用来定义,不能声明实例,结尾不需要;
符号,且每个字段定义之后用 ,
分隔。
Rust 很多地方受 JavaScript 影响,在实例化结构体的时候用 JSON 对象的 key: value 语法来实现定义:
let runoob = Site {domain: String::from("www.runoob.com"),name: String::from("RUNOOB"),nation: String::from("China"),found: 2013
};
如果正在实例化的结构体,有字段名称与现存变量名称一样,可以简化书写。
let domain = String::from("www.runoob.com");
let name = String::from("RUNOOB");
let runoob = Site {domain, // 等同于 domain : domain,name, // 等同于 name : name,nation: String::from("China"),traffic: 2013
};
新建一个结构体实例,如果其中大部分属性需要被设置成与现存的一个结构体属性一样,仅需更改其中一两个字段的值,可以使用结构体更新语法:
let site = Site {domain: String::from("www.runoob.com"),name: String::from("RUNOOB"),..runoob
};
注:…runoob 后面不可以有逗号。这种语法不允许一成不变的复制另一个结构体实例,至少重新设定一个字段的值才能引用其他实例的值。
元组结构体
struct Color(u8, u8, u8);
struct Point(f64, f64);let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);
元组结构体对象的使用方式和元组一样,通过 .
和下标来进行访问:
struct Color(u8, u8, u8);
struct Point(f64, f64);
let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);
println!("black = ({}, {}, {})", black.0, black.1, lack.2);
println!("origin = ({}, {})", origin.0, origin.1);
结构体必须掌握字段值所有权,因为结构体失效的时候会释放所有字段。
结构体输出
导入调试库 #[derive(Debug)]
在 println 和 print 宏中可以用 {:?}
占位符输出一整个结构体;结构体如果属性较多,可使用另一个占位符 {:#?}
。
结构体方法
结构体方法的第一个参数必须是 &self
,不需声明类型。
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's area is {}", rect1.area());
}
这里与Python中的Class方法有神似。
结构体关联函数
不依赖实例,使用时需要声明是在哪个 impl 块中的。String::from
函数就是一个"关联函数"。
# [derive(Debug)]struct Rectangle {width: u32,height: u32,
}impl Rectangle {fn create(width: u32, height: u32) -> Rectangle {Rectangle { width, height }}
}fn main() {let rect = Rectangle::create(30, 50);println!("{:?}", rect);
}
这里的Rectangle中的create函数,即是结构体关联函数。这个概念与 C++语言里面的类成员函数有些相似。不同之处在于, C++ 类成员函数是在类的内部定义,并且使用 this 指针来访问类的实例。
单元结构体
结构体可以只作为一种象征而无需任何成员:
struct UnitStruct;
枚举类
# [derive(Debug)]enum Book {Papery, Electronic
}fn main() {let book = Book::Papery;println!("{:?}", book);
}
为枚举类成员添加元组属性描述
enum Book {Papery(u32),Electronic(String),
}let book = Book::Papery(1001);
let ebook = Book::Electronic(String::from("url://..."));
为属性命名,可以用结构体语法:
enum Book {Papery { index: u32 },Electronic { url: String },
}
let book = Book::Papery{index: 1001};
match 语法
枚举的目的是对某一类事物的分类,分类的目的是为了对不同的情况进行描述。Rust 通过 match 语句来实现分支结构。
fn main() {enum Book {Papery {index: u32},Electronic {url: String},}let book = Book::Papery{index: 1001};let ebook = Book::Electronic{url: String::from("url...")};match book {Book::Papery { index } => {println!("Papery book {}", index);},Book::Electronic { url } => {println!("E-book {}", url);}}
}
注意其中的,号与;
号。
match 枚举类实例 {分类1 => 返回值表达式,分类2 => 返回值表达式,...
}
对非枚举类进行分支选择时必须注意处理例外情况,即使在例外情况下没有任何要做的事 . 例外情况用下划线 _ 表示:
fn main() {let t = "abc";match t {"abc" => println!("Yes"),_ => {},}
}
Option 枚举类
Rust 标准库中的枚举类,用于填补 Rust 不支持 null 引用的空白。Rust 在语言层面彻底不允许空值 null 的存在,但null 可以高效地解决少量的问题,所以 Rust 引入了 Option 枚举类:
enum Option<T> {Some(T),None,
}
如果想定义一个可以为空值的类,可以这样:
let opt = Option::Some("Hello");
如果想针对 opt 执行某些操作,必须先判断它是否是 Option::None:
fn main() {let opt = Option::Some("Hello");match opt {Option::Some(something) => {println!("{}", something);},Option::None => {println!("opt is nothing");}}
}
初始值为空的 Option 必须明确类型:
fn main() {let opt: Option<&str> = Option::None;match opt {Option::Some(something) => {println!("{}", something);},Option::None => {println!("opt is nothing");}}
}
这种设计会让空值编程变得不容易,但这正是构建一个稳定高效的系统所需要的。由于 Option 是 Rust 编译器默认引入的,在使用时可以省略 Option:: 直接写 None 或者 Some()。
fn main() {let t = Some(64);match t {Some(64) => println!("Yes"),_ => println!("No"),}
}
又:
let i = 0;
match i {0 => println!("zero"),_ => {},
}
用 if let 语法缩短这段代码:
let i = 0;
if let 0 = i {println!("zero");
}
如:
fn main() {enum Book {Papery(u32),Electronic(String)}let book = Book::Electronic(String::from("url"));if let Book::Papery(index) = book {println!("Papery {}", index);} else {println!("Not papery book");}
}
注意其中 if 语句后的 = 号。
组织管理
Rust 中有三个重要的组织概念:箱、包、模块。
箱(Crate)
"箱"是二进制程序文件或者库文件,存在于"包"中。树状结构,树根是编译器开始运行时编译的源文件所编译的程序。
注意:“二进制程序文件"不一定是"二进制可执行文件”,只能确定是是包含目标机器语言的文件,文件格式随编译环境的不同而不同。
包(Package)
当使用 Cargo 执行 new 命令创建 Rust 工程时,工程目录下会建立一个 Cargo.toml 文件。工程的实质就是一个包,包必须由一个 Cargo.toml 文件来管理,该文件描述了包的基本信息以及依赖项。
一个包最多包含一个库"箱",可以包含任意数量的二进制"箱",但是至少包含一个"箱"(不管是库还是二进制"箱")。
当使用 cargo new 命令创建完包之后,src 目录下会生成一个 main.rs 源文件,Cargo 默认这个文件为二进制箱的根,编译之后的二进制箱将与包名相同。
模块(Module)
对于一个软件工程来说,往往按照所使用的编程语言的组织规范来进行组织,组织模块的主要结构往往是树。Java 组织功能模块的主要单位是类,而 JavaScript 组织模块的主要方式是 function。Rust 中的组织单位是模块(Module)。
这些先进的语言的组织单位可以层层包含,就像文件系统的目录结构一样。Rust 中的组织单位是模块(Module)。
路径分为绝对路径和相对路径。绝对路径从 crate 关键字开始描述。相对路径从 self 或 super 关键字或一个标识符开始描述。Rust 中的路径分隔符是 ::
。如:
crate::nation::government::govern();
是描述 govern 函数的绝对路径,相对路径可以表示为:
nation::government::govern();
访问权限
Rust 中有两种简单的访问权:公共(public)和私有(private)。
默认情况下,如果不加修饰符,模块中的成员访问权将是私有的。
如果想使用公共权限,需要使用 pub
关键字。
对于私有的模块,只有在与其平级的位置或下级的位置才能访问,不能从其外部访问。
mod nation {pub mod government {pub fn govern() {}}mod congress {pub fn legislate() {}}mod court {fn judicial() {super::congress::legislate();}}
}fn main() {nation::government::govern();
}
这段程序是能通过编译的。请注意观察 court 模块中 super 的访问方法。更多的信息请参考:
https://www.runoob.com/rust/rust-project-management.html
use 关键字能够将模块标识符引入当前作用域
mod nation {pub mod government {pub fn govern() {}}
}use crate::nation::government::govern; // 解决局部模块路径过长的问题。fn main() {govern();
}
重命名
mod nation {pub mod government {pub fn govern() {}}pub fn govern() {}
}use crate::nation::government::govern;
use crate::nation::govern as nation_govern; // 解决重名问题fn main() {nation_govern();govern();
}
还可以与 pub
关键字配合使用:
mod nation {pub mod government {pub fn govern() {}}pub use government::govern;
}fn main() {nation::govern();
}
Rust 官方标准库字典
所有系统库模块都是被默认导入的,所以在使用的时候只需要使用 use 关键字简化路径即可使用。
在 Rust 中没有 Exception。对可恢复错误用 Result<T, E>
类来处理,对不可恢复错误使用 panic!
宏来处理。
不可恢复错误
fn main() {panic!("error occured"); // 程序将在此处中断,不执行后续语句println!("Hello, Rust");
}
回溯是不可恢复错误的另一种处理方式,它会展开运行的栈并输出所有的信息,然后程序依然会退出。上面的省略号省略了大量的输出信息,我们可以找到我们编写的 panic! 宏触发的错误。
可恢复的错误
Rust 通过 Result<T, E>
枚举类作返回值来进行异常表达。
use std::fs::File;fn main() {let f = File::open("hello.txt");match f {Ok(file) => {println!("File opened successfully.");},Err(err) => {println!("Failed to open the file.");}}
}
可用 if let 语法对简化 match 语法块:
use std::fs::File;fn main() {let f = File::open("hello.txt");if let Ok(file) = f {println!("File opened successfully.");} else {println!("Failed to open the file.");}
}
Rust 中可以在 Result 对象后添加 ?
操作符将同类的 Err 直接传递出去.
fn f(i: i32) -> Result<i32, bool> {if i >= 0 { Ok(i) }else { Err(false) }
}fn g(i: i32) -> Result<i32, bool> {let t = f(i)?;Ok(t) // 因为确定 t 不是 Err, t 在这里已经是 i32 类型
}fn main() {let r = g(10000);if let Ok(v) = r {println!("Ok: g(10000) = {}", v);} else {println!("Err");}
}
?
符的实际作用是将 Result 类非异常的值直接取出,如果有异常就将异常 Result 返回出去。所以,?
符仅用于返回值类型为 Result<T, E>
的函数,其中 E 类型必须和 ?
所处理的 Result 的 E 类型一致。
判断 Result 的 Err 类型,用函数 kind()。
use std::io;
use std::io::Read;
use std::fs::File;fn read_text_from_file(path: &str) -> Result<String, io::Error> {let mut f = File::open(path)?;let mut s = String::new();f.read_to_string(&mut s)?;Ok(s)
}fn main() {let str_file = read_text_from_file("hello.txt");match str_file {Ok(s) => println!("{}", s),Err(e) => {match e.kind() {io::ErrorKind::NotFound => {println!("No such file");},_ => {println!("Cannot read the file");}}}}
}
相关文章:
Rust 初体验1
Rust 初体验 安装 打开官网,下载 rustup-init.exe, 选择缺省模式(1)安装。 国内源设置 在 .Cargo 目录下新建 config 文件,添加如下内容: [source.crates-io] registry "https://github.com/rus…...

【深度学习】实验7布置,图像超分辨
清华大学驭风计划 因为篇幅原因实验答案分开上传, 实验答案链接http://t.csdnimg.cn/P1yJF 如果需要更详细的实验报告或者代码可以私聊博主 有任何疑问或者问题,也欢迎私信博主,大家可以相互讨论交流哟~~ 深度学习训练营 案例 7 ࿱…...

【八大排序】归并排序 | 计数排序 + 图文详解!!
📷 江池俊: 个人主页 🔥个人专栏: ✅数据结构冒险记 ✅C语言进阶之路 🌅 有航道的人,再渺小也不会迷途。 文章目录 一、归并排序1.1 基本思想 动图演示2.2 递归版本代码实现 算法步骤2.3 非递归版本代…...

Netty应用(三) 之 NIO开发使用 网络编程 多路复用
目录 重要:logback日志的引入以及整合步骤 5.NIO的开发使用 5.1 文件操作 5.1.1 读取文件内容 5.1.2 写入文件内容 5.1.3 文件的复制 5.2 网络编程 5.2.1 accept,read阻塞的NIO编程 5.2.2 把accept,read设置成非阻塞的NIO编程 5.2.3…...
融资项目——配置redis
一、 在maven中导入相关依赖。在springboot框架中,我们使用spring data redis <!-- spring boot redis缓存引入 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifa…...

npm修改镜像源
背景:切换npm镜像源是经常遇到的事,下面记录下具体操作命令 1. 打开终端运行"npm config get registry"命令来查看当前配置的镜像源 npm config get registry2. 修改成淘宝镜像源"https://registry.npmjs.org/" npm config set re…...
K8S系列文章之 [基于 Alpine 使用 kubeadm 搭建 k8s]
先部署基础环境,然后根据官方文档 K8s - Alpine Linux,进行操作。 将官方文档整理为脚本 整理脚本时,有部分调整 #!/bin/shset -x # 添加源,安装时已经配置 #cat >> /etc/apk/repositories <<"EOF" #htt…...

JVM相关-JVM模型、垃圾回收、JVM调优
一、JVM模型 JVM内部体型划分 JVM的内部体系结构分为三部分,分别是:类加载器(ClassLoader)子系统、运行时数据区(内存)和执行引擎 1、类加载器 概念 每个JVM都有一个类加载器子系统(class l…...

提升图像分割精度:学习UNet++算法
文章目录 一、UNet 算法简介1.1 什么是 UNet 算法1.2 UNet 的优缺点1.3 UNet 在图像分割领域的应用 二、准备工作2.1 Python 环境配置2.2 相关库的安装 三、数据处理3.1 数据的获取与预处理3.2 数据的可视化与分析 四、网络结构4.1 UNet 的网络结构4.2 UNet 各层的作用 五、训练…...

排序算法---冒泡排序
原创不易,转载请注明出处。欢迎点赞收藏~ 冒泡排序是一种简单的排序算法,其原理是重复地比较相邻的两个元素,并将顺序不正确的元素进行交换,使得每次遍历都能将一个最大(或最小)的元素放到末尾。通过多次遍…...

基于数据挖掘的微博事件分析与可视化大屏分析系统
设计原理,是指一个系统的设计由来,其将需求合理拆解成功能,抽象的描述系统的模块,以模块下的功能。功能模块化后,变成可组合、可拆解的单元,在设计时,会将所有信息分解存储在各个表中࿰…...

数学建模-灰色预测最强讲义 GM(1,1)原理及Python实现
目录 一、GM(1,1)模型预测原理 二、GM(1,1)模型预测步骤 2.1 数据的检验与处理 2.2 建立模型 2.3 检验预测值 三、案例 灰色预测应用场景:时间序列预测 灰色预测的主要特点是模型使用的…...

智慧自助餐饮系统(SpringBoot+MP+Vue+微信小程序+JNI+ncnn+YOLOX-Nano)
一、项目简介 本项目是配合智慧自助餐厅下的一套综合系统,该系统分为安卓端、微信小程序用户端以及后台管理系统。安卓端利用图像识别技术进行识别多种不同菜品,识别成功后安卓端显示该订单菜品以及价格并且生成进入小程序的二维码,用户扫描…...

零基础学编程从入门到精通,系统化的编程视频教程上线,中文编程开发语言工具构件之缩放控制面板构件用法
一、前言 零基础学编程从入门到精通,系统化的编程视频教程上线,中文编程开发语言工具构件之缩放控制面板构件用法 编程入门视频教程链接 https://edu.csdn.net/course/detail/39036 编程工具及实例源码文件下载可以点击最下方官网卡片——软件下载—…...

【MySQL进阶之路】MySQL 中表空间和数据区的概念以及预读机制
欢迎关注公众号(通过文章导读关注:【11来了】),及时收到 AI 前沿项目工具及新技术的推送! 在我后台回复 「资料」 可领取编程高频电子书! 在我后台回复「面试」可领取硬核面试笔记! 文章导读地址…...

JVM 性能调优 - 常用的垃圾回收器(6)
垃圾收集器 在 JVM(Java虚拟机)中,垃圾收集器(Garbage Collector)是负责自动管理内存的组件。它的主要任务是在程序运行过程中,自动回收不再使用的对象所占用的内存空间,以便为新的对象提供足够的内存。 JVM中的垃圾收集器使用不同的算法和策略来实现垃圾收集过程,以…...

【java】Hibernate访问数据库
一、Hibernate访问数据库案例 Hibernate 是一个在 Java 社区广泛使用的对象关系映射(ORM)工具。它简化了 Java 应用程序中数据库操作的复杂性,并提供了一个框架,用于将对象模型数据映射到传统的关系型数据库。下面是一个简单的使…...
从零开始手写mmo游戏从框架到爆炸(八)— byte数组传输
导航:从零开始手写mmo游戏从框架到爆炸(零)—— 导航-CSDN博客 Netty帧解码器 Netty中,提供了几个重要的可以直接使用的帧解码器。 LineBasedFrameDecoder 行分割帧解码器。适用场景:每个上层数据包,使…...

Elasticsearch:BM25 及 使用 Elasticsearch 和 LangChain 的自查询检索器
本工作簿演示了 Elasticsearch 的自查询检索器将非结构化查询转换为结构化查询的示例,我们将其用于 BM25 示例。 在这个例子中: 我们将摄取 LangChain 之外的电影样本数据集自定义 ElasticsearchStore 中的检索策略以仅使用 BM25使用自查询检索将问题转…...
uniapp的api用法大全
页面生命周期API uniApp中的页面生命周期API可以帮助开发者在页面的不同生命周期中执行相应的操作。常用的页面生命周期API包括:onLoad、onShow、onReady、onHide、onUnload等。其中,onLoad在页面加载时触发,onShow在页面显示时触发…...

深度学习在微纳光子学中的应用
深度学习在微纳光子学中的主要应用方向 深度学习与微纳光子学的结合主要集中在以下几个方向: 逆向设计 通过神经网络快速预测微纳结构的光学响应,替代传统耗时的数值模拟方法。例如设计超表面、光子晶体等结构。 特征提取与优化 从复杂的光学数据中自…...

.Net框架,除了EF还有很多很多......
文章目录 1. 引言2. Dapper2.1 概述与设计原理2.2 核心功能与代码示例基本查询多映射查询存储过程调用 2.3 性能优化原理2.4 适用场景 3. NHibernate3.1 概述与架构设计3.2 映射配置示例Fluent映射XML映射 3.3 查询示例HQL查询Criteria APILINQ提供程序 3.4 高级特性3.5 适用场…...

高频面试之3Zookeeper
高频面试之3Zookeeper 文章目录 高频面试之3Zookeeper3.1 常用命令3.2 选举机制3.3 Zookeeper符合法则中哪两个?3.4 Zookeeper脑裂3.5 Zookeeper用来干嘛了 3.1 常用命令 ls、get、create、delete、deleteall3.2 选举机制 半数机制(过半机制࿰…...

《通信之道——从微积分到 5G》读书总结
第1章 绪 论 1.1 这是一本什么样的书 通信技术,说到底就是数学。 那些最基础、最本质的部分。 1.2 什么是通信 通信 发送方 接收方 承载信息的信号 解调出其中承载的信息 信息在发送方那里被加工成信号(调制) 把信息从信号中抽取出来&am…...
spring:实例工厂方法获取bean
spring处理使用静态工厂方法获取bean实例,也可以通过实例工厂方法获取bean实例。 实例工厂方法步骤如下: 定义实例工厂类(Java代码),定义实例工厂(xml),定义调用实例工厂ÿ…...
LLM基础1_语言模型如何处理文本
基于GitHub项目:https://github.com/datawhalechina/llms-from-scratch-cn 工具介绍 tiktoken:OpenAI开发的专业"分词器" torch:Facebook开发的强力计算引擎,相当于超级计算器 理解词嵌入:给词语画"…...

全志A40i android7.1 调试信息打印串口由uart0改为uart3
一,概述 1. 目的 将调试信息打印串口由uart0改为uart3。 2. 版本信息 Uboot版本:2014.07; Kernel版本:Linux-3.10; 二,Uboot 1. sys_config.fex改动 使能uart3(TX:PH00 RX:PH01),并让boo…...
CMake控制VS2022项目文件分组
我们可以通过 CMake 控制源文件的组织结构,使它们在 VS 解决方案资源管理器中以“组”(Filter)的形式进行分类展示。 🎯 目标 通过 CMake 脚本将 .cpp、.h 等源文件分组显示在 Visual Studio 2022 的解决方案资源管理器中。 ✅ 支持的方法汇总(共4种) 方法描述是否推荐…...

R语言速释制剂QBD解决方案之三
本文是《Quality by Design for ANDAs: An Example for Immediate-Release Dosage Forms》第一个处方的R语言解决方案。 第一个处方研究评估原料药粒径分布、MCC/Lactose比例、崩解剂用量对制剂CQAs的影响。 第二处方研究用于理解颗粒外加硬脂酸镁和滑石粉对片剂质量和可生产…...

AI+无人机如何守护濒危物种?YOLOv8实现95%精准识别
【导读】 野生动物监测在理解和保护生态系统中发挥着至关重要的作用。然而,传统的野生动物观察方法往往耗时耗力、成本高昂且范围有限。无人机的出现为野生动物监测提供了有前景的替代方案,能够实现大范围覆盖并远程采集数据。尽管具备这些优势…...