数组类

package
v0.0.0-...-2910145 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 14, 2024 License: MIT Imports: 15 Imported by: 0

Documentation

Overview

包garray提供了最常用的数组容器，同时支持并发安全/不安全切换功能。

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Array 

type Array struct {
	// contains filtered or unexported fields
}

Array 是一个具有丰富特性的 Go 语言数组。 它包含一个并发安全/不安全切换开关，该开关应在初始化时设置，并且之后不可更改。

func NewArray别名 

func NewArray别名(并发安全 ...bool) *Array

NewArray 是 New 的别名，请参阅 New。

func NewFromCopy别名 

func NewFromCopy别名(数组 []interface{}, 并发安全 ...bool) *Array

NewFromCopy 是 NewArrayFromCopy 的别名。 请参阅 NewArrayFromCopy。

func NewFrom别名 

func NewFrom别名(数组 []interface{}, 并发安全 ...bool) *Array

NewFrom 是 NewArrayFrom 的别名。 请参阅 NewArrayFrom。

func X创建 

func X创建(并发安全 ...bool) *Array

New 创建并返回一个空数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建并从数组 

func X创建并从数组(数组 []interface{}, 并发安全 ...bool) *Array

NewArrayFrom 通过给定的切片 `array` 创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建并从数组复制 

func X创建并从数组复制(数组 []interface{}, 并发安全 ...bool) *Array

NewArrayFromCopy 通过复制给定切片 `array` 创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建并按大小 

func X创建并按大小(大小 int, 上限 int, 并发安全 ...bool) *Array

NewArraySize 根据给定的大小和容量创建并返回一个数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建并按范围 

func X创建并按范围(起点, 终点, 步长 int, 并发安全 ...bool) *Array

NewArrayRange 根据指定的范围从 `start` 到 `end` 并以步长值 `step` 创建并返回一个数组。

func (*Array) Append别名 

func (a *Array) Append别名(值 ...interface{}) *Array

Append 是 PushRight 的别名，请参阅 PushRight。

func (*Array) DeepCopy 

func (a *Array) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (Array) MarshalJSON 

func (a Array) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。 注意：此处接收者不使用指针。

func (*Array) String 

func (a *Array) String() string

String 方法将当前数组以字符串形式返回，其实现方式类似于 json.Marshal。

func (*Array) UnmarshalJSON 

func (a *Array) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

func (*Array) UnmarshalValue 

func (a *Array) UnmarshalValue(value interface{}) error

UnmarshalValue 实现了一个接口，该接口用于为数组设置任意类型的值。

func (*Array) X倒排序 

func (a *Array) X倒排序() *Array

Reverse 将数组元素按逆序排列生成新数组。

func (*Array) X入栈右 

func (a *Array) X入栈右(值 ...interface{}) *Array

PushRight将一个或多个元素推送到数组的末尾。 它等同于Append。

func (*Array) X入栈左 

func (a *Array) X入栈左(值 ...interface{}) *Array

PushLeft 将一个或多个元素推送到数组的起始位置。

func (*Array) X出栈右 

func (a *Array) X出栈右() (值 interface{}, 成功 bool)

PopRight从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则`found`为false。

func (*Array) X出栈右多个 

func (a *Array) X出栈右多个(数量 int) []interface{}

PopRights 从数组末尾弹出并返回 `size` 个元素。

func (*Array) X出栈左 

func (a *Array) X出栈左() (值 interface{}, 成功 bool)

PopLeft 从数组开头弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*Array) X出栈左多个 

func (a *Array) X出栈左多个(数量 int) []interface{}

PopLefts 从数组开头弹出并返回 `size` 个元素。

func (*Array) X出栈随机 

func (a *Array) X出栈随机() (值 interface{}, 成功 bool)

PopRand 随机地从数组中弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*Array) X出栈随机多个 

func (a *Array) X出栈随机多个(数量 int) []interface{}

PopRands 随机地从数组中弹出并返回 `size` 个元素。

func (*Array) X分割 

func (a *Array) X分割(数量 int) [][]interface{}

Chunk 函数将一个数组分割成多个子数组， 每个子数组的大小由参数 `size` 确定。 最后一个子数组可能包含少于 size 个元素。

func (*Array) X删除 

func (a *Array) X删除(索引 int) (值 interface{}, 成功 bool)

Remove 通过索引移除一个元素。 如果给定的 `index` 超出了数组范围，`found` 将为 false。

func (*Array) X删除值 

func (a *Array) X删除值(值 interface{}) bool

RemoveValue 通过值移除一个元素。 若在数组中找到该值，则返回 true，否则（未找到时）返回 false。

func (*Array) X删除多个值 

func (a *Array) X删除多个值(值 ...interface{})

RemoveValues 通过 `values` 移除多个项目。

func (*Array) X删除所有nil 

func (a *Array) X删除所有nil() *Array

FilterNil 移除数组中所有的 nil 值。

func (*Array) X删除所有空值 

func (a *Array) X删除所有空值() *Array

FilterEmpty 用于移除数组中所有空值。 下列值被认为是空值：0, nil, false, "", 以及长度为0的slice、map或chan。

func (*Array) X去重 

func (a *Array) X去重() *Array

Unique 函数用于对数组去重，清除重复的元素。 示例：[1,1,2,3,2] -> [1,2,3]

func (*Array) X取any数组 

func (a *Array) X取any数组() []interface{}

Interfaces 函数将当前数组转换为 []interface{} 类型并返回。

func (*Array) X取值 

func (a *Array) X取值(索引 int) (值 interface{})

At通过指定的索引返回值。 如果给定的`index`超出数组范围，它将返回`nil`。

func (*Array) X取值2 

func (a *Array) X取值2(索引 int) (值 interface{}, 成功 bool)

Get 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，那么 `found` 将为 false。

func (*Array) X取值随机 

func (a *Array) X取值随机() (值 interface{}, 成功 bool)

Rand 随机地从数组中返回一个元素（不删除）。

func (*Array) X取值随机多个 

func (a *Array) X取值随机多个(数量 int) []interface{}

Rands 随机返回数组中的 `size` 个元素（不删除）。

func (*Array) X取切片 

func (a *Array) X取切片() []interface{}

Slice 返回数组的基础数据。 注意，如果它在并发安全的使用场景下，会返回基础数据的一个副本， 否则，则返回指向基础数据的指针。

func (*Array) X取切片并按数量 

func (a *Array) X取切片并按数量(起点 int, 数量 ...int) []interface{}

SubSlice 返回数组中由 `offset` 和 `size` 参数指定的元素子序列，并将其作为切片。 若在并发安全场景下使用，返回该切片的副本；否则返回指向切片的指针。

如果 offset 非负，则序列从数组该偏移位置开始。 如果 offset 为负，则序列从数组末尾向前偏移该距离的位置开始。

如果提供了 length 并且为正数，则序列将包含最多该数量的元素。 若数组长度小于 length，则序列仅包含数组中可获得的元素。 如果 length 为负数，则序列将在数组末尾向前停在该距离的位置。 如果未提供 length，则序列包含从 offset 开始直到数组末尾的所有元素。

若有任何可能穿越数组左边界的情况，函数将失败。

func (*Array) X取切片并按范围 

func (a *Array) X取切片并按范围(起点 int, 终点 ...int) []interface{}

Range 函数通过范围选择并返回数组中的元素，类似于 array[start:end]。 注意：在并发安全的使用场景下，它会返回一个原数据的副本；否则，返回的是底层数据的指针。

如果 `end` 为负数，则偏移量将从数组末尾开始计算。 如果省略了 `end`，则序列将包含从 start 开始直到数组末尾的所有元素。

func (*Array) X取副本 

func (a *Array) X取副本() (新数组 *Array)

Clone 返回一个新的数组，它是当前数组的一个副本。

func (*Array) X取文本 

func (a *Array) X取文本() string

func (*Array) X取长度 

func (a *Array) X取长度() int

Len 返回数组的长度。

func (*Array) X合并 

func (a *Array) X合并(数组 interface{}) *Array

Merge 将`array`合并到当前数组中。 参数`array`可以是任何garray类型或切片类型。 Merge 和 Append 的区别在于，Append 仅支持特定类型的切片作为参数， 而 Merge 支持更多类型的参数。

func (*Array) X填充 

func (a *Array) X填充(起点 int, 填充数量 int, 值 interface{}) error

Fill 用 `value` 值填充数组，填充 num 个条目， 键（索引）从 `startIndex` 参数开始。

func (*Array) X填满 

func (a *Array) X填满(总数量 int, 值 interface{}) *Array

Pad 通过 `value` 值对数组进行填充，以达到指定长度。 如果 size 为正数，则在数组右侧进行填充；若为负数，则在左侧填充。 若 `size` 的绝对值小于或等于数组的长度，则不进行填充操作。

func (*Array) X排序并带函数 

func (a *Array) X排序并带函数(回调函数 func(v1, v2 interface{}) bool) *Array

SortFunc 通过自定义函数 `less` 对数组进行排序。

func (*Array) X插入前面 

func (a *Array) X插入前面(索引 int, 值 ...interface{}) error

InsertBefore 将 `values` 插入到 `index` 之前的位置。

func (*Array) X插入后面 

func (a *Array) X插入后面(索引 int, 值 ...interface{}) error

InsertAfter 在`index`之后插入`values`。

func (*Array) X是否为空 

func (a *Array) X是否为空() bool

IsEmpty 检查数组是否为空。

func (*Array) X是否存在 

func (a *Array) X是否存在(值 interface{}) bool

Contains 检查某个值是否存在于数组中。

func (*Array) X替换 

func (a *Array) X替换(数组 []interface{}) *Array

