败犬女主太多了 | 设定整理

WorkFlow | 记录3 

WorkFlow | 记录2

主要内容：

1. WorkFlow 项目期望功能
2. WorkFlow 架构设计
3. WorkFlow 实现计划



### * 一些碎碎念

~~这是去年被搁置的一个项目，我现在想了想，决定把现在它拿出来重新做，作为我简历上的一个已上线的，有实际作用的大型项目。希望我能独自顺利地完成它。~~

~~该项目预期客户端主要技术栈是 Jetpack Compose，后端主要技术栈是 Go Http 三件套。如果有余裕的话倒是想折腾一下 Kotlin.js 看看能不能上前端。~~

### 1 WorkFlow 项目期望功能

一开始我对这个项目的预期是一个更高级的文件管理，为文件附加信息，使其更好地进行管理，版本迭代和云端同步。现在我想要对这个应用有更高的期望：我想要它变成一个工作流管理的应用。我设想中的工作流是这样构成的：

- 项目/任务
- 人员
- 资料

从这三方面进行引申，就有了该项目的大致的期望功能：

1. 项目列表，在这里是对下面三个模块的集成。不仅要对所有的参与的项目管理（增删改查），还能关联相关的要用到的文件和知识库，以及任务中关联到的人。在这里引入一个聊天功能。项目的基本信息由发起者编辑，要用到的文件和知识库可以被参与者编辑等等。
2. TODO 列表，这里就是仅对用户自身有效的，可以标记为关联到某一项目，可以加闹钟。
3. 联系人管理，这个没啥好说的。注意单人聊天的功能就不要加了。
4. 文件管理，包括对文件加 tag，加注释，版本管理等。
5. 知识库管理，主要是以 Json 方式进行可视化编辑，参考思维导图或者 Neo4j。该知识库可以选择是否公开，可公开的部分可以被任意用户查找并且下载为自己的知识库。

### 2 WorkFlow 结构设计

1. 该项目数据库是 SQLite，用 Room 作为 ORM 来读写数据。
2. 该项目的网络相关库是 OkHttp，Json 怎么存暂时还没想好。
3. 该项目设置相关的是放到 DataStore 中的。
4. 统一这些 IO 操作的是 Repository 层，大致是一个模块对应一个 Repository。
5. 在 Repository 层和页面层中间的是 ViewModel 层，它负责和页面进行数据的交互。所有的状态都在 ViewModel 中，并且提供方法给上层的页面的事件（比如点击按钮一类的）。一个页面对应一个 ViewModel。
6. 这些结构统一用 Hilt 进行依赖注入。

示例代码如下：

``` kotlin
// 先是 Repository 层 依赖更下层的 DAO 和 OkHttp 此处仅为示例
class TestRepository @Inject constructor (private val dao: FileEntityDAO) {

    suspend fun UpdateValueTest(value: Int) {
        withContext(Dispatchers.IO) {
            dao.getAllFile()
        }
    }
}

// 再是 ViewModel 层 向上提供状态和接口
@HiltViewModel
class TestViewModel @Inject constructor(private val repository: TestRepository) : ViewModel() {
    private val _data = MutableStateFlow<Int>(1)

    val data : StateFlow<Int> get() = _data

    fun updateTestData (value: Int) {
        _data.value = value

        viewModelScope.launch {
            repository.UpdateValueTest(value)
        }
    }
}

// 最后是视图层 这层把 ViewModel 放在 Activity 还是 单独的 Compose 组件里都行 我认为是放在单独成页面的 Compose 组件中比较好
@Composable
fun Greeting2(name: String, modifier: Modifier = Modifier) {
    val viewModel : TestViewModel = hiltViewModel()

    val data by viewModel.data.collectAsState()
    var editedData by remember { mutableIntStateOf(data) }

    TextField(
        value = editedData.toString(),
        onValueChange = { newValue ->
            editedData = newValue.toInt()
        },
        modifier = modifier
    )

    Button(
        onClick = {
            viewModel.updateTestData(editedData)
        }
    ) {
        Text(
            text = "Update"
        )
    }
}
```

### 3 实现计划

1. 10月，先把 WorkFlow 这个大致的框架搭起来，功能上先以文件管理和 TODO 列表为主，先在本地跑通。
2. 11月，开始实现对应后端功能。客户端这块主要是联调和实现用户登录，如果时间来得及，可以把联系人功能加上。
3. 12月，主要任务是把知识库实现好，这块不太清楚需要怎么实现，所以留足时间。

