0%

一直以来,从 JavaScriptPHPPythonGolang,然后还有linux系统中,无处不见正则表达式的身影,可是一致困扰在POSIXPCRE的概念中,分不清这两个是个啥,今天就来翻翻正则表达式的老底,了解了解正则表达式的前世今生。

Regular ExpressionRegular一般被译为正则、正规、常规。此处的Regular即是规则的意思,Regular Expression即描述某种规则的表达式之意。

正则表达式(英语:Regular Expression,在代码中常简写为regexregexpRE),是计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。在很多文本编辑器里,正则表达式通常被用来检索、替换那些匹配某个模式的文本。

许多程序设计语言都支持利用正则表达式进行字符串操作。例如,在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件(例如sedgrep)普及开的。正则表达式通常缩写成regex,单数有regexpregex,复数有regexpsregexesregexen

阅读全文 »

std::marker::PhantomData 是一个零大小的类型,用于标记一些类型,这些类型看起来拥有类型 T,但实际上并没有:

1
2
3
pub struct PhantomData<T>
where
T: ?Sized;

Rust 并不希望在定义类型时,出现目前还没使用,但未来会被使用的泛型参数,例如未使用的生命周期参数以及未使用的类型。

PhantomData 最常见的用例可能是具有未使用的生命周期参数的结构体,例如,这儿有一个结构体 Slice,它有两个 *const T 类型的指针,可能指向某个地方的数组,我们期望 Slice 类型的值在生命周期 'a 内仅仅有效,但是如果像下面这样,'a 我们又无处安放:

1
2
3
4
struct Slice<'a, T> {
start: *const T,
end: *const T,
}

我们可以使用 PhantomData 告诉编译器就像 Slice 结构包含引用 &'a T 一样来纠正这个问题:

1
2
3
4
5
6
7
use std::marker::PhantomData;

struct Slice<'a, T: 'a> {
start: *const T,
end: *const T,
phantom: PhantomData<&'a T>,
}

这反过来要求 T 类型中的任何引用在生命周期 'a 内都是有效的,初始化 Slice 时,仅需要为 phantom 字段提供值 PhantomData 即可:

1
2
3
4
5
6
7
8
fn borrow_vec<T>(vec: &Vec<T>) -> Slice<'_, T> {
let ptr = vec.as_ptr();
Slice {
start: ptr,
end: unsafe { ptr.add(vec.len()) },
phantom: PhantomData,
}
}
阅读全文 »

sliceGo 里面最常用的数据结构之一,相比起长度固定的数组,slice 使用起来更加灵活,它可以动态扩容,可以从其他 slice 或者数组创建。不过 slice 的底层依然是一个固定长度的数组,也就是一片连续内存,当插入新的元素时,如果当前容量不够,就需要扩容,申请一片足够大的内存,并将原有的内容的复制进去。

接下来的测试使用的 Go 版本都是:go version go1.18 darwin/arm64

创建一个 slice,我们有下面几种方法(Go 官方文档中也有详细的说明):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main

import "fmt"

func main() {
// 方法一:slice 字面量
var s1 = []int{1, 2, 3, 4}
fmt.Println(s1, len(s1), cap(s1))

// 方法二:使用 make 创建
var s2 = make([]int, 10, 10)
fmt.Println(s2, len(s2), cap(s2))

// 方法三:从数组或者slice创建,引用数组的部分片段
// 形式是:arr[low:high],那么创建的 slice 长度是 high-low,容量是:cap(arr) - low
var arr = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var s3 = arr[2:8]
fmt.Println(s3, len(s3), cap(s3))

// 方法四:类似前面的方法,但是我们在创建时可以指定最大容量,形式是:arr[low:high:max]
// 这种情况下容量是 max - low,长度是:high - low
var s4 = s3[1:4:7]
fmt.Println(s4, len(s4), cap(s4))

// 当然还有其他的形式,例如我们可以从数组的指针创建
var s5 = (&arr)[2:4]
fmt.Println(s5, len(s5), cap(s5))
}

这将输出:

[1 2 3 4] 4 4
[0 0 0 0 0 0 0 0 0 0] 10 10
[2 3 4 5 6 7] 6 8
[3 4 5] 3 6
[2 3] 2 8
阅读全文 »