Replace 从数组起始位置开始，使用给定的`array`替换原有数组元素。

func (*Array) X查找 

func (a *Array) X查找(值 interface{}) int

Search 在数组中通过 `value` 进行搜索，返回 `value` 的索引， 若不存在，则返回 -1。

func (*Array) X求和 

func (a *Array) X求和() (值 int)

Sum 返回数组中所有值的和。

func (*Array) X清空 

func (a *Array) X清空() *Array

清空删除当前数组中的所有元素。

func (*Array) X统计 

func (a *Array) X统计() map[interface{}]int

CountValues 计算数组中所有值出现的次数。

func (*Array) X设置值 

func (a *Array) X设置值(索引 int, 值 interface{}) error

Set将值设置到指定的索引位置。

func (*Array) X设置数组 

func (a *Array) X设置数组(数组 []interface{}) *Array

SetArray 将底层的切片数组设置为给定的 `array`。

func (*Array) X连接 

func (a *Array) X连接(连接符 string) string

Join 通过字符串 `glue` 连接数组元素。

func (*Array) X遍历 

func (a *Array) X遍历(回调函数 func(k int, v interface{}) bool)

Iterator 是 IteratorAsc 的别名。

func (*Array) X遍历修改 

func (a *Array) X遍历修改(回调函数 func(值 interface{}) interface{}) *Array

Walk 对数组中的每一项应用用户提供的函数 `f`。

func (*Array) X遍历删除 

func (a *Array) X遍历删除(回调函数 func(索引 int, 值 interface{}) bool) *Array

Filter 对数组进行迭代，并通过自定义回调函数进行元素过滤。 如果回调函数 `filter` 返回 true，则从数组中移除该元素； 否则不做任何处理并继续迭代。

func (*Array) X遍历升序 

func (a *Array) X遍历升序(回调函数 func(k int, v interface{}) bool)

IteratorAsc 以升序遍历给定数组，并使用回调函数 `f` 进行只读操作。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止遍历。

func (*Array) X遍历并写锁定 

func (a *Array) X遍历并写锁定(回调函数 func(数组 []interface{})) *Array

LockFunc 通过回调函数`f`进行写入锁定。

func (*Array) X遍历并读锁定 

func (a *Array) X遍历并读锁定(回调函数 func(数组 []interface{})) *Array

RLockFunc 通过回调函数`f`锁定读取操作。

func (*Array) X遍历降序 

func (a *Array) X遍历降序(回调函数 func(k int, v interface{}) bool)

IteratorDesc 函数以降序遍历给定的数组，并使用指定回调函数 `f` 进行只读操作。 若 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

func (*Array) X随机排序 

func (a *Array) X随机排序() *Array

Shuffle 随机地对数组进行洗牌。

type IntArray 

type IntArray struct {
	// contains filtered or unexported fields
}

IntArray 是一个具有丰富功能的 Go 语言整数数组。 它包含一个并发安全/不安全切换开关，应在初始化时设置，并且此后不可更改。

func X创建整数 

func X创建整数(并发安全 ...bool) *IntArray

NewIntArray 创建并返回一个空数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建整数并从数组 

func X创建整数并从数组(数组 []int, 并发安全 ...bool) *IntArray

NewIntArrayFrom 根据给定的切片 `array` 创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建整数并从数组复制 

func X创建整数并从数组复制(数组 []int, 并发安全 ...bool) *IntArray

NewIntArrayFromCopy 通过复制给定切片 `array` 创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建整数并按大小 

func X创建整数并按大小(大小 int, 上限 int, 并发安全 ...bool) *IntArray

NewIntArraySize 根据给定的大小和容量创建并返回一个数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建整数并按范围 

func X创建整数并按范围(起点, 终点, 步长 int, 并发安全 ...bool) *IntArray

NewIntArrayRange 根据指定范围从 `start` 到 `end` 以步长值 `step` 创建并返回一个整数数组。

func (*IntArray) Append别名 

func (a *IntArray) Append别名(值 ...int) *IntArray

Append 是 PushRight 的别名，请参阅 PushRight。

func (*IntArray) DeepCopy 

func (a *IntArray) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (IntArray) MarshalJSON 

func (a IntArray) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。 注意：此处接收者不使用指针。

Example 
type Student struct {
	Id     int
	Name   string
	Scores 数组类.IntArray
}
var array 数组类.IntArray
array.X设置数组(g.SliceInt别名{98, 97, 96})
s := Student{
	Id:     1,
	Name:   "john",
	Scores: array,
}
b, _ := json.Marshal(s)
fmt.Println(string(b))

Output:

{"Id":1,"Name":"john","Scores":[98,97,96]}

func (*IntArray) String 

func (a *IntArray) String() string

String 方法将当前数组以字符串形式返回，其实现方式类似于 json.Marshal。

Example 
s := 数组类.X创建整数并从数组(g.SliceInt别名{10, 20, 15, 30, 40, 50, 60})
fmt.Println(s)
fmt.Println(s.String())

Output:

[10,20,15,30,40,50,60]
[10,20,15,30,40,50,60]

func (*IntArray) UnmarshalJSON 

func (a *IntArray) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
b := []byte(`{"Id":1,"Name":"john","Scores":[98,96,97]}`)
type Student struct {
	Id     int
	Name   string
	Scores *数组类.IntArray
}
s := Student{}
json.Unmarshal(b, &s)
fmt.Println(s)

Output:

{1 john [98,96,97]}

func (*IntArray) UnmarshalValue 

func (a *IntArray) UnmarshalValue(value interface{}) error

UnmarshalValue 实现了一个接口，该接口用于为数组设置任意类型的值。

Example 
type Student struct {
	Name   string
	Scores *数组类.IntArray
}

var s *Student
转换类.Struct(g.Map{
	"name":   "john",
	"scores": g.SliceInt别名{96, 98, 97},
}, &s)
fmt.Println(s)

Output:

&{john [96,98,97]}

func (*IntArray) X倒排序 

func (a *IntArray) X倒排序() *IntArray

Reverse 将数组元素按逆序排列生成新数组。

func (*IntArray) X入栈右 

func (a *IntArray) X入栈右(值 ...int) *IntArray

PushRight将一个或多个元素推送到数组的末尾。 它等同于Append。

func (*IntArray) X入栈左 

func (a *IntArray) X入栈左(值 ...int) *IntArray

PushLeft 将一个或多个元素推送到数组的起始位置。

func (*IntArray) X出栈右 

func (a *IntArray) X出栈右() (值 int, 成功 bool)

PopRight从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则`found`为false。

func (*IntArray) X出栈右多个 

func (a *IntArray) X出栈右多个(数量 int) []int

PopRights 从数组末尾弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回nil。

func (*IntArray) X出栈左 

func (a *IntArray) X出栈左() (值 int, 成功 bool)

PopLeft 从数组开头弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*IntArray) X出栈左多个 

func (a *IntArray) X出栈左多个(数量 int) []int

PopLefts 从数组开头弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，则返回nil。

func (*IntArray) X出栈随机 

func (a *IntArray) X出栈随机() (值 int, 成功 bool)

PopRand 随机地从数组中弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*IntArray) X出栈随机多个 

func (a *IntArray) X出栈随机多个(数量 int) []int

PopRands 随机地从数组中弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回 nil。

func (*IntArray) X分割 

func (a *IntArray) X分割(数量 int) [][]int

Chunk 函数将一个数组分割成多个子数组， 每个子数组的大小由参数 `size` 确定。 最后一个子数组可能包含少于 size 个元素。

func (*IntArray) X删除 

func (a *IntArray) X删除(索引 int) (值 int, 成功 bool)

Remove 通过索引移除一个元素。 如果给定的 `index` 超出了数组范围，`found` 将为 false。

func (*IntArray) X删除值 

func (a *IntArray) X删除值(值 int) bool

RemoveValue 通过值移除一个元素。 若在数组中找到该值，则返回 true，否则（未找到时）返回 false。

func (*IntArray) X删除多个值 

func (a *IntArray) X删除多个值(值 ...int)

RemoveValues 通过 `values` 移除多个项目。

func (*IntArray) X删除所有零值 

func (a *IntArray) X删除所有零值() *IntArray

FilterEmpty 移除数组中的所有零值。

func (*IntArray) X去重 

func (a *IntArray) X去重() *IntArray

Unique 函数用于对数组去重，清除重复的元素。 示例：[1,1,2,3,2] -> [1,2,3]

func (*IntArray) X取any数组 

func (a *IntArray) X取any数组() []interface{}

Interfaces 函数将当前数组转换为 []interface{} 类型并返回。

func (*IntArray) X取值 

func (a *IntArray) X取值(索引 int) (值 int)

At通过指定的索引返回值。 如果给定的`index`超出数组范围，它将返回`0`。

func (*IntArray) X取值2 

func (a *IntArray) X取值2(索引 int) (值 int, 成功 bool)

Get 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，那么 `found` 将为 false。

func (*IntArray) X取值随机 

func (a *IntArray) X取值随机() (值 int, 成功 bool)

Rand 随机地从数组中返回一个元素（不删除）。

func (*IntArray) X取值随机多个 

func (a *IntArray) X取值随机多个(数量 int) []int

Rands 随机返回数组中的 `size` 个元素（不删除）。

func (*IntArray) X取切片 

func (a *IntArray) X取切片() []int

Slice 返回数组的基础数据。 注意，如果它在并发安全的使用场景下，会返回基础数据的一个副本， 否则，则返回指向基础数据的指针。

func (*IntArray) X取切片并按数量 

func (a *IntArray) X取切片并按数量(起点 int, 数量 ...int) []int

