@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//346/225/260/346/215/256/347/273/223/346/236/204//346/240/221/345/275/242/347/261/273/345/236/213-gtree//346/240/221/345/275/242/347/261/273/345/236/213-/346/226/271/346/263/225/344/273/213/347/273/215.md

@@ -0,0 +1,1254 @@
+:::tip
+以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档： [https://pkg.go.dev/github.com/gogf/gf/v2/container/gtree](https://pkg.go.dev/github.com/gogf/gf/v2/container/gtree)
+:::
+## `NewBTree`
+
+- 说明： `NewBTree` 使用 `m`(最大子节点数量)和自定义的比较方法创建 `BTree`。参数 `safe` 用于指定是否使用并发安全的 `tree`，默认情况下为 `false`。
+
+- 注意：参数 `m` 必须大于等于 `3`，否则会 `panic`。
+- 格式：
+
+```go
+NewBTree(m int, comparator func(v1, v2 interface{}) int, safe ...bool) *BTree
+```
+
+- 示例：
+
+```go
+func ExampleNewBTree() {
+      bTree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          bTree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+      fmt.Println(bTree.Map())
+
+      // Output:
+      // map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
+}
+```
+
+## `NewBTreeFrom`
+
+- 说明： `NewBTreeFrom` 使用 `m`(最大子节点数量)，自定义的比较方法和类型为 `map[interface{}]interface{}` 的 `data` 创建 `BTree`。参数 `safe` 用于指定是否使用并发安全的 `tree`，默认情况下为 `false`。
+
+- 注意：参数 `m` 必须大于等于 `3`，否则会 `panic`。
+- 格式：
+
+```go
+NewBTreeFrom(m int, comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *BTree
+```
+
+- 示例：
+
+```go
+func ExampleNewBTreeFrom() {
+      bTree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          bTree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      otherBTree := gtree.NewBTreeFrom(3, gutil.ComparatorString, bTree.Map())
+      fmt.Println(otherBTree.Map())
+
+      // Output:
+      // map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
+}
+```
+
+## `Clone`
+
+- 说明： `clone` 返回一个值为当前 `tree` 值的副本的新 `BTree`。
+
+- 格式：
+
+```go
+Clone() *BTree
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Clone() {
+      b := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          b.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      tree := b.Clone()
+
+      fmt.Println(tree.Map())
+      fmt.Println(tree.Size())
+
+      // Output:
+      // map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
+      // 6
+}
+```
+
+## `Set`
+
+- 说明： `Set` 为 `tree` 设置 `key/value`。
+
+- 格式：
+
+```go
+Set(key interface{}, value interface{})
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Set() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Map())
+      fmt.Println(tree.Size())
+
+      // Output:
+      // map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
+      // 6
+}
+```
+
+## `Sets`
+
+- 说明： `Sets` 为 `tree` 批量设置 `key/value`。
+
+- 格式：
+
+```go
+Sets(data map[interface{}]interface{})
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Sets() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+
+      tree.Sets(map[interface{}]interface{}{
+          "key1": "val1",
+          "key2": "val2",
+      })
+
+      fmt.Println(tree.Map())
+      fmt.Println(tree.Size())
+
+      // Output:
+      // map[key1:val1 key2:val2]
+      // 2
+}
+```
+
+## `Get`
+
+- 说明： `Get` 返回参数 `key` 对应的值 `value`，如 `key` 不存在，则返回 `Nil`。
+
+- 格式：
+
+```go
+Get(key interface{}) (value interface{})
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Get() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Get("key1"))
+      fmt.Println(tree.Get("key10"))
+
+      // Output:
+      // val1
+      // <nil>
+}
+```
+
+## `GetOrSet`
+
+- 说明： `GetOrSet` 如 `key` 存在，则返回 `value`，如 `key` 不存在，使用 `key` 和 `value` 设置键值，然后返回该值。
+
+- 格式：
+
+```go
+GetOrSet(key interface{}, value interface{}) interface{}
+```
+
+- 示例：
+
+```go
+func ExampleBTree_GetOrSet() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.GetOrSet("key1", "newVal1"))
+      fmt.Println(tree.GetOrSet("key6", "val6"))
+
+      // Output:
+      // val1
+      // val6
+}
+```
+
+## `GetOrSetFunc`
+
+- 说明： `GetOrSetFunc` 如 `key` 存在，则返回 `value`，如 `key` 不存在，使用 `key` 和 `func f` 的返回值设置键值，然后返回该值。
+
+- 格式：
+
+```go
+GetOrSetFunc(key interface{}, f func() interface{}) interface{}
+```
+
+- 示例：
+
+```go
+func ExampleBTree_GetOrSetFunc() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.GetOrSetFunc("key1", func() interface{} {
+          return "newVal1"
+      }))
+      fmt.Println(tree.GetOrSetFunc("key6", func() interface{} {
+          return "val6"
+      }))
+
+      // Output:
+      // val1
+      // val6
+}
+```
+
+## `GetOrSetFuncLock`
+
+- 说明： `GetOrSetFunc` 如 `key` 存在，则返回 `value`，如 `key` 不存在，使用 `key` 和 `func f` 的返回值设置键值，然后返回该值。
+
+- 注意： `GetOrSetFuncLock` 与 `GetOrSetFunc` 函数的不同之处在于它在写锁中执行函数 `f`。
+- 格式：
+
+```go
+GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}
+```
+
+- 示例：
+
+```go
+func ExampleBTree_GetOrSetFuncLock() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.GetOrSetFuncLock("key1", func() interface{} {
+          return "newVal1"
+      }))
+      fmt.Println(tree.GetOrSetFuncLock("key6", func() interface{} {
+          return "val6"
+      }))
+
+      // Output:
+      // val1
+      // val6
+}
+```
+
+## `GetVar`
+
+- 说明： `GetVar` 根据键名 `key` 查询并返回对应的键值，类型为 `*gvar.Var`。
+
+- 注意：返回的 `gvar.Var` 是非并发安全的。
+- 格式：
+
+```go
+GetVar(key interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+func ExampleBTree_GetVar() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.GetVar("key1").String())
+
+      // Output:
+      // val1
+}
+```
+
+## `GetVarOrSet`
+
+- 说明： `GetVarOrSet` 使用 `GetOrSet` 的结果返回，类型为 `*gvar.Var`。
+
+- 注意：返回的 `gvar.Var` 是非并发安全的。
+- 格式：
+
+```go
+GetVarOrSet(key interface{}, value interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+func ExampleBTree_GetVarOrSet() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.GetVarOrSet("key1", "newVal1"))
+      fmt.Println(tree.GetVarOrSet("key6", "val6"))
+
+      // Output:
+      // val1
+      // val6
+}
+```
+
+## `GetVarOrSetFunc`
+
+- 说明： `GetVarOrSetFunc` 使用 `GetOrSetFunc` 的结果返回，类型为 `*gvar.Var`。
+- 注意：返回的 `gvar.Var` 是非并发安全的。
+- 格式：
+
+```go
+GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+func ExampleBTree_GetVarOrSetFunc() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.GetVarOrSetFunc("key1", func() interface{} {
+          return "newVal1"
+      }))
+      fmt.Println(tree.GetVarOrSetFunc("key6", func() interface{} {
+          return "val6"
+      }))
+
+      // Output:
+      // val1
+      // val6
+}
+```
+
+## `GetVarOrSetFuncLock`
+
+- 说明： `GetVarOrSetFuncLock` 使用 `GetOrSetFuncLock` 的结果返回，类型为 `*gvar.Var`。
+
+- 注意：返回的 `gvar.Var` 是非并发安全的。
+- 格式：
+
+```go
+GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+func ExampleBTree_GetVarOrSetFuncLock() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.GetVarOrSetFuncLock("key1", func() interface{} {
+          return "newVal1"
+      }))
+      fmt.Println(tree.GetVarOrSetFuncLock("key6", func() interface{} {
+          return "val6"
+      }))
+
+      // Output:
+      // val1
+      // val6
+}
+```
+
+## `SetIfNotExist`
+
+- 说明：如果 `key` 不存在，则 `SetIfNotExist` 为 `map` 设置值键值对 `key/value`，并且返回 `true`。如果 `key` 存在，则返回 `false`，而 `value` 将被忽略。
+
+- 格式：
+
+```go
+SetIfNotExist(key interface{}, value interface{}) bool
+```
+
+- 示例：
+
+```go
+func ExampleBTree_SetIfNotExist() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.SetIfNotExist("key1", "newVal1"))
+      fmt.Println(tree.SetIfNotExist("key6", "val6"))
+
+      // Output:
+      // false
+      // true
+}
+```
+
+## `SetIfNotExistFunc`
+
+- 说明：如果 `key` 不存在，则 `SetIfNotExistFunc` 设置值为函数 `f` 的返回值，并且返回 `true`。如果 `key` 存在，则返回 `false`，并且 `value` 将被忽略。
+
+- 格式：
+
+```go
+SetIfNotExistFunc(key interface{}, f func() interface{}) bool
+```
+
+- 示例：
+
+```go
+func ExampleBTree_SetIfNotExistFunc() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.SetIfNotExistFunc("key1", func() interface{} {
+          return "newVal1"
+      }))
+      fmt.Println(tree.SetIfNotExistFunc("key6", func() interface{} {
+          return "val6"
+      }))
+
+      // Output:
+      // false
+      // true
+}
+```
+
+## `SetIfNotExistFuncLock`
+
+- 说明：如果 `key` 不存在，则 `SetIfNotExistFunc` 设置值为 `func c` 的返回值，然后返回 `true`。如果 `key` 存在，则返回 `false`，而 `value` 将被忽略。
+
+- `SetIfNotExistFuncLock` 与 `SetIfNotExistFunc` 函数的不同之处在于它在 `mutex.Lock` 中执行函数 `f`。
+- 格式：
+
+```go
+SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool
+```
+
+- 示例：
+
+```go
+func ExampleBTree_SetIfNotExistFuncLock() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.SetIfNotExistFuncLock("key1", func() interface{} {
+          return "newVal1"
+      }))
+      fmt.Println(tree.SetIfNotExistFuncLock("key6", func() interface{} {
+          return "val6"
+      }))
+
+      // Output:
+      // false
+      // true
+}
+```
+
+## `Contains`
+
+- 说明： `Contains` 检查 `key` 在 `tree` 中是否存在。如果 `key` 存在，则返回 `true`，否则返回 `false`。
+
+- 格式：
+
+```go
+Contains(key interface{}) bool
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Contains() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Contains("key1"))
+      fmt.Println(tree.Contains("key6"))
+
+      // Output:
+      // true
+      // false
+}
+```
+
+## `Remove`
+
+- 说明：按给定的 `key` 从 `tree` 中删除 `value`，并返回此删除的 `value`。
+
+- 格式：
+
+```go
+Remove(key interface{}) (value interface{})
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Remove() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Remove("key1"))
+      fmt.Println(tree.Remove("key6"))
+      fmt.Println(tree.Map())
+
+      // Output:
+      // val1
+      // <nil>
+      // map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]
+}
+```
+
+## `Removes`
+
+- 说明： `Removes` 按给定的 `key` 批量删除 `tree` 的 `value`。
+
+- 格式：
+
+```go
+Removes(keys []interface{})
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Removes() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      removeKeys := make([]interface{}, 2)
+      removeKeys = append(removeKeys, "key1")
+      removeKeys = append(removeKeys, "key6")
+
+      tree.Removes(removeKeys)
+
+      fmt.Println(tree.Map())
+
+      // Output:
+      // map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]
+}
+```
+
+## `IsEmpty`
+
+- 说明： `IsEmpty` 检查 `tree` 是否为空。如果 `tree` 为空，则返回 `true`，否则返回 `false`。
+
+- 格式：
+
+```go
+IsEmpty() bool
+```
+
+- 示例：
+
+```go
+func ExampleBTree_IsEmpty() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+
+      fmt.Println(tree.IsEmpty())
+
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.IsEmpty())
+
+      // Output:
+      // true
+      // false
+}
+```
+
+## `Size`
+
+- 说明： `Size` 返回 `tree` 的大小。
+
+- 格式：
+
+```go
+Size() int
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Size() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+
+      fmt.Println(tree.Size())
+
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Size())
+
+      // Output:
+      // 0
+      // 6
+}
+```
+
+## `Keys`
+
+- 说明： `Keys` 按升序返回所有的 `key`。
+
+- 格式：
+
+```go
+Keys() []interface{}
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Keys() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 6; i > 0; i-- {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Keys())
+
+      // Output:
+      // [key1 key2 key3 key4 key5 key6]
+}
+```
+
+## `Values`
+
+- 说明： `Values` 按 `key` 的升序返回所有的 `value`。
+
+- 格式：
+
+```go
+Values() []interface{}
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Values() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 6; i > 0; i-- {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Values())
+
+      // Output:
+      // [val1 val2 val3 val4 val5 val6]
+}
+```
+
+## `Map`
+
+- 说明： `Map` 以 `map` 的形式返回所有的 `key/value`。
+
+- 格式：
+
+```go
+Map() map[interface{}]interface{}
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Map() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Map())
+
+      // Output:
+      // map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
+}
+```
+
+## `MapStrAny`
+
+- 说明： `MapStrAny` 以 `map[string]interface{}` 的形式返回所有的 `key/value`。
+
+- 格式：
+
+```go
+MapStrAny() map[string]interface{}
+```
+
+- 示例：
+
+```go
+func ExampleBTree_MapStrAny() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set(1000+i, "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.MapStrAny())
+
+      // Output:
+      // map[1000:val0 1001:val1 1002:val2 1003:val3 1004:val4 1005:val5]
+}
+```
+
+## `Clear`
+
+- 说明： `Clear` 删除 `tree` 的所有数据。
+
+- 格式：
+
+```go
+Clear()
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Clear() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set(1000+i, "val"+gconv.String(i))
+      }
+      fmt.Println(tree.Size())
+
+      tree.Clear()
+      fmt.Println(tree.Size())
+
+      // Output:
+      // 6
+      // 0
+}
+```
+
+## `Replace`
+
+- 说明： `Replace` 用类型为 `map[interface{}]interface{}` 的 `data` 替换 `tree` 的 `key/value`。
+
+- 格式：
+
+```go
+Replace(data map[interface{}]interface{})
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Replace() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Map())
+
+      data := map[interface{}]interface{}{
+          "newKey0": "newVal0",
+          "newKey1": "newVal1",
+          "newKey2": "newVal2",
+      }
+
+      tree.Replace(data)
+
+      fmt.Println(tree.Map())
+
+      // Output:
+      // map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
+      // map[newKey0:newVal0 newKey1:newVal1 newKey2:newVal2]
+}
+```
+
+## `Height`
+
+- 说明： `Height` 返回 `tree` 的高度。
+
+- 格式：
+
+```go
+Height() int
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Height() {
+      tree := gtree.NewBTree(3, gutil.ComparatorInt)
+      for i := 0; i < 100; i++ {
+          tree.Set(i, i)
+      }
+      fmt.Println(tree.Height())
+
+      // Output:
+      // 6
+}
+```
+
+## `Left`
+
+- 说明： `Left` 返回最左边（最小）的类型为 `*BTreeEntry` 的 `node`，如果 `tree` 是空的，则返回 `nil`。
+
+- 格式：
+
+```go
+Left() *BTreeEntry
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Left() {
+      tree := gtree.NewBTree(3, gutil.ComparatorInt)
+      for i := 1; i < 100; i++ {
+          tree.Set(i, i)
+      }
+      fmt.Println(tree.Left().Key, tree.Left().Value)
+
+      emptyTree := gtree.NewBTree(3, gutil.ComparatorInt)
+      fmt.Println(emptyTree.Left())
+
+      // Output:
+      // 1 1
+      // <nil>
+}
+```
+
+## `Right`
+
+- 说明： `Left` 返回最右边（最大）的类型为 `*BTreeEntry` 的 `node`，如果 `tree` 是空的，则返回 `nil`。
+
+- 格式：
+
+```go
+Right() *BTreeEntry
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Right() {
+      tree := gtree.NewBTree(3, gutil.ComparatorInt)
+      for i := 1; i < 100; i++ {
+          tree.Set(i, i)
+      }
+      fmt.Println(tree.Right().Key, tree.Right().Value)
+
+      emptyTree := gtree.NewBTree(3, gutil.ComparatorInt)
+      fmt.Println(emptyTree.Left())
+
+      // Output:
+      // 99 99
+      // <nil>
+}
+```
+
+## `String`
+
+- 说明： `String` 返回 `tree` 的 `node` 显示（用于调试）。
+
+- 格式：
+
+```go
+String() string
+```
+
+- 示例：
+
+```go
+func ExampleBTree_String() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.String())
+
+      // Output:
+      // key0
+      // key1
+      //     key2
+      // key3
+      //     key4
+      //     key5
+}
+```
+
+## `Search`
+
+- 说明： `Search` 使用参数 `key` 搜索 `tree`。如果找到 `key`，则返回其对应的键值，并且返回参数 `found` 为 `true`，否则为 `false`。
+
+- 格式：
+
+```go
+Search(key interface{}) (value interface{}, found bool)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Search() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      fmt.Println(tree.Search("key0"))
+      fmt.Println(tree.Search("key6"))
+
+      // Output:
+      // val0 true
+      // <nil> false
+}
+```
+
+## `Print`
+
+- 说明： `Print` 将 `tree` 打印到标准输出。
+
+- 格式：
+
+```go
+Print()
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Print() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      tree.Print()
+
+      // Output:
+      // key0
+      // key1
+      //     key2
+      // key3
+      //     key4
+      //     key5
+}
+```
+
+## `Iterator`
+
+- 说明： `Iterator` 等同于 `IteratorAsc` 。
+
+- 格式：
+
+```go
+Iterator(f func(key, value interface{}) bool)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_Iterator() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 10; i++ {
+          tree.Set(i, 10-i)
+      }
+
+      var totalKey, totalValue int
+      tree.Iterator(func(key, value interface{}) bool {
+          totalKey += key.(int)
+          totalValue += value.(int)
+
+          return totalValue < 20
+      })
+
+      fmt.Println("totalKey:", totalKey)
+      fmt.Println("totalValue:", totalValue)
+
+      // Output:
+      // totalKey: 3
+      // totalValue: 27
+}
+```
+
+## `IteratorFrom`
+
+- 说明： `IteratorFrom` 等同于 `IteratorAscFrom` 。
+
+- 格式：
+
+```go
+IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_IteratorFrom() {
+      m := make(map[interface{}]interface{})
+      for i := 1; i <= 5; i++ {
+          m[i] = i * 10
+      }
+      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
+
+      tree.IteratorFrom(1, true, func(key, value interface{}) bool {
+          fmt.Println("key:", key, ", value:", value)
+          return true
+      })
+
+      // Output:
+      // key: 1 , value: 10
+      // key: 2 , value: 20
+      // key: 3 , value: 30
+      // key: 4 , value: 40
+      // key: 5 , value: 50
+}
+```
+
+## `IteratorAsc`
+
+- 说明： `IteratorAsc` 使用自定义回调函数 `f` 以只读方式按升序迭代 `tree`。如果 `f` 返回 `true`，则继续迭代，返回 `false` 则停止。
+
+- 格式：
+
+```go
+IteratorAsc(f func(key, value interface{}) bool)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_IteratorAsc() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 10; i++ {
+          tree.Set(i, 10-i)
+      }
+
+      tree.IteratorAsc(func(key, value interface{}) bool {
+          fmt.Println("key:", key, ", value:", value)
+          return true
+      })
+
+      // Output:
+      // key: 0 , value: 10
+      // key: 1 , value: 9
+      // key: 2 , value: 8
+      // key: 3 , value: 7
+      // key: 4 , value: 6
+      // key: 5 , value: 5
+      // key: 6 , value: 4
+      // key: 7 , value: 3
+      // key: 8 , value: 2
+      // key: 9 , value: 1
+}
+```
+
+## `IteratorAscFrom`
+
+- 说明： `IteratorAscFrom` 使用自定义回调函数 `f` 以只读方式按升序迭代 `tree`。参数 `key` 指定从哪个 `key` 开始迭代。参数 `match` 为 `true` 时，从 `key` 完全匹配时开始迭代，否则使用索引搜索迭代。如果 `f` 返回 `true`，则继续迭代，返回 `false` 则停止。
+
+- 格式：
+
+```go
+IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_IteratorAscFrom_Normal() {
+      m := make(map[interface{}]interface{})
+      for i := 1; i <= 5; i++ {
+          m[i] = i * 10
+      }
+      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
+
+      tree.IteratorAscFrom(1, true, func(key, value interface{}) bool {
+          fmt.Println("key:", key, ", value:", value)
+          return true
+      })
+
+      // Output:
+      // key: 1 , value: 10
+      // key: 2 , value: 20
+      // key: 3 , value: 30
+      // key: 4 , value: 40
+      // key: 5 , value: 50
+}
+```
+
+```go
+func ExampleBTree_IteratorAscFrom_NoExistKey() {
+      m := make(map[interface{}]interface{})
+      for i := 1; i <= 5; i++ {
+          m[i] = i * 10
+      }
+      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
+
+      tree.IteratorAscFrom(0, true, func(key, value interface{}) bool {
+          fmt.Println("key:", key, ", value:", value)
+          return true
+      })
+
+      // Output:
+}
+```
+
+```go
+func ExampleBTree_IteratorAscFrom_NoExistKeyAndMatchFalse() {
+      m := make(map[interface{}]interface{})
+      for i := 1; i <= 5; i++ {
+          m[i] = i * 10
+      }
+      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
+
+      tree.IteratorAscFrom(0, false, func(key, value interface{}) bool {
+          fmt.Println("key:", key, ", value:", value)
+          return true
+      })
+
+      // Output:
+      // key: 1 , value: 10
+      // key: 2 , value: 20
+      // key: 3 , value: 30
+      // key: 4 , value: 40
+      // key: 5 , value: 50
+}
+```
+
+## `IteratorDesc`
+
+- 说明： `IteratorDesc` 使用自定义回调函数 `f` 以只读方式按降序迭代 `tree`。如果 `f` 返回 `true`，则继续迭代，返回 `false` 则停止。
+
+- 格式：
+
+```go
+IteratorDesc(f func(key, value interface{}) bool)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_IteratorDesc() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 10; i++ {
+          tree.Set(i, 10-i)
+      }
+
+      tree.IteratorDesc(func(key, value interface{}) bool {
+          fmt.Println("key:", key, ", value:", value)
+          return true
+      })
+
+      // Output:
+      // key: 9 , value: 1
+      // key: 8 , value: 2
+      // key: 7 , value: 3
+      // key: 6 , value: 4
+      // key: 5 , value: 5
+      // key: 4 , value: 6
+      // key: 3 , value: 7
+      // key: 2 , value: 8
+      // key: 1 , value: 9
+      // key: 0 , value: 10
+}
+```
+
+## `IteratorDescFrom`
+
+- 说明： `IteratorDescFrom` 使用自定义回调函数 `f` 以只读方式按降序迭代 `tree`。参数 `key` 指定从哪个 `key` 开始迭代。参数 `match` 为 `true` 时，从 `key` 完全匹配时开始迭代，否则使用索引搜索迭代。如果 `f` 返回 `true`，则继续迭代，返回 `false` 则停止。
+
+- 格式：
+
+```go
+IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_IteratorDescFrom() {
+      m := make(map[interface{}]interface{})
+      for i := 1; i <= 5; i++ {
+          m[i] = i * 10
+      }
+      tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
+
+      tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
+          fmt.Println("key:", key, ", value:", value)
+          return true
+      })
+
+      // Output:
+      // key: 5 , value: 50
+      // key: 4 , value: 40
+      // key: 3 , value: 30
+      // key: 2 , value: 20
+      // key: 1 , value: 10
+}
+```
+
+## `MarshalJson`
+
+- 说明： `MarshalJSON` 实现 `json.Marshal` 的接口。
+
+- 格式：
+
+```go
+MarshalJSON() ([]byte, error)
+```
+
+- 示例：
+
+```go
+func ExampleBTree_MarshalJSON() {
+      tree := gtree.NewBTree(3, gutil.ComparatorString)
+      for i := 0; i < 6; i++ {
+          tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
+      }
+
+      bytes, err := json.Marshal(tree)
+      if err == nil {
+          fmt.Println(gconv.String(bytes))
+      }
+
+      // Output:
+      // {"key0":"val0","key1":"val1","key2":"val2","key3":"val3","key4":"val4","key5":"val5"}
+}
+```