很多时候,我们需要实现一些自动优化的数据结构,在某些情况下是一种优化的数据结构和相应的算法,在其他情况下使用通用的结构和通用的算法。比如当一个 HashSet 的内容比较少的时候,可以用数组实现,但内容逐渐增多,再转换成用哈希表实现。如果我们想让使用者不用关心这些实现的细节,使用同样的接口就能享受到更好的性能,那么,就可以考虑用智能指针来统一它的行为。

我们来实现一个智能 StringRustString 在栈上占了 24 个字节,然后在堆上存放字符串实际的内容,对于一些比较短的字符串,这很浪费内存。

参考 Cow,我们可以用一个 enum 来处理:当字符串小于 N 字节时,我们直接用栈上的数组,否则使用 String。但是这个 N 不宜太大,否则当使用 String 时,会比目前的版本浪费内存。

当使用 enum 时,额外的 tag + 为了对齐而使用的 padding 会占用一些内存。因为 String 结构是 8 字节对齐的,我们的 enum 最小 8 + 24 = 32 个字节。

所以,可以设计一个数据结构,内部用1个字节表示字符串的长度,用 30 个字节表示字符串内容,再加上 1 个字节的 tag,正好也是 32 字节,可以和 String 放在一个 enum 里使用,我们暂且称这个 enumSmartString,它的结构如下图所示:

阅读全文 »

使用 std::sync::Mutex 可以多线程共享可变数据,MutexRwLock 和原子类型,即使声明为 non-mut,这些类型也可以修改:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
use std::borrow::Cow;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
// 用 Arc 来提供并发环境下的共享所有权(使用引用计数)
let metrics: Arc<Mutex<HashMap<Cow<'static, str>, usize>>> =
Arc::new(Mutex::new(HashMap::new()));
for _ in 0..32 {
let m = metrics.clone();
thread::spawn(move || {
let mut g = m.lock().unwrap();

// 此时只有拿到 MutexGuard 的线程可以访问 HashMap
let data = &mut *g;

// Cow 实现了很多数据结构的 From trait,
// 所以我们可以用 "hello".into() 生成 Cow
let value = data.entry("hello".into()).or_insert(0);
*value += 1;

// MutexGuard 被 Drop,锁被释放
});
}

thread::sleep(Duration::from_millis(100));
println!("metrics: {:?}", metrics.lock().unwrap());
}

构造 Double Free

使用 unsafe 特性构造指向同一块内存的两个变量,导致 Double Free

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
use std::{mem, ptr};

fn main() {
let mut d = String::from("cccc");
let d_len = d.len();

let mut c = String::with_capacity(d_len);
unsafe {
ptr::copy(&d, &mut c, 1);
};
println!("{:?}", c.as_ptr());

println!("{:?}", d.as_ptr());
d.push_str("c");
println!("{}", d);
}
阅读全文 »

Rust 中使用 std::result::Result 表示可能出错的操作,成功的时候是 Ok(T),而出错的时候则是 Err(E)

1
2
3
4
pub enum Result<T, E> {
Ok(T),
Err(E),
}

通常情况下,E 是实现 std::error::Error 的错误类型:

1
2
3
4
5
6
pub trait Error: Debug + Display {
fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
fn backtrace(&self) -> Option<&Backtrace> { ... }
fn description(&self) -> &str { ... }
fn cause(&self) -> Option<&dyn Error> { ... }
}

我们通常也需要在自己的代码中自定义错误,并且为之手动实现 std::error::Error,这个工作很麻烦,所以就有了 thiserror,自动帮我们生成实现的 std::error::Error 的代码。

而借助于 anyhow::Error,和与之对应的 Result<T, anyhow::Error>,等价于 anyhow::Result<T>,我们可以使用 ? 在可能失败的函数中传播任何实现了 std::error::Error 的错误。

阅读全文 »

世界上的每个程序并非都是用 Rust 编写的,我们希望能够在我们的 Rust 程序中使用许多用其他语言实现的关键库和接口。Rust 的外部函数接口 (FFI) 允许 Rust 代码调用用 C 编写的函数,也可以是 C++。由于大多数操作系统都提供 C 接口,Rust 的外部函数接口允许立即访问各种低级功能。

在本章中,我们将编写一个与 libgit2 链接的程序,libgit2 是一个用于与 Git 版本控制系统一起工作的 C 库。首先,我们使用前一章中展示的 unsafe 特性展示直接从 Rust 使用 C 函数的例子,然后,我们将展示如何构建 libgit2 的安全接口,灵感来自开源 git2-rs。本文假设你熟悉 C 以及编译和链接 C 程序的机制,还假设熟悉 Git 版本控制系统。