SubSlice 返回数组中由 `offset` 和 `size` 参数指定的元素子序列，并将其作为切片。 若在并发安全场景下使用，返回该切片的副本；否则返回指向切片的指针。

如果 offset 非负，则序列从数组该偏移位置开始。 如果 offset 为负，则序列从数组末尾向前偏移该距离的位置开始。

如果提供了 length 并且为正数，则序列将包含最多该数量的元素。 若数组长度小于 length，则序列仅包含数组中可获得的元素。 如果 length 为负数，则序列将在数组末尾向前停在该距离的位置。 如果未提供 length，则序列包含从 offset 开始直到数组末尾的所有元素。

若有任何可能穿越数组左边界的情况，函数将失败。

func (*IntArray) X取切片并按范围 

func (a *IntArray) X取切片并按范围(起点 int, 终点 ...int) []int

Range 函数通过范围选择并返回数组中的元素，类似于 array[start:end]。 注意：在并发安全的使用场景下，它会返回一个原数据的副本；否则，返回的是底层数据的指针。

如果 `end` 为负数，则偏移量将从数组末尾开始计算。 如果省略了 `end`，则序列将包含从 start 开始直到数组末尾的所有元素。

func (*IntArray) X取副本 

func (a *IntArray) X取副本() (新数组 *IntArray)

Clone 返回一个新的数组，它是当前数组的一个副本。

func (*IntArray) X取文本 

func (a *IntArray) X取文本() string

func (*IntArray) X取长度 

func (a *IntArray) X取长度() int

Len 返回数组的长度。

func (*IntArray) X合并 

func (a *IntArray) X合并(数组 interface{}) *IntArray

Merge 将`array`合并到当前数组中。 参数`array`可以是任何garray类型或切片类型。 Merge 和 Append 的区别在于，Append 仅支持特定类型的切片作为参数， 而 Merge 支持更多类型的参数。

func (*IntArray) X填充 

func (a *IntArray) X填充(起点 int, 填充数量 int, 值 int) error

Fill 用 `value` 值填充数组，填充 num 个条目， 键（索引）从 `startIndex` 参数开始。

func (*IntArray) X填满 

func (a *IntArray) X填满(总数量 int, 值 int) *IntArray

Pad 通过 `value` 值对数组进行填充，以达到指定长度。 如果 size 为正数，则在数组右侧进行填充；若为负数，则在左侧填充。 若 `size` 的绝对值小于或等于数组的长度，则不进行填充操作。

func (*IntArray) X排序函数 

func (a *IntArray) X排序函数(回调函数 func(v1, v2 int) bool) *IntArray

SortFunc 通过自定义函数 `less` 对数组进行排序。

func (*IntArray) X排序递增 

func (a *IntArray) X排序递增(降序 ...bool) *IntArray

Sort 函数用于将数组按升序排序。 参数 `reverse` 用于控制是否按升序（默认）或降序进行排序。

func (*IntArray) X插入前面 

func (a *IntArray) X插入前面(索引 int, 值 ...int) error

InsertBefore 将 `values` 插入到 `index` 之前的位置。

func (*IntArray) X插入后面 

func (a *IntArray) X插入后面(index int, 值 ...int) error

InsertAfter 在`index`之后插入`value`。

func (*IntArray) X是否为空 

func (a *IntArray) X是否为空() bool

IsEmpty 检查数组是否为空。

func (*IntArray) X是否存在 

func (a *IntArray) X是否存在(值 int) bool

Contains 检查某个值是否存在于数组中。

func (*IntArray) X替换 

func (a *IntArray) X替换(数组 []int) *IntArray

Replace 从数组起始位置开始，使用给定的`array`替换原有数组元素。

func (*IntArray) X查找 

func (a *IntArray) X查找(值 int) int

Search 在数组中通过 `value` 进行搜索，返回 `value` 的索引， 若不存在，则返回 -1。

func (*IntArray) X求和 

func (a *IntArray) X求和() (值 int)

Sum 返回数组中所有值的和。

func (*IntArray) X清空 

func (a *IntArray) X清空() *IntArray

清空删除当前数组中的所有元素。

func (*IntArray) X统计 

func (a *IntArray) X统计() map[int]int

CountValues 计算数组中所有值出现的次数。

func (*IntArray) X设置值 

func (a *IntArray) X设置值(索引 int, 值 int) error

Set将值设置到指定的索引位置。

func (*IntArray) X设置数组 

func (a *IntArray) X设置数组(数组 []int) *IntArray

SetArray 将底层的切片数组设置为给定的 `array`。

func (*IntArray) X连接 

func (a *IntArray) X连接(连接符 string) string

Join 通过字符串 `glue` 连接数组元素。

func (*IntArray) X遍历 

func (a *IntArray) X遍历(回调函数 func(k int, v int) bool)

Iterator 是 IteratorAsc 的别名。

func (*IntArray) X遍历修改 

func (a *IntArray) X遍历修改(回调函数 func(值 int) int) *IntArray

Walk 对数组中的每一项应用用户提供的函数 `f`。

func (*IntArray) X遍历写锁定 

func (a *IntArray) X遍历写锁定(回调函数 func(数组 []int)) *IntArray

LockFunc 通过回调函数`f`进行写入锁定。

func (*IntArray) X遍历删除 

func (a *IntArray) X遍历删除(回调函数 func(索引 int, 值 int) bool) *IntArray

Filter 对数组进行迭代，并通过自定义回调函数进行元素过滤。 如果回调函数 `filter` 返回 true，则从数组中移除该元素； 否则不做任何处理并继续迭代。

func (*IntArray) X遍历升序 

func (a *IntArray) X遍历升序(回调函数 func(k int, v int) bool)

IteratorAsc 以升序遍历给定数组，并使用回调函数 `f` 进行只读操作。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止遍历。

func (*IntArray) X遍历读锁定 

func (a *IntArray) X遍历读锁定(回调函数 func(数组 []int)) *IntArray

RLockFunc 通过回调函数`f`锁定读取操作。

func (*IntArray) X遍历降序 

func (a *IntArray) X遍历降序(回调函数 func(k int, v int) bool)

IteratorDesc 函数以降序遍历给定的数组，并使用指定回调函数 `f` 进行只读操作。 若 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

func (*IntArray) X随机排序 

func (a *IntArray) X随机排序() *IntArray

Shuffle 随机地对数组进行洗牌。

type SortedArray 

type SortedArray struct {
	// contains filtered or unexported fields
}