### * 导入依赖

1. Hilt

在项目级别的`build.gradle.kts`中导入：

``` kotlin
plugins {
    ...
    id("com.google.dagger.hilt.android")version "2.52" apply false
}
```

在 App 级别的`build.gradle.kts`中导入：

``` kotlin
dependencies {
    ...
    val hiltVersion = "2.52"

    implementation("com.google.dagger:hilt-android:$hiltVersion")
    kapt("com.google.dagger:hilt-compiler:$hiltVersion")
    implementation("androidx.hilt:hilt-navigation-compose:1.2.0")
}
```

2. OkHttp

App 级别的`build.gradle.kts`中导入：

``` kotlin
dependencies {
    ...
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
}
```

:::danger{title="警告"}
Gradle 进行编译不成功的时候，一定要检查以下工具的版本是否对应，这里给出一个版本记录。

- Gradle 版本：8.9（在 Project Structure 内查看）
- Gradle 用的 Java 版本：17（在 Settings -> Build, Execution, Deployment -> Build Tools -> Gradle 内指定，也可在 gradle.properties 文件内通过`org.gradle.java.home`强制指定）
- Kotlin 版本：2.0.10（在 lib.versions.toml 文件内指定）
- Compose 组件（也说 Compose Compiler Gradle 插件）版本：依赖 Kotlin 版本（在 lib.versions.toml 文件内指定）
- KSP 版本：2.0.10-1.0.24（在项目级别的 build.gradle.kts 文件内指定）
- Kotlin 编译插件（`kotlinCompilerExtensionVersion`）版本：1.5.5（在 app 级别的 build.gradle.kts 文件内指定）
- Kotlin 编译源码标准和目标 Java 版本，目标 jvm 版本：17（在 app 级别的 build.gradle.kts 文件内指定）
- Android Gradle Plugin（agp）版本：8.7.0（在 Project Structure 内查看，也可在 lib.versions.toml 文件内指定）

如果有编译问题，大概率就是这几个东西版本冲突。
:::

WorkFlow | 记录1

主要内容：

1. 泛型
2. 带泛型的 ART 树的实现
3. String 类型的索引实现



### 1 Go 中的泛型

#### 1.1 泛型函数、泛型类型

泛型作为现代语言的一大重要特性，与 1.18 版本被引入。泛型的引入不仅节省了针对不同类型的代码的代码量，也改变了“接口”这一重要概念的定义。

:::tip{title="提示"}
Go 的泛型说实话实现的有点也不能说是残缺，就是说别扭吧。除了这个`[T]`符号选的贼怪异（与切片声明混合容易造成语义不明）之外，泛型还不支持方法和匿名函数也是虽然可以说无伤大雅，但也可以说是功能残缺。不过我个人就不太想纠结这些事情，我什么水平去直接关心语言的实现（），用就是了。
:::

Go 中的泛型声明使用`[]`这一符号，一个简单的泛型函数示例如下：

``` go
func GenericFuncTest [T comparable] (param1 T) T {
	return param1
}

func t () {
	GenericFuncTest[int](1)
}
```

在上述代码中，引入了泛型`T`，每次调用`GenericFuncTest`函数时，都要指定这个泛型的实际类型。而`T`的后面用`comparable`指定了该泛型的类型范围。这一段话里就引出了三个概念：

- 类型形参：`T`，即每次使用泛型时，可以理解为那个泛型的代指
- 类型实参：`int`，每次使用泛型时，实际要用的类型
- 类型约束：`comparable`，该泛型能够匹配的类型

除了泛型函数，类型也是可以指定泛型的，而且上面三个概念依然沿用。

``` go
type GenericMapTest [Key comparable, Value string | int | []string | []Key] map[Key]Value // 没错 泛型可以一次性指定多个 还能互相嵌套

func t () {
	m := GenericMapTest[int, string]{}
	m[1] = "1"
}
```

但是有些写法是会报错的，比如这样：

``` go
//type GenericSliceTest [Elem *GenericMapTest[int, string]] []Elem
// 会报错 主要原因就在那个 * 上
// 下面这个写法就没问题 如果泛型出了语法问题可以考虑包上一层 interface

type GenericSliceTest [Elem interface{*GenericMapTest[int, string]}] []Elem
```