现实中确实存在用于与许多其他语言进行通信的 Rust 包,包括 PythonJavaScriptLuaJava。这里没有篇幅介绍它们,但归根结底,所有这些接口都是使用 C 外来函数接口构建的。

阅读全文 »

系统编程的秘密乐趣在于,在每一种安全语言和精心设计的抽象之下,都存在着极其 unsafe 的机器语言和小技巧,我们也可以用 Rust 来写。

到目前为止,我们介绍的语言可确保程序通过类型、生命周期、边界检查等完全自动地避免内存错误和数据竞争,但是这种自动推断有其局限性,有许多有价值的技术手段是无法被 Rust 认可的。

unsafe 代码告诉 Rust,程序选择使用它无法保证安全的特性。通过将代码块或函数标记为 unsafe,可以获得调用标准库中的 unsafe 函数、解引用 unsafe 指针以及调用用其他语言(如 CC++ )编写的函数以及其他能力。

这种跳出安全 Rust 边界的能力使得在 Rust 中实现许多 Rust 最基本的功能成为可能,就像 CC++ 用来实现自己的标准库一样。 unsafe 代码允许 Vec 有效地管理其缓冲区、 std::io 能直接和操作系统对话、以及提供并发原语的 std::threadstd::sync

本节将 unsafe 功能的要点:

  • Rustunsafe 块在安全的 Rust 代码和使用 unsafe 特性的代码之间建立了界限;

  • 可以将函数标记为 unsafe,提醒调用者存他们必须遵守的额外规范以避免未定义的行为;

  • 裸指针及其方法允许不受限制地访问内存,并允许构建 Rust 类型系统原本禁止的数据结构。尽管 Rust 的引用是安全但受约束的,但正如任何 CC++ 程序员所知道的,裸指针是一个强大而锋利的工具;

  • 了解未定义行为将帮助理解为什么它会产生比仅仅得到错误结果更严重的后果;

  • unsafeTrait,类似于 unsafe 的函数,强加了每个实现必须遵循的规约;

阅读全文 »

Rust 语言支持宏,如我们之前使用的 assert_eq!println! 等。宏做了函数不能做的一些事情,例如,assert_eq! 当一个断言失败时,assert_eq! 生成包含断言的文件名和行号的错误消息,普通函数无法获取这些信息,但宏可以,因为它们的工作方式完全不同。

宏是一种简写,在编译期间,在检查类型和生成任何机器代码之前,每个宏调用都会被扩展。也就是说,它被一些 Rust 代码替换。assert_eq! 调用扩展为大致如下:

1
2
3
4
5
6
7
8
9
10
match (&gcd(6, 10), &2) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
panic!(
"assertion failed: `(left == right)`, (left: `{:?}`, right: `{:?}`)",
left_val, right_val
);
}
}
}

panic! 也是一个宏,它本身扩展为更多的 Rust 代码。该代码使用到了另外两个宏:file!()line!()。 一旦 crate 中的每个宏调用都被完全展开,Rust 就会进入下一个编译阶段。

在运行时,断言失败看起来像这样:

thread 'main' panicked at 'assertion failed: `(left == right)`, (left: `17`, right: `2`)', gcd.rs:7

如果熟悉 C++,可能对宏有过一些不好的体验。但是 Rust 宏采用不同的方法,类似于 Scheme 的语法规则。与 C++ 宏相比,Rust 宏可以更好地与语言的其余部分集成,因此更不容易出错。宏调用总是标有感叹号 !,因此在阅读代码时它们会比较突出,所以不会意外调用它们。Rust 宏从不插入不匹配的括号或圆括号,并且 Rust 宏带有模式匹配,使得编写既可维护又易于使用的宏变得更加容易。

在本节中,我们将通过几个简单的例子来展示如何编写宏。但与 Rust 的大部分内容一样,理解宏需要下很大功夫。在这里将介绍一个很复杂的宏的设计,它可以将 JSON 文字直接嵌入到我们的程序中。但是宏的内容涵盖的非常多,因此这里将提供一些进一步研究的建议,包括我们在此处展示的高级技术,以及称为过程宏的更强大的工具。

阅读全文 »