SortedArray 是一个具有丰富特性的 Go 语言有序数组。 默认情况下，它使用递增顺序排列，可以通过设置自定义比较器进行更改。 它包含一个并发安全/不安全的切换选项，该选项应在初始化时设置，并且之后不能更改。 示例： ```go SortedArray 是一个Go语言实现的具备多种功能的有序数组。 默认情况下，数组按升序排列，通过设定自定义比较函数可以改变排序方式。 它具备并发安全/非安全模式切换功能，但该选项需在初始化时设定，并且设定后不可再更改。

func X创建排序 

func X创建排序(排序函数 func(a, b interface{}) int, 并发安全 ...bool) *SortedArray

NewSortedArray 创建并返回一个空的排序数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。 参数 `comparator` 用于比较数组中要排序的值， 如果它返回值 < 0，表示 `a` < `b`；此时 `a` 将被插入到 `b` 之前； 如果它返回值 = 0，表示 `a` = `b`；此时 `a` 将替换 `b`； 如果它返回值 > 0，表示 `a` > `b`；此时 `a` 将被插入到 `b` 之后。

func X创建排序并从数组 

func X创建排序并从数组(数组 []interface{}, 排序函数 func(a, b interface{}) int, 并发安全 ...bool) *SortedArray

NewSortedArrayFrom 根据给定的切片 `array` 创建并返回一个已排序的数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建排序并从数组复制 

func X创建排序并从数组复制(数组 []interface{}, 排序函数 func(a, b interface{}) int, 并发安全 ...bool) *SortedArray

NewSortedArrayFromCopy 函数通过复制给定切片 `array` 创建并返回一个已排序的数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建排序并按大小 

func X创建排序并按大小(大小 int, 排序函数 func(a, b interface{}) int, 并发安全 ...bool) *SortedArray

NewSortedArraySize 根据给定的大小和容量创建并返回一个已排序的数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建排序并按范围 

func X创建排序并按范围(起点, 终点, 步长 int, 排序函数 func(a, b interface{}) int, 并发安全 ...bool) *SortedArray

NewSortedArrayRange 根据指定的范围从 `start` 到 `end`，并以步长值 `step` 创建并返回一个数组。

func (*SortedArray) Append别名 

func (a *SortedArray) Append别名(值 ...interface{}) *SortedArray

Append 向已排序的数组中添加一个或多个值，数组将始终保持有序。

func (*SortedArray) DeepCopy 

func (a *SortedArray) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (SortedArray) MarshalJSON 

func (a SortedArray) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。 注意：此处接收者不使用指针。

func (*SortedArray) String 

func (a *SortedArray) String() string

String 方法将当前数组以字符串形式返回，其实现方式类似于 json.Marshal。

func (*SortedArray) UnmarshalJSON 

func (a *SortedArray) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。 注意，该比较器默认设置为字符串比较器。

func (*SortedArray) UnmarshalValue 

func (a *SortedArray) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 实现了一个接口，该接口用于为数组设置任何类型的值。 注意，默认情况下比较器设置为字符串比较器。

func (*SortedArray) X入栈右 

func (a *SortedArray) X入栈右(值 ...interface{}) *SortedArray

Add 向有序数组中添加一个或多个值，数组始终保持有序。 它是函数 Append 的别名，请参阅 Append。

func (*SortedArray) X出栈右 

func (a *SortedArray) X出栈右() (值 interface{}, 成功 bool)

PopRight从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则`found`为false。

func (*SortedArray) X出栈右多个 

func (a *SortedArray) X出栈右多个(数量 int) []interface{}

PopRights 从数组末尾弹出并返回 `size` 个元素。

func (*SortedArray) X出栈左 

func (a *SortedArray) X出栈左() (值 interface{}, 成功 bool)

PopLeft 从数组开头弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*SortedArray) X出栈左多个 

func (a *SortedArray) X出栈左多个(数量 int) []interface{}

PopLefts 从数组开头弹出并返回 `size` 个元素。

func (*SortedArray) X出栈随机 

func (a *SortedArray) X出栈随机() (值 interface{}, 成功 bool)

PopRand 随机地从数组中弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*SortedArray) X出栈随机多个 

func (a *SortedArray) X出栈随机多个(数量 int) []interface{}

PopRands 随机地从数组中弹出并返回 `size` 个元素。

func (*SortedArray) X分割 

func (a *SortedArray) X分割(数量 int) [][]interface{}

Chunk 函数将一个数组分割成多个子数组， 每个子数组的大小由参数 `size` 确定。 最后一个子数组可能包含少于 size 个元素。

func (*SortedArray) X删除 

func (a *SortedArray) X删除(索引 int) (值 interface{}, 成功 bool)

Remove 通过索引移除一个元素。 如果给定的 `index` 超出了数组范围，`found` 将为 false。

func (*SortedArray) X删除值 

func (a *SortedArray) X删除值(值 interface{}) bool

RemoveValue 通过值移除一个元素。 若在数组中找到该值，则返回 true，否则（未找到时）返回 false。

func (*SortedArray) X删除多个值 

func (a *SortedArray) X删除多个值(值 ...interface{})

RemoveValues 通过 `values` 移除项目。

func (*SortedArray) X删除所有nil 

func (a *SortedArray) X删除所有nil() *SortedArray

FilterNil 移除数组中所有的 nil 值。

func (*SortedArray) X删除所有空值 

func (a *SortedArray) X删除所有空值() *SortedArray

FilterEmpty 用于移除数组中所有空值。 下列值被认为是空值：0, nil, false, "", 以及长度为0的slice、map或chan。

func (*SortedArray) X去重 

func (a *SortedArray) X去重() *SortedArray

Unique 对数组进行去重，清除重复的元素。

func (*SortedArray) X取any数组 

func (a *SortedArray) X取any数组() []interface{}

Interfaces 函数将当前数组转换为 []interface{} 类型并返回。

func (*SortedArray) X取值 

func (a *SortedArray) X取值(索引 int) (值 interface{})

At通过指定的索引返回值。 如果给定的`index`超出数组范围，它将返回`nil`。

func (*SortedArray) X取值2 

func (a *SortedArray) X取值2(索引 int) (值 interface{}, 成功 bool)

Get 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，那么 `found` 将为 false。

func (*SortedArray) X取值随机 

func (a *SortedArray) X取值随机() (值 interface{}, 成功 bool)

Rand 随机地从数组中返回一个元素（不删除）。

func (*SortedArray) X取值随机多个 

func (a *SortedArray) X取值随机多个(数量 int) []interface{}

Rands 随机返回数组中的 `size` 个元素（不删除）。

func (*SortedArray) X取切片 

func (a *SortedArray) X取切片() []interface{}

Slice 返回数组的基础数据。 注意，如果它在并发安全的使用场景下，会返回基础数据的一个副本， 否则，则返回指向基础数据的指针。

func (*SortedArray) X取切片并按数量 

func (a *SortedArray) X取切片并按数量(起点 int, 数量 ...int) []interface{}

SubSlice 返回数组中由 `offset` 和 `size` 参数指定的元素子序列，并将其作为切片。 若在并发安全场景下使用，返回该切片的副本；否则返回指向切片的指针。

如果 offset 非负，则序列从数组该偏移位置开始。 如果 offset 为负，则序列从数组末尾向前偏移该距离的位置开始。

如果提供了 length 并且为正数，则序列将包含最多该数量的元素。 若数组长度小于 length，则序列仅包含数组中可获得的元素。 如果 length 为负数，则序列将在数组末尾向前停在该距离的位置。 如果未提供 length，则序列包含从 offset 开始直到数组末尾的所有元素。

若有任何可能穿越数组左边界的情况，函数将失败。

func (*SortedArray) X取切片并按范围 

func (a *SortedArray) X取切片并按范围(起点 int, 终点 ...int) []interface{}

Range 函数通过范围选择并返回数组中的元素，类似于 array[start:end]。 注意：在并发安全的使用场景下，它会返回一个原数据的副本；否则，返回的是底层数据的指针。

如果 `end` 为负数，则偏移量将从数组末尾开始计算。 如果省略了 `end`，则序列将包含从 start 开始直到数组末尾的所有元素。

func (*SortedArray) X取副本 

func (a *SortedArray) X取副本() (新数组 *SortedArray)

Clone 返回一个新的数组，它是当前数组的一个副本。

func (*SortedArray) X取文本 

func (a *SortedArray) X取文本() string

func (*SortedArray) X取长度 

func (a *SortedArray) X取长度() int

Len 返回数组的长度。

func (*SortedArray) X合并 

func (a *SortedArray) X合并(数组 interface{}) *SortedArray

Merge 将`array`合并到当前数组中。 参数`array`可以是任何garray类型或切片类型。 Merge 和 Append 的区别在于，Append 仅支持特定类型的切片作为参数， 而 Merge 支持更多类型的参数。

func (*SortedArray) X排序递增 

func (a *SortedArray) X排序递增() *SortedArray

Sort 函数用于将数组按升序排序。 参数 `reverse` 控制排序方式，若 reverse 为 true，则按降序（默认为升序）排序。

func (*SortedArray) X是否为空 

func (a *SortedArray) X是否为空() bool

IsEmpty 检查数组是否为空。

func (*SortedArray) X是否存在 

func (a *SortedArray) X是否存在(值 interface{}) bool

Contains 检查某个值是否存在于数组中。

func (*SortedArray) X查找 

func (a *SortedArray) X查找(值 interface{}) (索引 int)

Search 在数组中通过 `value` 进行搜索，返回 `value` 的索引， 若不存在，则返回 -1。

func (*SortedArray) X求和 

func (a *SortedArray) X求和() (值 int)

Sum 返回数组中所有值的和。

func (*SortedArray) X清空 

func (a *SortedArray) X清空() *SortedArray

清空删除当前数组中的所有元素。

func (*SortedArray) X统计 

func (a *SortedArray) X统计() map[interface{}]int

CountValues 计算数组中所有值出现的次数。

func (*SortedArray) X设置去重 

func (a *SortedArray) X设置去重(去重 bool) *SortedArray

SetUnique 将唯一标志设置到数组中， 意味着该数组不包含任何重复的元素。 同时进行唯一性检查，移除所有重复的项。

func (*SortedArray) X设置排序函数 

func (a *SortedArray) X设置排序函数(排序函数 func(a, b interface{}) int)

SetComparator 设置/更改排序的比较器。 当比较器发生改变时，它会重新对数组进行排序。

func (*SortedArray) X设置数组 

func (a *SortedArray) X设置数组(数组 []interface{}) *SortedArray

SetArray 将底层的切片数组设置为给定的 `array`。

func (*SortedArray) X连接 

func (a *SortedArray) X连接(连接符 string) string

Join 通过字符串 `glue` 连接数组元素。

func (*SortedArray) X遍历 

func (a *SortedArray) X遍历(回调函数 func(k int, v interface{}) bool)

Iterator 是 IteratorAsc 的别名。

func (*SortedArray) X遍历修改 

func (a *SortedArray) X遍历修改(回调函数 func(值 interface{}) interface{}) *SortedArray

Walk 对数组中的每一项应用用户提供的函数 `f`。

func (*SortedArray) X遍历写锁定 

func (a *SortedArray) X遍历写锁定(回调函数 func(数组 []interface{})) *SortedArray

LockFunc 通过回调函数`f`进行写入锁定。

func (*SortedArray) X遍历删除 

func (a *SortedArray) X遍历删除(回调函数 func(索引 int, 值 interface{}) bool) *SortedArray

Filter 对数组进行迭代，并通过自定义回调函数进行元素过滤。 如果回调函数 `filter` 返回 true，则从数组中移除该元素； 否则不做任何处理并继续迭代。

func (*SortedArray) X遍历升序 

func (a *SortedArray) X遍历升序(回调函数 func(k int, v interface{}) bool)

IteratorAsc 以升序遍历给定数组，并使用回调函数 `f` 进行只读操作。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止遍历。

func (*SortedArray) X遍历读锁定 

func (a *SortedArray) X遍历读锁定(回调函数 func(数组 []interface{})) *SortedArray

RLockFunc 通过回调函数`f`锁定读取操作。

func (*SortedArray) X遍历降序 

func (a *SortedArray) X遍历降序(回调函数 func(k int, v interface{}) bool)

IteratorDesc 函数以降序遍历给定的数组，并使用指定回调函数 `f` 进行只读操作。 若 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

type SortedIntArray 

type SortedIntArray struct {
	// contains filtered or unexported fields
}

SortedIntArray 是一个具有丰富功能的Golang有序整数数组。 默认情况下，它按递增顺序排列，但可以通过 设置自定义比较器来改变排序方式。 它包含一个并发安全/不安全的切换选项，该选项应在初始化时设置， 并且之后不可更改。

func X创建整数排序 

func X创建整数排序(并发安全 ...bool) *SortedIntArray

NewSortedIntArray 创建并返回一个空的有序整数数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建整数排序并从数组 

func X创建整数排序并从数组(数组 []int, 并发安全 ...bool) *SortedIntArray

NewSortedIntArrayFrom 根据给定的切片 `array` 创建并返回一个已排序的数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建整数排序并从数组复制 

func X创建整数排序并从数组复制(数组 []int, 并发安全 ...bool) *SortedIntArray

NewSortedIntArrayFromCopy 通过复制给定切片`array`创建并返回一个已排序的数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。 ```go NewSortedIntArrayFromCopy 函数通过复制给定的切片 `array`，生成并返回一个新的已排序整数数组。 其中参数 `safe` 表示是否需要在并发安全模式下使用该数组，默认情况下为不安全（false）。