另外，**匿名结构体和匿名函数是不支持泛型的**。

#### 1.2 泛型方法

既然有了泛型类型和泛型函数，那么泛型方法也有，虽然多少有点功能不全。

``` go
type GenericMapTest [Key comparable, Value any] map[Key]Value

func (receiver GenericMapTest[Key, Value]) DeleteElement(key Key) (deleteValue Value) {
	deleteValue, ok := receiver[key]
	if ok {
		delete(receiver, key)
		return deleteValue
	}
	return
}
```

关于泛型方法，要提的点有这几条：

- 泛型方法是**不支持泛型类型以外的泛型**的，即使是普通方法也是不能加泛型的。比如说要是这么声明函数，是过不了编译的：

``` go
func (receiver GenericMapTest[Key, Value]) DeleteElement[T any](key Key) (deleteValue T)
```

:::tip{title="提示"}
关于为什么方法不能引入除了调用者泛型以外的泛型，最简洁的回答是：可以做，但是为了避免编译器复杂度所以没做。具体点说的话，原因如下：

- Go 会在编译期就确定所有泛型的类型，并且根据调用方的类型实参来编译相对应的泛型函数/类型代码，这事好说，在哪里调用了就在哪开始编译对应类型的函数/类型。就像之前的例子中，编译到`GenericMapTest`的时候先过，到具体的要用到这个类型的时候`m := GenericMapTest[int, string]{}`再编译`int`，`string`对应代码。
- 但是方法就不一样了，得考虑接口的存在了。当一个变量类型断言成一个接口类型并且调用泛型方法的时候，它不能确定该变量的实际类型的接口实现函数的对应类型有没有被编译过，也不好编译对应代码。比如说有个 A 接口，底下有一个泛型方法等着实现，有个 B 类型，实现了该泛型方法。然后在 C 函数下通过类型断言的方法将一个`any`断言为 A 类型，调用泛型方法。此时编译器是不知道 B 类型的那个泛型方法实现有没有被针对实际类型编译过的。最极端的情况下，它得扫描整个包才能确定这件事，那开销就大了。更别提**类型断言是在运行期而不是编译期的事**（我到写这篇文的时候才知道），那更没法编译了。