func X创建整数排序并带排序函数 

func X创建整数排序并带排序函数(排序函数 func(a, b int) int, 并发安全 ...bool) *SortedIntArray

NewSortedIntArrayComparator 创建并返回一个空的有序数组，使用指定的比较器。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建整数排序并按大小 

func X创建整数排序并按大小(大小 int, 并发安全 ...bool) *SortedIntArray

NewSortedIntArraySize 根据给定的大小和容量创建并返回一个已排序的整数数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建整数排序并按范围 

func X创建整数排序并按范围(起点, 终点, 步长 int, 并发安全 ...bool) *SortedIntArray

NewSortedIntArrayRange 根据给定的范围从 `start` 到 `end`，并以指定的步长 `step` 创建并返回一个已排序的整数数组。

func (*SortedIntArray) Append别名 

func (a *SortedIntArray) Append别名(值 ...int) *SortedIntArray

Append 向已排序的数组中添加一个或多个值，数组将始终保持有序。

func (*SortedIntArray) DeepCopy 

func (a *SortedIntArray) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (SortedIntArray) MarshalJSON 

func (a SortedIntArray) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。 注意：此处接收者不使用指针。

func (*SortedIntArray) String 

func (a *SortedIntArray) String() string

String 方法将当前数组以字符串形式返回，其实现方式类似于 json.Marshal。

func (*SortedIntArray) UnmarshalJSON 

func (a *SortedIntArray) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

func (*SortedIntArray) UnmarshalValue 

func (a *SortedIntArray) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 实现了一个接口，该接口用于为数组设置任意类型的值。

func (*SortedIntArray) X入栈右 

func (a *SortedIntArray) X入栈右(值 ...int) *SortedIntArray

Add 向有序数组中添加一个或多个值，数组始终保持有序。 它是函数 Append 的别名，请参阅 Append。

func (*SortedIntArray) X出栈右 

func (a *SortedIntArray) X出栈右() (值 int, 成功 bool)

PopRight从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则`found`为false。

func (*SortedIntArray) X出栈右多个 

func (a *SortedIntArray) X出栈右多个(数量 int) []int

PopRights 从数组末尾弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回nil。

func (*SortedIntArray) X出栈左 

func (a *SortedIntArray) X出栈左() (值 int, 成功 bool)

PopLeft 从数组开头弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*SortedIntArray) X出栈左多个 

func (a *SortedIntArray) X出栈左多个(数量 int) []int

PopLefts 从数组开头弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，则返回nil。

func (*SortedIntArray) X出栈随机 

func (a *SortedIntArray) X出栈随机() (值 int, 成功 bool)

PopRand 随机地从数组中弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*SortedIntArray) X出栈随机多个 

func (a *SortedIntArray) X出栈随机多个(数量 int) []int

PopRands 随机地从数组中弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回 nil。

func (*SortedIntArray) X分割 

func (a *SortedIntArray) X分割(数量 int) [][]int

Chunk 函数将一个数组分割成多个子数组， 每个子数组的大小由参数 `size` 确定。 最后一个子数组可能包含少于 size 个元素。

func (*SortedIntArray) X删除 

func (a *SortedIntArray) X删除(索引 int) (值 int, 成功 bool)

Remove 通过索引移除一个元素。 如果给定的 `index` 超出了数组范围，`found` 将为 false。

func (*SortedIntArray) X删除值 

func (a *SortedIntArray) X删除值(值 int) bool

RemoveValue 通过值移除一个元素。 若在数组中找到该值，则返回 true，否则（未找到时）返回 false。

func (*SortedIntArray) X删除多个值 

func (a *SortedIntArray) X删除多个值(值 ...int)

RemoveValues 通过 `values` 移除项目。

func (*SortedIntArray) X删除所有空值 

func (a *SortedIntArray) X删除所有空值() *SortedIntArray

FilterEmpty 移除数组中的所有零值。

func (*SortedIntArray) X去重 

func (a *SortedIntArray) X去重() *SortedIntArray

Unique 对数组进行去重，清除重复的元素。

func (*SortedIntArray) X取any数组 

func (a *SortedIntArray) X取any数组() []interface{}

Interfaces 函数将当前数组转换为 []interface{} 类型并返回。

func (*SortedIntArray) X取值 

func (a *SortedIntArray) X取值(索引 int) (值 int)

At通过指定的索引返回值。 如果给定的`index`超出数组范围，它将返回`0`。

func (*SortedIntArray) X取值2 

func (a *SortedIntArray) X取值2(索引 int) (值 int, 成功 bool)

Get 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，那么 `found` 将为 false。

func (*SortedIntArray) X取值随机 

func (a *SortedIntArray) X取值随机() (值 int, 成功 bool)

Rand 随机地从数组中返回一个元素（不删除）。

func (*SortedIntArray) X取值随机多个 

func (a *SortedIntArray) X取值随机多个(数量 int) []int

Rands 随机返回数组中的 `size` 个元素（不删除）。

func (*SortedIntArray) X取切片 

func (a *SortedIntArray) X取切片() []int

Slice 返回数组的基础数据。 注意，如果它在并发安全的使用场景下，会返回基础数据的一个副本， 否则，则返回指向基础数据的指针。

func (*SortedIntArray) X取切片并按数量 

func (a *SortedIntArray) X取切片并按数量(起点 int, 数量 ...int) []int

SubSlice 返回数组中由 `offset` 和 `size` 参数指定的元素子序列，并将其作为切片。 若在并发安全场景下使用，返回该切片的副本；否则返回指向切片的指针。

如果 offset 非负，则序列从数组该偏移位置开始。 如果 offset 为负，则序列从数组末尾向前偏移该距离的位置开始。

如果提供了 length 并且为正数，则序列将包含最多该数量的元素。 若数组长度小于 length，则序列仅包含数组中可获得的元素。 如果 length 为负数，则序列将在数组末尾向前停在该距离的位置。 如果未提供 length，则序列包含从 offset 开始直到数组末尾的所有元素。

若有任何可能穿越数组左边界的情况，函数将失败。

func (*SortedIntArray) X取切片并按范围 

func (a *SortedIntArray) X取切片并按范围(起点 int, 终点 ...int) []int

Range 函数通过范围选择并返回数组中的元素，类似于 array[start:end]。 注意：在并发安全的使用场景下，它会返回一个原数据的副本；否则，返回的是底层数据的指针。

如果 `end` 为负数，则偏移量将从数组末尾开始计算。 如果省略了 `end`，则序列将包含从 start 开始直到数组末尾的所有元素。

func (*SortedIntArray) X取副本 

func (a *SortedIntArray) X取副本() (新数组 *SortedIntArray)

Clone 返回一个新的数组，它是当前数组的一个副本。

func (*SortedIntArray) X取文本 

func (a *SortedIntArray) X取文本() string

func (*SortedIntArray) X取长度 

func (a *SortedIntArray) X取长度() int

Len 返回数组的长度。

func (*SortedIntArray) X合并 

func (a *SortedIntArray) X合并(数组 interface{}) *SortedIntArray

Merge 将`array`合并到当前数组中。 参数`array`可以是任何garray类型或切片类型。 Merge 和 Append 的区别在于，Append 仅支持特定类型的切片作为参数， 而 Merge 支持更多类型的参数。

func (*SortedIntArray) X排序递增 

func (a *SortedIntArray) X排序递增() *SortedIntArray

Sort 函数用于将数组按升序排列。 参数 `reverse` 用于控制排序方式，若为 true 则按降序排列（默认为升序）。

func (*SortedIntArray) X是否为空 

func (a *SortedIntArray) X是否为空() bool

IsEmpty 检查数组是否为空。

func (*SortedIntArray) X是否存在 

func (a *SortedIntArray) X是否存在(值 int) bool

Contains 检查某个值是否存在于数组中。

func (*SortedIntArray) X查找 

func (a *SortedIntArray) X查找(值 int) (索引 int)

Search 在数组中通过 `value` 进行搜索，返回 `value` 的索引， 若不存在，则返回 -1。

func (*SortedIntArray) X求和 

func (a *SortedIntArray) X求和() (值 int)

Sum 返回数组中所有值的和。

func (*SortedIntArray) X清空 

func (a *SortedIntArray) X清空() *SortedIntArray

清空删除当前数组中的所有元素。

func (*SortedIntArray) X统计 

func (a *SortedIntArray) X统计() map[int]int

CountValues 计算数组中所有值出现的次数。

func (*SortedIntArray) X设置去重 

func (a *SortedIntArray) X设置去重(去重 bool) *SortedIntArray

SetUnique 将唯一标志设置到数组中， 这意味着该数组不包含任何重复的元素。 同时，它还会进行唯一性检查，并移除所有重复的项。

func (*SortedIntArray) X设置数组 

func (a *SortedIntArray) X设置数组(数组 []int) *SortedIntArray

SetArray 将底层的切片数组设置为给定的 `array`。