上面的话多少有点别扭，主要是我理解的也有点别扭。看原文的话详情参见：[Type Parameter Proposal](https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md#No-parameterized-methods)
:::

- 传进来的泛型类型下的参数，是**不能使用 switch 和类型断言的**。如果要实际的获得参数类型，只能用反射。

#### 1.3 接口新定义

之前在指定类型约束的时候，其实很容易一写就写很长的泛型约束，并且这么长的泛型约束也不好复用。所以 Go 将这个问题交给接口来解决。

``` go
type Int interface {
    int | int8 | int16 | int32 | int64
}

type Uint interface {
    uint | uint8 | uint16 | uint32
}

type Float interface {
    float32 | float64
}

type Slice[T Int | Uint | Float] []T

type SliceElement interface {
    Int | Uint | Float | string
}

type Slice[T SliceElement] []T 
```

如上，接口中可以通过指定类型约束来形成一个新的类型，该类型可以在别的泛型中嵌套，也可以和普通的类型一起用。

类型约束可以通过三个运算符来指定：`|``~`和换行，分别表示类型取并集，类型取底层类型，类型取交集。另外，指定了类型约束的接口仍然可以指定要实现的函数原型。

``` go
type GenericInterfaceTest interface {
	~uint8 | ~uint16 | uint32
	byte
        
        String() string
}
```

如上，该泛型接口所指定的类型约束就是以 uint8 为底层类型的所有类型。首先是上面三个 uint 取并集，之后和下面的 byte 取交集，那么取完之后就剩底层为 uint8 的类型了。

由此可以看到，**从 Go 加入泛型之后，以前的接口定义已经不适用了，毕竟不止有要实现的函数**。来回顾一下以前的接口是如何定义的：

> An interface type specifies a method set called its interface.（**一个声明了方法集的接口类型即为接口**）

再看看 Go 1.18之后接口的定义：

> An interface type defines a type set.（**一个接口定义了一个类型的集合**）

接口从一个**方法集**变成了**类型集**。按照此定义，`GenericInterfaceTest`的定义即为：所有底层类型为 uint8 的，并且持有`String`方法的类型的集合；而`interface{}`类型（Go 1.18后新增其别名`any`）的定义即为：所有的类型的集合。而原来的接口定义依然可以套这个新的定义，即**如果一个类型持有一个接口所定义的所有函数原型的对应方法，那么可以认为该类型属于该接口所定义的类型集**。

:::tip{title="comparable"}
特殊的，Go 定义了一个类型`comparable`，该类型是所有可以用`==``!=`比较的类型的集合。需要注意，它**仅仅是可比较，而不是可以比较大小，它只能比较是否相同**。

另外，`comparable`不能被直接或间接地和其他类型合并。
:::

#### 1.4 泛型接口

接口也可以引入泛型，如下示例：

``` go
// 泛型接口定义
type GenericInterfaceTest [T any] interface {
	int | struct{ testValue string }
	
	GenericInterfaceFuncTest (value T) string
}
// 如果该接口没有指定类型集的话 可以通过类似 GenericInterfaceTest[string] 这样的方式成为一个变量的类型

// 实现接口
type GenericInterfaceImplement struct {
	testValue string
}

func (g *GenericInterfaceImplement) GenericInterfaceFuncTest (value string) string {
	return g.testValue + value
}

// 子接口
type GenericInterfaceImplement2 [T any] interface {
	int
	
	GenericInterfaceFuncTest (value T) string
}
```

#### 1.* 一些注意事项

1. 如果一个接口定义了类型约束，那么它不能被实例化。
2. 类型取交集可以用两个完全没有交集的类型，虽然结果是个空集，没有任何类型是它的成员，没有实际意义，但是它是能过编译的。
3. 类型取并集的时候要求取并集的两个类型不能有交集，但是如果其中一个类型是接口的话，可以无视这一规则。
4. 类型取并集的时候，不能用类型形参来取并集。
5. 接口不能直接或者间接地并入自己。
6. 取底层类型的时候，只能用基本类型，类型别名和别的类型都不行，接口也不行。
7. 如果一个接口带方法，那么该接口不能被取并集。

### 2 ART 树的实现

:::tip{title="提示"}
该实现是在[plar/go-adaptive-radix-tree](https://github.com/plar/go-adaptive-radix-tree)的基础上写的。我阅读了所有源码，对着源码写了自己的代码，并且加入了泛型。
:::

ART 树（adaptive radix tree）是一个在前缀树的基础上进行改进的树，它的主要功能是以字节数组为键，进行键值对的有序存储。相比于一般的前缀树，它可以通过不同的节点大小和压缩前缀来大幅减少内存占用的同时，达到相近的性能。

> 前缀树：一种按字节数组存储的树。假设它要存储的目标只有a到z这26个字节，那么它的每个节点都有一个长度为26的字节数组，每个元素存储指向子节点的指针。从根节点开始，每个节点按顺序使用字节数组的一个元素来指向子节点，所以前缀树的高度取决于存储的最长的字节数组。

ART 树有四种节点类型：`node4`，`node16`，`node48`，`node256`。每种节点能存储对应上限个子节点：`node4`能存储4个子节点，`node16`能存储16个子节点，以此类推。节点之间可以按需互相转换，比如如果有需求要在`node4`节点下新增一个子节点的话，该节点就可以转换为`node16`。

除了可转换的节点以外，ART 树还能重用共有的前缀。举例来说，假如树上存储了以`apple`，`app`为键的两个值，那么共同的前缀`app`就会存储到一个节点中，而不是分成三个节点存储。

该树所能支持的操作如下：

``` go
// New 获取一棵新的树
func New[T Value]() Tree[T] {}

type Node[T Value] interface {
	Kind() Kind
	Key() Key
	Value() T
}

// Iterator 迭代器实例
type Iterator[T Value] interface {
	// HasNext 是否存在下一个节点
	HasNext() bool
	// Next 获取下一个节点 如果下一个节点不存在或者树结构被修改 就返回 NoMoreNodeErr 或者 TreeIsModifiedErr
	Next() (node Node[T], e error)
}

// Tree 树的接口
type Tree[T Value] interface {
	// Insert 根据指定的键插入新值 如果键在树中已经有值 就更新值 返回旧的值 并且返回 true
	Insert(key Key, value T) (oldValue T, isUpdated bool)
	// Delete 根据指定的键删除对应的值 并且返回被删除的旧值 如果键不存在将返回 false
	Delete(key Key) (deleteValue T, isDeleted bool)
	// Search 根据指定的键寻找对应的值
	Search(key Key) (value T, isFound bool)

	// ForEach 对树进行遍历 对于每个被遍历到的 符合条件的节点调用 callback 函数 默认情况下遍历只遍历叶子节点
	ForEach(callback Callback[T], options ...int)
	// ForEachWithPrefix 对树进行遍历 对于每个被遍历到的 前缀和指定的键匹配的 符合条件的节点调用 callback 函数 默认情况下遍历只遍历叶子节点
	ForEachWithPrefix(keyPrefix Key, callback Callback[T], options ...int)
	// Iterator 获取一个新的迭代器 默认只遍历叶子节点
	Iterator(options ...int) Iterator[T]

	// Minimum 获取当前树上字典序最小的键所对应的值
	Minimum() (min T, isFound bool)
	// Maximum 获取当前树上字典序最大的键所对应的值
	Maximum() (max T, isFound bool)

	// Size 获取树上键值对数量
	Size() int
}
```

具体的实现就不说了，就写几个写的过程中出现的问题吧。

*****

原作者的节点实现是这样的：

``` go
type artNode[T Value] struct {
	reference unsafe.Pointer
	kind      Kind
}

type nodePrototype[T Value] struct {
	prefixLen   uint32
	prefix      prefix
	childrenNum uint16
	zeroChild   *artNode[T] // 这东西是给正好断在别的键的中间的键用的 比如说 apple 和 appleWatch apple对应的叶子节点就放在这
}

type node4[T Value] struct {
	nodePrototype[T]
	children [node4Max]*artNode[T]
	keys     [node4Max]byte
	isExist  *bitmap
}

type node16[T Value] struct {
	nodePrototype[T]
	children [node16Max]*artNode[T]
	keys     [node16Max]byte
	isExist  *bitmap
}

type node48[T Value] struct {
	nodePrototype[T]
	children [node48Max]*artNode[T]
	keys     [node256Max]byte
	isExist  *bitmap
}

type node256[T Value] struct {
	nodePrototype[T]
	children [node256Max]*artNode[T]
}

type leaf[T Value] struct {
	key   Key
	value T
}
```

它的结构是这样的：所有的节点首先是一个`artNode`类型的结构体，在该结构体内部另有一个指针指向实际的节点内容`nodePrototype`，该类型是所有节点类型的原型，其他的节点类型（除了叶子节点以外）都将其组合进去了。这一点看它们的工厂方法就很明显了：

``` go
func newNode4[T Value]() *artNode[T] {
	return &artNode[T]{
		reference: unsafe.Pointer(&node4[T]{
			isExist: newBitmap(4),
		}),
		kind: Node4,
	}
}

func newNode16[T Value]() *artNode[T] {
	return &artNode[T]{
		reference: unsafe.Pointer(&node16[T]{
			isExist: newBitmap(16),
		}),
		kind: Node16,
	}
}

func newNode48[T Value]() *artNode[T] {
	return &artNode[T]{
		reference: unsafe.Pointer(&node48[T]{
			isExist: newBitmap(256),
		}),
		kind: Node48,
	}
}

func newNode256[T Value]() *artNode[T] {
	return &artNode[T]{
		reference: unsafe.Pointer(new(node256[T])),
		kind:      Node256,
	}
}

func newLeaf[T Value](key Key, value T) *artNode[T] {
	clonedKey := make(Key, len(key))
	copy(clonedKey, key)
	return &artNode[T]{
		reference: unsafe.Pointer(&leaf[T]{
			key:   clonedKey,
			value: value,
		}),
		kind: Leaf,
	}
}
```

这种设计一方面是为了转型方便：`unsafe.Pointer`可以被毫无限制的转型成想要的指针类型。

``` go
func (a *artNode[T]) node() *nodePrototype[T] {
	return (*nodePrototype[T])(a.reference)
}
```

另一方面是为了便于替换节点，比如下面两个函数：

``` go
func replaceRef[T Value](oldNode **artNode[T], newNode *artNode[T]) {
	*oldNode = newNode
}

func replaceNode[T Value](oldNode *artNode[T], newNode *artNode[T]) {
	*oldNode = *newNode
}
```

第一个是替换指针内容，将原本是指向`oldNode`的指针修改为指向`newNode`；第二个是替换实际的指向内容，将`newNode`的内容拷贝到存储`oldNode`的内存中。这两个的区别是改指向还是该内容，基于这个区别，前者一定是在树这个层面上用，后者一定是在节点这个层面上用，但是这两个操作的前提都是基于相同的类型才可以。

*****

因为字节0也是有实际意义的，所以节点内不仅有字节数组来存储子节点所代表的字节，还需要一个结构来存储哪个字节是有实际意义的。原作者针对不同的节点，用的是不同的位图：`[node4Max]byte`，`uint16`，`[4]uint64`（`node256`是不需要这个结构的，只需要检查子节点是否为空即可）。如果字节数组对应位置有意义，那么对应的位为1，反之则为0。鉴于原作者的位运算实在过于复杂而且感觉还有问题（？），我自己封装了一个统一的位图。

``` go
// bitmap 对位图进行封装 把读写逻辑都封进来
// 其底层为 uint16 的切片
type bitmap struct {
	data            []uint16
	effectiveLength int
}

// newBitmap 获取一个新的 bitmap length 用于指定 bitmap 的有效长度
//
// 如果 length 不足16也是用 uint16 进行存储
func newBitmap(length int) *bitmap {
	arrayLength := length / 16
	if length%16 != 0 {
		arrayLength += 1
	}
	return &bitmap{
		data:            make([]uint16, arrayLength),
		effectiveLength: length,
	}
}

// set1 将指定的数位设置为1 如果指定的数位超过了初始化 bitmap 时指定的长度 将不做任何操作
func (b *bitmap) set1(index int) {
	if index >= b.effectiveLength {
		return
	}
	arrayIndex := index / 16
	i := index % 16
	if i == 0 {
		b.data[arrayIndex] |= 1
		return
	}
	b.data[arrayIndex] |= 1 << i
}

// set0 将指定的数位设置为0 如果指定的数位超过了初始化 bitmap 时指定的长度 将不做任何操作
func (b *bitmap) set0(index int) {
	if index >= b.effectiveLength {
		return
	}
	arrayIndex := index / 16
	i := index % 16
	if i == 0 {
		b.data[arrayIndex] &= 65534 // 655534 = 1111111111111110
		return
	}
	b.data[arrayIndex] &= ^(1 << i)
}

// get 指定数位是否为1 如果指定的数位超过了初始化直接返回 false
func (b *bitmap) get(index int) bool {
	if index >= b.effectiveLength {
		return false
	}
	arrayIndex := index / 16
	i := index % 16
	return (b.data[arrayIndex] & (1 << i)) != 0
}

// getNum 获取当前位图中数位为1的位的数量
func (b *bitmap) getNum() int {
	count := 0
	s := b.string()
	for i := range s {
		if s[i] == 49 {
			count += 1
		}
	}

	return count
}

func (b *bitmap) string() string {
	strBuilder := &strings.Builder{}
	for i := range b.data {
		if b.data[i] == 0 {
			strBuilder.WriteString("0 ")
		} else {
			strBuilder.WriteString(numToBinIncludeLeadingZero(b.data[i]))
			strBuilder.WriteString(" ")
		}
	}

	return strBuilder.String()
}
```

位图是个应用挺广的东西，除了这种代替布尔数组来指示是否的用途以外，也可以用来方便的传递多配置项：

``` go
const (
	TraverseLeaf = 1
	TraverseNode = 2
	TraverseAll  = TraverseLeaf | TraverseNode
)
```

### 3 String 类型的索引实现

目前 String 类型所能支持的操作如下：

1. `set`，不多说。
2. `get`，不多说。
3. `setnx`，只有在键不存在的时候设置值。
4. `getrange`，获取对应的值的在`[start, end]`范围内的字符。
5. `getset`，先按key获取旧的值，然后再设置新的值并且返回旧值。
6. `append`，在key存在的情况下，向其已经存在的value追加一个字符串。
7. `del`，不多说。

这个索引结构也没啥可说的了，就是 ART 树。

~~到这之后，这个类 Redis 数据库也就差不多了，再另加功能的话一个是自动整理存档文件，另外的就涉及分布式了。~~