func (*SortedIntArray) X连接 

func (a *SortedIntArray) X连接(连接符 string) string

Join 通过字符串 `glue` 连接数组元素。

func (*SortedIntArray) X遍历 

func (a *SortedIntArray) X遍历(回调函数 func(k int, v int) bool)

Iterator 是 IteratorAsc 的别名。

func (*SortedIntArray) X遍历修改 

func (a *SortedIntArray) X遍历修改(回调函数 func(值 int) int) *SortedIntArray

Walk 对数组中的每一项应用用户提供的函数 `f`。

func (*SortedIntArray) X遍历写锁定 

func (a *SortedIntArray) X遍历写锁定(回调函数 func(数组 []int)) *SortedIntArray

LockFunc 通过回调函数`f`进行写入锁定。

func (*SortedIntArray) X遍历删除 

func (a *SortedIntArray) X遍历删除(回调函数 func(索引 int, 值 int) bool) *SortedIntArray

Filter 对数组进行迭代，并通过自定义回调函数进行元素过滤。 如果回调函数 `filter` 返回 true，则从数组中移除该元素； 否则不做任何处理并继续迭代。

func (*SortedIntArray) X遍历升序 

func (a *SortedIntArray) X遍历升序(回调函数 func(k int, v int) bool)

IteratorAsc 以升序遍历给定数组，并使用回调函数 `f` 进行只读操作。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止遍历。

func (*SortedIntArray) X遍历读锁定 

func (a *SortedIntArray) X遍历读锁定(回调函数 func(数组 []int)) *SortedIntArray

RLockFunc 通过回调函数`f`锁定读取操作。

func (*SortedIntArray) X遍历降序 

func (a *SortedIntArray) X遍历降序(回调函数 func(k int, v int) bool)

IteratorDesc 函数以降序遍历给定的数组，并使用指定回调函数 `f` 进行只读操作。 若 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

type SortedStrArray 

type SortedStrArray struct {
	// contains filtered or unexported fields
}

SortedStrArray 是一个具有丰富特性的 Go 语言有序字符串数组。 默认情况下，它按升序排列，但可以通过设置自定义比较器来改变排序方式。 它包含一个并发安全/非安全切换选项，该选项应在初始化时设定，并且一旦设定后不可更改。

func X创建文本排序 

func X创建文本排序(并发安全 ...bool) *SortedStrArray

NewSortedStrArray 创建并返回一个空的已排序数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建文本排序并从数组 

func X创建文本排序并从数组(数组 []string, 并发安全 ...bool) *SortedStrArray

NewSortedStrArrayFrom 通过给定的切片`array`创建并返回一个已排序的数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建文本排序并从数组复制 

func X创建文本排序并从数组复制(数组 []string, 并发安全 ...bool) *SortedStrArray

NewSortedStrArrayFromCopy 通过复制给定切片 `array` 创建并返回一个已排序的数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建文本排序并带排序函数 

func X创建文本排序并带排序函数(排序函数 func(a, b string) int, 并发安全 ...bool) *SortedStrArray

NewSortedStrArrayComparator 创建并返回一个根据指定比较器排序的空数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建文本排序并按大小 

func X创建文本排序并按大小(大小 int, 并发安全 ...bool) *SortedStrArray

NewSortedStrArraySize 根据给定的大小和容量创建并返回一个已排序的数组。 参数 `safe` 用于指定是否在并发安全环境下使用该数组，默认为 false。

func (*SortedStrArray) Append别名 

func (a *SortedStrArray) Append别名(值 ...string) *SortedStrArray

Append 向已排序的数组中添加一个或多个值，数组将始终保持有序。

func (*SortedStrArray) DeepCopy 

func (a *SortedStrArray) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (SortedStrArray) MarshalJSON 

func (a SortedStrArray) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。 注意：此处接收者不使用指针。

Example 
type Student struct {
	ID     int
	Name   string
	Levels 数组类.SortedStrArray
}
r := 数组类.X创建文本排序并从数组(g.SliceStr别名{"b", "c", "a"})
s := Student{
	ID:     1,
	Name:   "john",
	Levels: *r,
}
b, _ := json.Marshal(s)
fmt.Println(string(b))

Output:

{"ID":1,"Name":"john","Levels":["a","b","c"]}

func (*SortedStrArray) String 

func (a *SortedStrArray) String() string

String 方法将当前数组以字符串形式返回，其实现方式类似于 json.Marshal。

Example 
s := 数组类.X创建文本排序并从数组(g.SliceStr别名{"b", "c", "a"})
fmt.Println(s.String())

Output:

["a","b","c"]

func (*SortedStrArray) UnmarshalJSON 

func (a *SortedStrArray) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
type Student struct {
	Id      int
	Name    string
	Lessons *数组类.StrArray
}
s := Student{}
json.Unmarshal(b, &s)
fmt.Println(s)

Output:

{1 john ["Math","English","Sport"]}

func (*SortedStrArray) UnmarshalValue 

func (a *SortedStrArray) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 实现了一个接口，该接口用于为数组设置任意类型的值。

Example 
type Student struct {
	Name    string
	Lessons *数组类.StrArray
}
var s *Student
转换类.Struct(g.Map{
	"name":    "john",
	"lessons": []byte(`["Math","English","Sport"]`),
}, &s)
fmt.Println(s)

var s1 *Student
转换类.Struct(g.Map{
	"name":    "john",
	"lessons": g.SliceStr别名{"Math", "English", "Sport"},
}, &s1)
fmt.Println(s1)

Output:

&{john ["Math","English","Sport"]}
&{john ["Math","English","Sport"]}

func (*SortedStrArray) X入栈右 

func (a *SortedStrArray) X入栈右(值 ...string) *SortedStrArray

Add 向有序数组中添加一个或多个值，数组始终保持有序。 它是函数 Append 的别名，请参阅 Append。

func (*SortedStrArray) X出栈右 

func (a *SortedStrArray) X出栈右() (值 string, 成功 bool)

PopRight从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则`found`为false。

func (*SortedStrArray) X出栈右多个 

func (a *SortedStrArray) X出栈右多个(数量 int) []string

PopRights 从数组末尾弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回nil。

func (*SortedStrArray) X出栈左 

func (a *SortedStrArray) X出栈左() (值 string, 成功 bool)

PopLeft 从数组开头弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*SortedStrArray) X出栈左多个 

func (a *SortedStrArray) X出栈左多个(数量 int) []string

PopLefts 从数组开头弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，则返回nil。

func (*SortedStrArray) X出栈随机 

func (a *SortedStrArray) X出栈随机() (值 string, 成功 bool)

PopRand 随机地从数组中弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*SortedStrArray) X出栈随机多个 

func (a *SortedStrArray) X出栈随机多个(数量 int) []string

PopRands 随机地从数组中弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回 nil。

func (*SortedStrArray) X分割 

func (a *SortedStrArray) X分割(数量 int) [][]string

Chunk 函数将一个数组分割成多个子数组， 每个子数组的大小由参数 `size` 确定。 最后一个子数组可能包含少于 size 个元素。

func (*SortedStrArray) X删除 

func (a *SortedStrArray) X删除(索引 int) (值 string, 成功 bool)

Remove 通过索引移除一个元素。 如果给定的 `index` 超出了数组范围，`found` 将为 false。

func (*SortedStrArray) X删除值 

func (a *SortedStrArray) X删除值(值 string) bool

RemoveValue 通过值移除一个元素。 若在数组中找到该值，则返回 true，否则（未找到时）返回 false。

func (*SortedStrArray) X删除多个值 

func (a *SortedStrArray) X删除多个值(值 ...string)

RemoveValues 通过 `values` 移除项目。

func (*SortedStrArray) X删除所有空值 

func (a *SortedStrArray) X删除所有空值() *SortedStrArray

FilterEmpty 从数组中移除所有空字符串值。

func (*SortedStrArray) X去重 

func (a *SortedStrArray) X去重() *SortedStrArray

Unique 对数组进行去重，清除重复的元素。

func (*SortedStrArray) X取any数组 

func (a *SortedStrArray) X取any数组() []interface{}

Interfaces 函数将当前数组转换为 []interface{} 类型并返回。

func (*SortedStrArray) X取值 

func (a *SortedStrArray) X取值(索引 int) (值 string)

At 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，它将返回一个空字符串。

func (*SortedStrArray) X取值2 

func (a *SortedStrArray) X取值2(索引 int) (值 string, 成功 bool)

Get 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，那么 `found` 将为 false。

func (*SortedStrArray) X取值随机 

func (a *SortedStrArray) X取值随机() (值 string, 成功 bool)

Rand 随机地从数组中返回一个元素（不删除）。

func (*SortedStrArray) X取值随机多个 

func (a *SortedStrArray) X取值随机多个(数量 int) []string

Rands 随机返回数组中的 `size` 个元素（不删除）。

func (*SortedStrArray) X取切片 

func (a *SortedStrArray) X取切片() []string

Slice 返回数组的基础数据。 注意，如果它在并发安全的使用场景下，会返回基础数据的一个副本， 否则，则返回指向基础数据的指针。

func (*SortedStrArray) X取切片并按数量 

func (a *SortedStrArray) X取切片并按数量(起点 int, 数量 ...int) []string

SubSlice 返回数组中由 `offset` 和 `size` 参数指定的元素子序列，并将其作为切片。 若在并发安全场景下使用，返回该切片的副本；否则返回指向切片的指针。

如果 offset 非负，则序列从数组该偏移位置开始。 如果 offset 为负，则序列从数组末尾向前偏移该距离的位置开始。

如果提供了 length 并且为正数，则序列将包含最多该数量的元素。 若数组长度小于 length，则序列仅包含数组中可获得的元素。 如果 length 为负数，则序列将在数组末尾向前停在该距离的位置。 如果未提供 length，则序列包含从 offset 开始直到数组末尾的所有元素。

若有任何可能穿越数组左边界的情况，函数将失败。

func (*SortedStrArray) X取切片并按范围 

func (a *SortedStrArray) X取切片并按范围(起点 int, 终点 ...int) []string

Range 函数通过范围选择并返回数组中的元素，类似于 array[start:end]。 注意：在并发安全的使用场景下，它会返回一个原数据的副本；否则，返回的是底层数据的指针。

如果 `end` 为负数，则偏移量将从数组末尾开始计算。 如果省略了 `end`，则序列将包含从 start 开始直到数组末尾的所有元素。

func (*SortedStrArray) X取副本 

func (a *SortedStrArray) X取副本() (新数组 *SortedStrArray)

Clone 返回一个新的数组，它是当前数组的一个副本。

func (*SortedStrArray) X取文本 

func (a *SortedStrArray) X取文本() string

func (*SortedStrArray) X取长度 

func (a *SortedStrArray) X取长度() int

Len 返回数组的长度。

func (*SortedStrArray) X合并 

func (a *SortedStrArray) X合并(数组 interface{}) *SortedStrArray

Merge 将`array`合并到当前数组中。 参数`array`可以是任何garray类型或切片类型。 Merge 和 Append 的区别在于，Append 仅支持特定类型的切片作为参数， 而 Merge 支持更多类型的参数。

func (*SortedStrArray) X排序递增 

func (a *SortedStrArray) X排序递增() *SortedStrArray

Sort 函数用于将数组按升序排列。 参数 `reverse` 用于控制排序方式，若为 true 则按降序排列（默认为升序）。

func (*SortedStrArray) X是否为空 

func (a *SortedStrArray) X是否为空() bool

IsEmpty 检查数组是否为空。

func (*SortedStrArray) X是否存在 

func (a *SortedStrArray) X是否存在(值 string) bool

Contains 检查某个值是否存在于数组中。

func (*SortedStrArray) X是否存在并忽略大小写 

func (a *SortedStrArray) X是否存在并忽略大小写(值 string) bool

ContainsI 检查一个值是否以不区分大小写的方式存在于数组中。 注意，它在内部会遍历整个数组并进行不区分大小写的比较。

func (*SortedStrArray) X查找 

func (a *SortedStrArray) X查找(值 string) (索引 int)

Search 在数组中通过 `value` 进行搜索，返回 `value` 的索引， 若不存在，则返回 -1。

func (*SortedStrArray) X求和 

func (a *SortedStrArray) X求和() (值 int)

Sum 返回数组中所有值的和。

func (*SortedStrArray) X清空 

func (a *SortedStrArray) X清空() *SortedStrArray

清空删除当前数组中的所有元素。

func (*SortedStrArray) X统计 

func (a *SortedStrArray) X统计() map[string]int

CountValues 计算数组中所有值出现的次数。

func (*SortedStrArray) X设置去重 

func (a *SortedStrArray) X设置去重(去重 bool) *SortedStrArray

SetUnique 将唯一标志设置到数组中， 这意味着该数组不包含任何重复的元素。 同时，它还会进行唯一性检查，并移除所有重复的项。

func (*SortedStrArray) X设置数组 

func (a *SortedStrArray) X设置数组(数组 []string) *SortedStrArray

SetArray 将底层的切片数组设置为给定的 `array`。

func (*SortedStrArray) X连接 

func (a *SortedStrArray) X连接(连接符 string) string

Join 通过字符串 `glue` 连接数组元素。

func (*SortedStrArray) X遍历 

func (a *SortedStrArray) X遍历(回调函数 func(k int, v string) bool)

Iterator 是 IteratorAsc 的别名。

func (*SortedStrArray) X遍历修改 

func (a *SortedStrArray) X遍历修改(回调函数 func(值 string) string) *SortedStrArray

Walk 对数组中的每一项应用用户提供的函数 `f`。

func (*SortedStrArray) X遍历写锁定 

func (a *SortedStrArray) X遍历写锁定(回调函数 func(数组 []string)) *SortedStrArray

LockFunc 通过回调函数`f`进行写入锁定。

func (*SortedStrArray) X遍历删除 

func (a *SortedStrArray) X遍历删除(回调函数 func(索引 int, 值 string) bool) *SortedStrArray

Filter 对数组进行迭代，并通过自定义回调函数进行元素过滤。 如果回调函数 `filter` 返回 true，则从数组中移除该元素； 否则不做任何处理并继续迭代。

func (*SortedStrArray) X遍历升序 

func (a *SortedStrArray) X遍历升序(回调函数 func(k int, v string) bool)

IteratorAsc 以升序遍历给定数组，并使用回调函数 `f` 进行只读操作。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止遍历。

func (*SortedStrArray) X遍历读锁定 

func (a *SortedStrArray) X遍历读锁定(回调函数 func(数组 []string)) *SortedStrArray

RLockFunc 通过回调函数`f`锁定读取操作。

func (*SortedStrArray) X遍历降序 

func (a *SortedStrArray) X遍历降序(回调函数 func(k int, v string) bool)

IteratorDesc 函数以降序遍历给定的数组，并使用指定回调函数 `f` 进行只读操作。 若 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

type StrArray 

type StrArray struct {
	// contains filtered or unexported fields
}

StrArray 是一个具有丰富特性的 Go 语言字符串数组。 它包含一个并发安全/不安全的开关，在初始化时应设置该开关，之后不可更改。 ```go StrArray 是一个功能丰富的 Golang 字符串数组类型。 其中包含一个并发安全模式切换选项，应在初始化时设定，并且一旦设定后不可再更改。

func X创建文本 

func X创建文本(并发安全 ...bool) *StrArray

NewStrArray 创建并返回一个空字符串数组。 参数`safe`用于指定是否在并发安全的情况下使用数组，默认为false。

func X创建文本并从数组 

func X创建文本并从数组(数组 []string, 并发安全 ...bool) *StrArray

NewStrArrayFrom 根据给定的切片 `array` 创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func X创建文本并从数组复制 

func X创建文本并从数组复制(数组 []string, 并发安全 ...bool) *StrArray

NewStrArrayFromCopy 通过复制给定切片 `array` 创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全环境下使用该数组，默认为 false。

func X创建文本并按大小 

func X创建文本并按大小(大小 int, 上限 int, 并发安全 ...bool) *StrArray

NewStrArraySize 根据给定的大小和容量创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全的情况下使用数组，默认为 false。

func (*StrArray) Append别名 

func (a *StrArray) Append别名(值 ...string) *StrArray

Append 是 PushRight 的别名，请参阅 PushRight。

func (*StrArray) DeepCopy 

func (a *StrArray) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (StrArray) MarshalJSON 

func (a StrArray) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。 注意：此处接收者不使用指针。

Example 
package main

import (
	"fmt"

	"github.com/888go/goframe/internal/json"
)

func main() {
	type Student struct {
		Id      int
		Name    string
		Lessons []string
	}
	s := Student{
		Id:      1,
		Name:    "john",
		Lessons: []string{"Math", "English", "Music"},
	}
	b, _ := json.Marshal(s)
	fmt.Println(string(b))

}

Output:

{"Id":1,"Name":"john","Lessons":["Math","English","Music"]}

func (*StrArray) String 

func (a *StrArray) String() string

String 方法将当前数组以字符串形式返回，其实现方式类似于 json.Marshal。

Example 
s := 数组类.X创建文本并从数组(g.SliceStr别名{"a", "b", "c"})
fmt.Println(s.String())

Output:

["a","b","c"]

func (*StrArray) UnmarshalJSON 

func (a *StrArray) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
type Student struct {
	Id      int
	Name    string
	Lessons *数组类.StrArray
}
s := Student{}
json.Unmarshal(b, &s)
fmt.Println(s)

Output:

{1 john ["Math","English","Sport"]}

func (*StrArray) UnmarshalValue 

func (a *StrArray) UnmarshalValue(value interface{}) error

UnmarshalValue 实现了一个接口，该接口用于为数组设置任意类型的值。

Example 
type Student struct {
	Name    string
	Lessons *数组类.StrArray
}
var s *Student
转换类.Struct(g.Map{
	"name":    "john",
	"lessons": []byte(`["Math","English","Sport"]`),
}, &s)
fmt.Println(s)

var s1 *Student
转换类.Struct(g.Map{
	"name":    "john",
	"lessons": g.SliceStr别名{"Math", "English", "Sport"},
}, &s1)
fmt.Println(s1)

Output:

&{john ["Math","English","Sport"]}
&{john ["Math","English","Sport"]}

func (*StrArray) X倒排序 

func (a *StrArray) X倒排序() *StrArray

Reverse 将数组元素按逆序排列生成新数组。

func (*StrArray) X入栈右 

func (a *StrArray) X入栈右(值 ...string) *StrArray

PushRight将一个或多个元素推送到数组的末尾。 它等同于Append。

func (*StrArray) X入栈左 

func (a *StrArray) X入栈左(值 ...string) *StrArray

PushLeft 将一个或多个元素推送到数组的起始位置。

func (*StrArray) X出栈右 

func (a *StrArray) X出栈右() (值 string, 成功 bool)

PopRight从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则`found`为false。

func (*StrArray) X出栈右多个 

func (a *StrArray) X出栈右多个(数量 int) []string

PopRights 从数组末尾弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回nil。

func (*StrArray) X出栈左 

func (a *StrArray) X出栈左() (值 string, 成功 bool)

PopLeft 从数组开头弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*StrArray) X出栈左多个 

func (a *StrArray) X出栈左多个(数量 int) []string

PopLefts 从数组开头弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，则返回nil。

func (*StrArray) X出栈随机 

func (a *StrArray) X出栈随机() (值 string, 成功 bool)

PopRand 随机地从数组中弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。

func (*StrArray) X出栈随机多个 

func (a *StrArray) X出栈随机多个(数量 int) []string

PopRands 随机地从数组中弹出并返回 `size` 个元素。 若给定的 `size` 大于数组的大小，则返回数组中的所有元素。 注意，如果给定的 `size` 小于等于0或者数组为空，它将返回 nil。

func (*StrArray) X分割 

func (a *StrArray) X分割(数量 int) [][]string

Chunk 函数将一个数组分割成多个子数组， 每个子数组的大小由参数 `size` 确定。 最后一个子数组可能包含少于 size 个元素。

func (*StrArray) X删除 

func (a *StrArray) X删除(索引 int) (值 string, 成功 bool)

Remove 通过索引移除一个元素。 如果给定的 `index` 超出了数组范围，`found` 将为 false。

func (*StrArray) X删除值 

func (a *StrArray) X删除值(值 string) bool

RemoveValue 通过值移除一个元素。 若在数组中找到该值，则返回 true，否则（未找到时）返回 false。

func (*StrArray) X删除多个值 

func (a *StrArray) X删除多个值(值 ...string)

RemoveValues 通过 `values` 移除多个项目。

func (*StrArray) X删除所有空值 

func (a *StrArray) X删除所有空值() *StrArray

FilterEmpty 从数组中移除所有空字符串值。

func (*StrArray) X去重 

func (a *StrArray) X去重() *StrArray

Unique 函数用于对数组去重，清除重复的元素。 示例：[1,1,2,3,2] -> [1,2,3]

func (*StrArray) X取any数组 

func (a *StrArray) X取any数组() []interface{}

Interfaces 函数将当前数组转换为 []interface{} 类型并返回。

func (*StrArray) X取值 

func (a *StrArray) X取值(索引 int) (值 string)

At 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，它将返回一个空字符串。

func (*StrArray) X取值2 

func (a *StrArray) X取值2(索引 int) (值 string, 成功 bool)

Get 通过指定的索引返回值。 如果给定的 `index` 超出了数组的范围，那么 `found` 将为 false。

func (*StrArray) X取值随机 

func (a *StrArray) X取值随机() (值 string, 成功 bool)

Rand 随机地从数组中返回一个元素（不删除）。

func (*StrArray) X取值随机多个 

func (a *StrArray) X取值随机多个(数量 int) []string

Rands 随机返回数组中的 `size` 个元素（不删除）。

func (*StrArray) X取切片 

func (a *StrArray) X取切片() []string

Slice 返回数组的基础数据。 注意，如果它在并发安全的使用场景下，会返回基础数据的一个副本， 否则，则返回指向基础数据的指针。

func (*StrArray) X取切片并按数量 

func (a *StrArray) X取切片并按数量(起点 int, 数量 ...int) []string

SubSlice 返回数组中由 `offset` 和 `size` 参数指定的元素子序列，并将其作为切片。 若在并发安全场景下使用，返回该切片的副本；否则返回指向切片的指针。

如果 offset 非负，则序列从数组该偏移位置开始。 如果 offset 为负，则序列从数组末尾向前偏移该距离的位置开始。

如果提供了 length 并且为正数，则序列将包含最多该数量的元素。 若数组长度小于 length，则序列仅包含数组中可获得的元素。 如果 length 为负数，则序列将在数组末尾向前停在该距离的位置。 如果未提供 length，则序列包含从 offset 开始直到数组末尾的所有元素。

若有任何可能穿越数组左边界的情况，函数将失败。

func (*StrArray) X取切片并按范围 

func (a *StrArray) X取切片并按范围(起点 int, 终点 ...int) []string

Range 函数通过范围选择并返回数组中的元素，类似于 array[start:end]。 注意：在并发安全的使用场景下，它会返回一个原数据的副本；否则，返回的是底层数据的指针。

如果 `end` 为负数，则偏移量将从数组末尾开始计算。 如果省略了 `end`，则序列将包含从 start 开始直到数组末尾的所有元素。

func (*StrArray) X取副本 

func (a *StrArray) X取副本() (新数组 *StrArray)

Clone 返回一个新的数组，它是当前数组的一个副本。

func (*StrArray) X取文本 

func (a *StrArray) X取文本() string

func (*StrArray) X取长度 

func (a *StrArray) X取长度() int

Len 返回数组的长度。

func (*StrArray) X合并 

func (a *StrArray) X合并(数组 interface{}) *StrArray

Merge 将`array`合并到当前数组中。 参数`array`可以是任何garray类型或切片类型。 Merge 和 Append 的区别在于，Append 仅支持特定类型的切片作为参数， 而 Merge 支持更多类型的参数。

func (*StrArray) X填充 

func (a *StrArray) X填充(起点 int, 填充数量 int, 值 string) error

Fill 用 `value` 值填充数组，填充 num 个条目， 键（索引）从 `startIndex` 参数开始。

func (*StrArray) X填满 

func (a *StrArray) X填满(总数量 int, 值 string) *StrArray

Pad 通过 `value` 值对数组进行填充，以达到指定长度。 如果 size 为正数，则在数组右侧进行填充；若为负数，则在左侧填充。 若 `size` 的绝对值小于或等于数组的长度，则不进行填充操作。

func (*StrArray) X排序函数 

func (a *StrArray) X排序函数(回调函数 func(v1, v2 string) bool) *StrArray

SortFunc 通过自定义函数 `less` 对数组进行排序。

func (*StrArray) X排序递增 

func (a *StrArray) X排序递增(降序 ...bool) *StrArray

Sort 函数用于将数组按升序排序。 参数 `reverse` 控制排序方式，若 reverse 为 true，则按降序（默认为升序）排序。

func (*StrArray) X插入前面 

func (a *StrArray) X插入前面(索引 int, 值 ...string) error

InsertBefore 将 `values` 插入到 `index` 之前的位置。

func (*StrArray) X插入后面 

func (a *StrArray) X插入后面(索引 int, 值 ...string) error

InsertAfter 在`index`之后插入`values`。

func (*StrArray) X是否为空 

func (a *StrArray) X是否为空() bool

IsEmpty 检查数组是否为空。

func (*StrArray) X是否存在 

func (a *StrArray) X是否存在(值 string) bool

Contains 检查某个值是否存在于数组中。

func (*StrArray) X是否存在并忽略大小写 

func (a *StrArray) X是否存在并忽略大小写(值 string) bool

ContainsI 检查一个值是否以不区分大小写的方式存在于数组中。 注意，它在内部会遍历整个数组并进行不区分大小写的比较。

func (*StrArray) X替换 

func (a *StrArray) X替换(数组 []string) *StrArray

Replace 从数组起始位置开始，使用给定的`array`替换原有数组元素。

func (*StrArray) X查找 

func (a *StrArray) X查找(值 string) int

Search 在数组中通过 `value` 进行搜索，返回 `value` 的索引， 若不存在，则返回 -1。

func (*StrArray) X求和 

func (a *StrArray) X求和() (值 int)

Sum 返回数组中所有值的和。

func (*StrArray) X清空 

func (a *StrArray) X清空() *StrArray

清空删除当前数组中的所有元素。

func (*StrArray) X统计 

func (a *StrArray) X统计() map[string]int

CountValues 计算数组中所有值出现的次数。

func (*StrArray) X设置值 

func (a *StrArray) X设置值(索引 int, 值 string) error

Set将值设置到指定的索引位置。

func (*StrArray) X设置数组 

func (a *StrArray) X设置数组(数组 []string) *StrArray

SetArray 将底层的切片数组设置为给定的 `array`。

func (*StrArray) X连接 

func (a *StrArray) X连接(连接符 string) string

Join 通过字符串 `glue` 连接数组元素。

func (*StrArray) X遍历 

func (a *StrArray) X遍历(回调函数 func(k int, v string) bool)

Iterator 是 IteratorAsc 的别名。

func (*StrArray) X遍历修改 

func (a *StrArray) X遍历修改(回调函数 func(值 string) string) *StrArray

Walk 对数组中的每一项应用用户提供的函数 `f`。

func (*StrArray) X遍历写锁定 

func (a *StrArray) X遍历写锁定(回调函数 func(数组 []string)) *StrArray

LockFunc 通过回调函数`f`进行写入锁定。

func (*StrArray) X遍历删除 

func (a *StrArray) X遍历删除(回调函数 func(索引 int, 值 string) bool) *StrArray

Filter 对数组进行迭代，并通过自定义回调函数进行元素过滤。 如果回调函数 `filter` 返回 true，则从数组中移除该元素； 否则不做任何处理并继续迭代。

func (*StrArray) X遍历升序 

func (a *StrArray) X遍历升序(回调函数 func(k int, v string) bool)

IteratorAsc 以升序遍历给定数组，并使用回调函数 `f` 进行只读操作。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止遍历。

func (*StrArray) X遍历读锁定 

func (a *StrArray) X遍历读锁定(回调函数 func(数组 []string)) *StrArray

RLockFunc 通过回调函数`f`锁定读取操作。

func (*StrArray) X遍历降序 

func (a *StrArray) X遍历降序(回调函数 func(k int, v string) bool)

IteratorDesc 函数以降序遍历给定的数组，并使用指定回调函数 `f` 进行只读操作。 若 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

func (*StrArray) X随机排序 

func (a *StrArray) X随机排序() *StrArray

Shuffle 随机地对数组进行洗牌。

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.