数组类

package
v0.0.0-...-7e18bce Latest Latest
Warning

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

 Go to latest Published: Sep 4, 2024 License: MIT Imports: 15 Imported by: 0

Documentation

Overview

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

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 语言数组。 它包含一个并发安全/不安全的开关，应该在初始化时设置，并且不能随后更改。 md5:e0c9364387271f37

func NewArray别名 

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

NewArray别名 是 New 的别名，请查看 New 函数的说明。 md5:aa9968eb61e7efdd

func NewFromCopy别名 

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

NewFromCopy别名 是 NewArrayFromCopy 的别名。 参考 NewArrayFromCopy 的说明。 md5:5a0cadfeeacb74a6

func NewFrom别名 

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

NewFrom别名 是 NewArrayFrom 的别名。 参见 NewArrayFrom。 md5:bd6788065fd84cb7

func X创建 

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

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

func X创建并从数组 

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

newArrayFrom 创建并返回一个具有给定切片 `array` 的数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:abda2f52425c13a3

func X创建并从数组复制 

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

newArrayFromCopy 从给定切片 `array` 的副本创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:d7ac2661190a4f12

func X创建并按大小 

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

X创建并按大小 创建并返回一个具有给定大小和容量的数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:b667b71edd7dd0a0

func X创建并按范围 

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

newArrayRange 创建并返回一个范围从 `start` 到 `end`，步长为 `step` 的数组。 md5:92f64f2571842316

func (*Array) Append别名 

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

Append别名 是 PushRight 的别名，请查看 PushRight 说明。 md5:66b758835bf0db52

func (*Array) DeepCopy 

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

DeepCopy实现当前类型的深拷贝接口。 md5:9cfbcb08109f6ce1

func (Array) MarshalJSON 

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

MarshalJSON实现了json.Marshal接口的MarshalJSON方法。 注意，这里不要使用指针作为接收者。 md5:b4f76062b07a5263

func (*Array) String 

func (a *Array) String() string

String 将当前数组转换为字符串，其实现方式类似于 json.Marshal。 md5:feda8f29233cde8d

func (*Array) UnmarshalJSON 

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

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

func (*Array) UnmarshalValue 

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

UnmarshalValue 是一个接口实现，用于为数组设置任何类型的数据值。 md5:35211e747ab939ab

func (*Array) X倒排序 

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

X倒排序 函数将数组元素反转顺序。 md5:cc34cd0a2fa08e1c

func (*Array) X入栈右 

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

X入栈右 将一个或多个元素添加到数组的末尾。 它等同于 Append。 md5:bb33f2edfdfd9896

func (*Array) X入栈左 

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

X入栈左 将一个或多个项目推送到数组的开头。 md5:9062afab48970bed

func (*Array) X出栈右 

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

X出栈右 从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。 md5:207fa7c7c4a04a10

func (*Array) X出栈右多个 

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

X出栈右多个 从数组末尾移除并返回 `size` 个元素。 md5:0b04e6ad99e5349b

func (*Array) X出栈左 

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

X出栈左 从数组的开头弹出并返回一个项目。 注意，如果数组为空，`found` 为 false。 md5:68f14002d84594a4

func (*Array) X出栈左多个 

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

X出栈左多个 从数组开头弹出并返回 `size` 个元素。 md5:4a903258f1fe1dd4

func (*Array) X出栈随机 

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

X出栈随机 从数组中随机弹出并返回一个元素。 注意，如果数组为空，`found` 将为 false。 md5:29338267db400401

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

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

X出栈随机多个 随机地从数组中弹出并返回 `size` 个元素。 md5:3e1b1cbd52abd4cf

func (*Array) X分割 

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

X分割 将一个数组分割成多个子数组，每个子数组的大小由 `size` 决定。最后一个子数组可能包含少于 `size` 个元素。 md5:0f1f74ff34633d24

func (*Array) X删除 

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

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

func (*Array) X删除值 

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

X删除值 函数根据值删除一个元素。 如果值在数组中找到，它将返回 true，否则如果未找到则返回 false。 md5:c49c7706ce703d00

func (*Array) X删除多个值 

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

X删除多个值 根据`values`移除多个项目。 md5:fbdf68fa6a8cdd26

func (*Array) X删除所有nil 

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

X删除所有nil 删除数组中的所有空值（nil）。 md5:df6d66c2056b4815

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

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

X删除所有空值 移除数组中的所有空值。 被认为是空的值包括：0，nil，false，""，切片、映射（map）或通道（channel）的长度为0。 md5:da01f627cd0962db

func (*Array) X去重 

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

X去重 去除数组中的重复元素。 例如：[1,1,2,3,2] -> [1,2,3] md5:5083aa414231fd30

func (*Array) X取any数组 

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

X取any数组 将当前数组作为 []interface{} 返回。 md5:f7a2e3459e185314

func (*Array) X取值 

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

X取值 通过指定的索引返回值。 如果给定的`index`超出了数组的范围，它将返回`nil`。 md5:09a7e6585d2eba1a

func (*Array) X取值2 

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

X取值2 函数通过指定的索引返回值。 如果给定的 `index` 超出了数组范围，`found` 将为 false。 md5:ab300cfc0d6dd8ee

func (*Array) X取值随机 

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

X取值随机 随机从数组中返回一个元素（不进行删除）。 md5:e152d2c5bc15ecd7

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

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

X取值随机多个 随机从数组中返回 `size` 个元素（不删除）。 md5:09ad7802f8190e3c

func (*Array) X取副本 

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

X取副本 返回一个新的数组，它是当前数组的副本。 md5:52ada4030c562295

func (*Array) X取数组 

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

X取数组 返回数组的底层数据。 注意，如果在并发安全的使用情况下，它会返回底层数据的副本，否则返回底层数据的指针。 md5:111cbee45795a58b

func (*Array) X取数组并按数量 

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

X取数组并按数量 返回数组中指定的一段元素切片。 如果在并发安全的使用场景下，它将返回切片的一个副本；否则返回切片的指针。

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

如果提供了长度（size）且为正数，那么序列将包含最多这么多元素。 如果数组比指定的长度短，则序列只包含可用的数组元素。 如果长度为负数，则序列将在距离数组末尾该数量的元素处停止。 如果省略长度参数，那么序列将从偏移量开始直到数组末尾的所有元素。

如果切片范围的起始位置超出数组左侧边界，操作将失败。 md5:f87ecd35d1dd7ac8

func (*Array) X取数组并按范围 

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

X取数组并按范围通过范围选择并返回项目，就像数组[start:end]一样。 请注意，如果在并发安全使用中，它将返回切片的副本；否则返回底层数据的指针。

如果`end`为负数，则偏移量将从数组末尾开始。 如果省略`end`，则序列将包含从`start`到数组结尾的所有内容。 md5:8b71690536bb9ec5

func (*Array) X取文本 

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

zj:

func (*Array) X取长度 

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

X取长度 返回数组的长度。 md5:593b37501e98da95

func (*Array) X合并 

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

X合并 将 `array` 合并到当前数组中。 参数 `array` 可以是任何 garray 或切片类型。 X合并 和 Append 的区别在于，Append 只支持特定的切片类型， 而 X合并 支持更多种类的参数类型。 md5:465caccda38e84f8

func (*Array) X填充 

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

X填充 使用`value`值填充数组，从`startIndex`参数开始的num个条目。 md5:0a7d3daa806b72ca

func (*Array) X填满 

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

X填满 用`value`将数组填充到指定的长度。 如果大小为正数，则在右侧填充数组，如果为负数，则在左侧填充。 如果`size`的绝对值小于或等于数组的长度，则不进行填充。 md5:fbe08b371c540418

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

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

X排序并带函数 使用自定义函数 `less` 对数组进行排序。 md5:8da07d09bbd08513

func (*Array) X插入前面 

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

X插入前面 将`values`插入到`index`的前面。 md5:f5f3b46cd17ba885

func (*Array) X插入后面 

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

X插入后面 将 `values` 插入到 `index` 后面。 md5:b90b80fa75b6b6e0

func (*Array) X是否为空 

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

X是否为空 检查数组是否为空。 md5:fb6684351506a02d

func (*Array) X是否存在 

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

X是否存在 检查值是否存在于数组中。 md5:f209e1f30dd53cb2

func (*Array) X替换 

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

X替换 从数组的起始位置开始，使用给定的 `array` 替换数组中的元素。 md5:5acead2fd9ec0761

func (*Array) X查找 

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

X查找 在数组中搜索 `value`，返回 `value` 的索引， 如果不存在则返回 -1。 md5:787617bfeade8f93

func (*Array) X求和 

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

X求和 返回数组中所有值的和。 md5:b2148175a749b162

func (*Array) X清空 

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

X清空 删除当前数组中的所有项目。 md5:3d9c6d68a5719979

func (*Array) X统计 

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

X统计 计算数组中所有值出现的次数。 md5:95b4772dcb002365

func (*Array) X设置值 

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

X设置值 设置指定索引的值。 md5:7c1d7ea9df0b722c

func (*Array) X设置数组 

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

X设置数组 使用给定的 `array` 设置底层切片数组。 md5:160b43a5c0ec752c

func (*Array) X连接 

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

X连接 使用字符串 `glue` 连接数组元素。 md5:ec3894b049af1251

func (*Array) X遍历 

func (a *Array) X遍历(f func(k int, v interface{}) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

func (*Array) X遍历修改 

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

X遍历修改 将用户提供的函数 `f` 应用到数组的每个元素上。 md5:51e35ea7c2c6525c

func (*Array) X遍历删除 

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

X遍历删除 遍历数组，并使用自定义回调函数过滤元素。 如果回调函数`filter`返回true，它将从数组中移除该元素，否则不做任何操作并继续遍历。 md5:d33873cfb9f1bb38

func (*Array) X遍历升序 

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

X遍历升序 遍历数组，按照给定的回调函数 `f` 以升序进行只读访问。如果 `f` 返回 true，则继续遍历；否则停止。 md5:8a125e2dd8982d48

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

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

X遍历并写锁定 通过回调函数 `f` 实现写入锁定。 md5:d45a130fa9aa0af2

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

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

X遍历并读锁定 通过回调函数 `f` 实现读取锁定。 md5:a45deee1e6f17c88

func (*Array) X遍历降序 

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

X遍历降序 以降序遍历数组，并使用给定的回调函数`f`进行只读迭代。 如果`f`返回true，则继续遍历；如果返回false，则停止遍历。 md5:ea0a3805bccce0f7

func (*Array) X随机排序 

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

随机打乱数组。 md5:5897797461d9f11a

type IntArray 

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

IntArray 是一个功能丰富的 Go 语言整数数组。 它包含一个并发安全/不安全的开关，应该在初始化时设置并且不能更改。 md5:f21f7e3fb70f9176

func X创建整数 

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

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

func X创建整数并从数组 

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

X创建整数并从数组 创建并返回一个具有给定切片 `array` 的整数数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:3e01caa77a3b2f1d

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

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

X创建整数并从数组复制 根据给定的切片 `array` 创建并返回一个数组的副本。 参数 `safe` 用于指定是否使用并发安全的数组，默认为 false。 md5:cbbbaea27760e100

func X创建整数并按大小 

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

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

func X创建整数并按范围 

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

X创建整数并按范围 通过从 `start` 到 `end` 的范围，以步长 `step` 创建并返回一个整数数组。 md5:aec253ad1078e244

func (*IntArray) Append别名 

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

Append别名 是 PushRight 的别名，详情请参阅 PushRight。 md5:2f083a022f7fd9c3

func (*IntArray) DeepCopy 

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

DeepCopy实现当前类型的深拷贝接口。 md5:9cfbcb08109f6ce1

func (IntArray) MarshalJSON 

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

MarshalJSON实现了json.Marshal接口的MarshalJSON方法。 注意，这里不要使用指针作为接收者。 md5:b4f76062b07a5263

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"
	"gitee.com/go_888/goframe/internal/json"
)

func main() {
	type Student struct {
		Id     int
		Name   string
		Scores garray.IntArray
	}
	var array garray.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。 md5:feda8f29233cde8d

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"
)

func main() {
	s := garray.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方法。 md5:f6766b88cf3d63c2

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/internal/json"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Scores":[98,96,97]}`)
	type Student struct {
		Id     int
		Name   string
		Scores *garray.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 是一个接口实现，用于为数组设置任何类型的数据值。 md5:35211e747ab939ab

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"

	gconv "gitee.com/go_888/goframe/util/gconv"
)

func main() {
	type Student struct {
		Name   string
		Scores *garray.IntArray
	}

	var s *Student
	gconv.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

X倒排序 函数将数组元素反转顺序。 md5:cc34cd0a2fa08e1c

func (*IntArray) X入栈右 

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

X入栈右 将一个或多个元素添加到数组的末尾。 它等同于 Append。 md5:bb33f2edfdfd9896

func (*IntArray) X入栈左 

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

X入栈左 将一个或多个项目推送到数组的开头。 md5:9062afab48970bed

func (*IntArray) X出栈右 

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

X出栈右 从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。 md5:207fa7c7c4a04a10

func (*IntArray) X出栈右多个 

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

X出栈右多个 从数组末尾弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组中的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:4f44f32fbb68fb50

func (*IntArray) X出栈左 

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

X出栈左 从数组的开头弹出并返回一个项目。 注意，如果数组为空，`found` 为 false。 md5:68f14002d84594a4

func (*IntArray) X出栈左多个 

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

X出栈左多个 从数组开始处弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的长度，它将返回数组中的所有元素。 请注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:3ecbe066336a9849

func (*IntArray) X出栈随机 

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

X出栈随机 从数组中随机弹出并返回一个元素。 注意，如果数组为空，`found` 将为 false。 md5:29338267db400401

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

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

X出栈随机多个 随机地从数组中弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:9fd270d3d3021d32

func (*IntArray) X分割 

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

X分割 将一个数组分割成多个子数组，每个子数组的大小由 `size` 决定。最后一个子数组可能包含少于 `size` 个元素。 md5:0f1f74ff34633d24

func (*IntArray) X删除 

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

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

func (*IntArray) X删除值 

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

X删除值 函数根据值删除一个元素。 如果值在数组中找到，它将返回 true，否则如果未找到则返回 false。 md5:c49c7706ce703d00

func (*IntArray) X删除多个值 

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

X删除多个值 根据`values`移除多个项目。 md5:fbdf68fa6a8cdd26

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

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

X删除所有零值 移除数组中的所有零值。 md5:9155868b39243912

func (*IntArray) X去重 

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

X去重 去除数组中的重复元素。 例如：[1,1,2,3,2] -> [1,2,3] md5:5083aa414231fd30

func (*IntArray) X取any数组 

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

X取any数组 将当前数组作为 []interface{} 返回。 md5:f7a2e3459e185314

func (*IntArray) X取值 

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

X取值 函数返回指定索引处的值。 如果给定的 `index` 超出了数组的范围，它将返回 `0`。 md5:f1565bd13293ecb5

func (*IntArray) X取值2 

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

X取值2 函数通过指定的索引返回值。 如果给定的 `index` 超出了数组范围，`found` 将为 false。 md5:ab300cfc0d6dd8ee

func (*IntArray) X取值随机 

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

X取值随机 随机从数组中返回一个元素（不进行删除）。 md5:e152d2c5bc15ecd7

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

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

X取值随机多个 随机从数组中返回 `size` 个元素（不删除）。 md5:09ad7802f8190e3c

func (*IntArray) X取副本 

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

X取副本 返回一个新的数组，它是当前数组的副本。 md5:52ada4030c562295

func (*IntArray) X取数组 

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

X取数组 返回数组的底层数据。 注意，如果在并发安全的使用情况下，它会返回底层数据的副本，否则返回底层数据的指针。 md5:111cbee45795a58b

func (*IntArray) X取数组并按数量 

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

X取数组并按数量 返回数组中指定的一段元素切片。 如果在并发安全的使用场景下，它将返回切片的一个副本；否则返回切片的指针。

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

如果提供了长度（size）且为正数，那么序列将包含最多这么多元素。 如果数组比指定的长度短，则序列只包含可用的数组元素。 如果长度为负数，则序列将在距离数组末尾该数量的元素处停止。 如果省略长度参数，那么序列将从偏移量开始直到数组末尾的所有元素。

如果切片范围的起始位置超出数组左侧边界，操作将失败。 md5:f87ecd35d1dd7ac8

func (*IntArray) X取数组并按范围 

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

X取数组并按范围通过范围选择并返回项目，就像数组[start:end]一样。 请注意，如果在并发安全使用中，它将返回切片的副本；否则返回底层数据的指针。

如果`end`为负数，则偏移量将从数组末尾开始。 如果省略`end`，则序列将包含从`start`到数组结尾的所有内容。 md5:8b71690536bb9ec5

func (*IntArray) X取文本 

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

zj:

func (*IntArray) X取长度 

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

X取长度 返回数组的长度。 md5:593b37501e98da95

func (*IntArray) X合并 

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

X合并 将 `array` 合并到当前数组中。 参数 `array` 可以是任何 garray 或切片类型。 X合并 和 Append 的区别在于，Append 只支持特定的切片类型， 而 X合并 支持更多种类的参数类型。 md5:465caccda38e84f8

func (*IntArray) X填充 

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

X填充 使用`value`值填充数组，从`startIndex`参数开始的num个条目。 md5:0a7d3daa806b72ca

func (*IntArray) X填满 

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

X填满 用`value`将数组填充到指定的长度。 如果大小为正数，则在右侧填充数组，如果为负数，则在左侧填充。 如果`size`的绝对值小于或等于数组的长度，则不进行填充。 md5:fbe08b371c540418

func (*IntArray) X排序函数 

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

X排序函数 使用自定义函数 `less` 对数组进行排序。 md5:8da07d09bbd08513

func (*IntArray) X排序递增 

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

X排序递增 对数组进行升序排序。 参数 `reverse` 控制是按升序（默认）还是降序排序。 md5:c5974dc42c2259a0

func (*IntArray) X插入前面 

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

X插入前面 将`values`插入到`index`的前面。 md5:f5f3b46cd17ba885

func (*IntArray) X插入后面 

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

X插入后面 将`value`插入到`index`的末尾。 md5:8199bd4f98873d8d

func (*IntArray) X是否为空 

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

X是否为空 检查数组是否为空。 md5:fb6684351506a02d

func (*IntArray) X是否存在 

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

X是否存在 检查值是否存在于数组中。 md5:f209e1f30dd53cb2

func (*IntArray) X替换 

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

X替换 从数组的起始位置开始，使用给定的 `array` 替换数组中的元素。 md5:5acead2fd9ec0761

func (*IntArray) X查找 

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

X查找 在数组中搜索 `value`，返回 `value` 的索引， 如果不存在则返回 -1。 md5:787617bfeade8f93

func (*IntArray) X求和 

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

X求和 返回数组中所有值的和。 md5:b2148175a749b162

func (*IntArray) X清空 

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

X清空 删除当前数组中的所有项目。 md5:3d9c6d68a5719979

func (*IntArray) X统计 

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

X统计 计算数组中所有值出现的次数。 md5:95b4772dcb002365

func (*IntArray) X设置值 

func (a *IntArray) X设置值(index int, value int) error

X设置值 设置指定索引的值。 md5:7c1d7ea9df0b722c

func (*IntArray) X设置数组 

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

X设置数组 使用给定的 `array` 设置底层切片数组。 md5:160b43a5c0ec752c

func (*IntArray) X连接 

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

X连接 使用字符串 `glue` 连接数组元素。 md5:ec3894b049af1251

func (*IntArray) X遍历 

func (a *IntArray) X遍历(f func(k int, v int) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

func (*IntArray) X遍历修改 

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

X遍历修改 将用户提供的函数 `f` 应用到数组的每个元素上。 md5:51e35ea7c2c6525c

func (*IntArray) X遍历写锁定 

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

X遍历写锁定 通过回调函数 `f` 实现写入锁定。 md5:d45a130fa9aa0af2

func (*IntArray) X遍历删除 

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

X遍历删除 遍历数组，并使用自定义回调函数过滤元素。 如果回调函数`filter`返回true，它将从数组中移除该元素，否则不做任何操作并继续遍历。 md5:d33873cfb9f1bb38

func (*IntArray) X遍历升序 

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

X遍历升序 遍历数组，按照给定的回调函数 `f` 以升序进行只读访问。如果 `f` 返回 true，则继续遍历；否则停止。 md5:8a125e2dd8982d48

func (*IntArray) X遍历读锁定 

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

X遍历读锁定 通过回调函数 `f` 实现读取锁定。 md5:a45deee1e6f17c88

func (*IntArray) X遍历降序 

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

X遍历降序 以降序遍历数组，并使用给定的回调函数`f`进行只读迭代。 如果`f`返回true，则继续遍历；如果返回false，则停止遍历。 md5:ea0a3805bccce0f7

func (*IntArray) X随机排序 

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

随机打乱数组。 md5:5897797461d9f11a

type SortedArray 

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

SortedArray 是一个功能丰富的 Go 语言排序数组。 默认情况下，它使用递增顺序，但可以通过设置自定义比较器进行更改。 它包含一个并发安全/不安全的开关，该开关应在初始化时设置并且不能更改。 md5:48308289d58755e8

func X创建排序 

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

X创建排序 创建并返回一个空的排序数组。 参数 `safe` 用于指定是否在并发安全环境下使用数组，默认为 false。 参数 `comparator` 用于比较数组中值的排序， 若返回值小于 0，表示 `a` 小于 `b`；`a` 将插入到 `b` 之前； 若返回值等于 0，表示 `a` 等于 `b`；`a` 将被 `b` 替换； 若返回值大于 0，表示 `a` 大于 `b`；`a` 将插入到 `b` 之后。 md5:72443a89d087c135

func X创建排序并从数组 

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

X创建排序并从数组 根据给定的切片 `array` 创建并返回一个排序数组。 参数 `safe` 用于指定是否使用并发安全的数组，默认为 false。 md5:764ff7e74cab303e

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

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

X创建排序并从数组复制 根据给定切片 `array` 的副本创建并返回一个已排序的数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:ec79e11f360050f4

func X创建排序并按大小 

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

X创建排序并按大小 创建并返回一个给定大小和容量的排序数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:827c3309faba84ac

func X创建排序并按范围 

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

X创建排序并按范围 创建并返回一个从 `start` 到 `end` 的范围，步长为 `step` 的数组。 md5:93c103a8dc8cf9d7

func (*SortedArray) Append别名 

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

Append别名 向已排序的数组中添加一个或多个值，数组将始终保持排序状态。 md5:f839b377c2c77f6b

func (*SortedArray) DeepCopy 

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

DeepCopy实现当前类型的深拷贝接口。 md5:9cfbcb08109f6ce1

func (SortedArray) MarshalJSON 

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

MarshalJSON实现了json.Marshal接口的MarshalJSON方法。 注意，这里不要使用指针作为接收者。 md5:b4f76062b07a5263

func (*SortedArray) String 

func (a *SortedArray) String() string

String 将当前数组转换为字符串，其实现方式类似于 json.Marshal。 md5:feda8f29233cde8d

func (*SortedArray) UnmarshalJSON 

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

UnmarshalJSON实现了json.Unmarshal接口的UnmarshalJSON方法。 注意，默认情况下，比较器被设置为字符串比较器。 md5:8af2d4d6f742bb31

func (*SortedArray) UnmarshalValue 

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

UnmarshalValue 是一个接口实现，用于为数组设置任何类型的价值。 注意，比较器默认设置为字符串比较器。 md5:5c9d5d1af1e97ec8

func (*SortedArray) X入栈右 

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

X入栈右 将一个或多个值添加到已排序的数组中，数组始终保持排序。它是Append函数的别名，请参阅Append。 md5:34facedfc7e1b731

func (*SortedArray) X出栈右 

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

X出栈右 从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。 md5:207fa7c7c4a04a10

func (*SortedArray) X出栈右多个 

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

X出栈右多个 从数组末尾移除并返回 `size` 个元素。 md5:0b04e6ad99e5349b

func (*SortedArray) X出栈左 

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

X出栈左 从数组的开头弹出并返回一个项目。 注意，如果数组为空，`found` 为 false。 md5:68f14002d84594a4

func (*SortedArray) X出栈左多个 

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

X出栈左多个 从数组开头弹出并返回 `size` 个元素。 md5:4a903258f1fe1dd4

func (*SortedArray) X出栈随机 

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

X出栈随机 从数组中随机弹出并返回一个元素。 注意，如果数组为空，`found` 将为 false。 md5:29338267db400401

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

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

X出栈随机多个 随机地从数组中弹出并返回 `size` 个元素。 md5:3e1b1cbd52abd4cf

func (*SortedArray) X分割 

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

X分割 将一个数组分割成多个子数组，每个子数组的大小由 `size` 决定。最后一个子数组可能包含少于 `size` 个元素。 md5:0f1f74ff34633d24

func (*SortedArray) X删除 

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

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

func (*SortedArray) X删除值 

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

X删除值 函数根据值删除一个元素。 如果值在数组中找到，它将返回 true，否则如果未找到则返回 false。 md5:c49c7706ce703d00

func (*SortedArray) X删除多个值 

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

X删除多个值 通过 `values` 删除一个项目。 md5:05e01eb00e998269

func (*SortedArray) X删除所有nil 

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

X删除所有nil 删除数组中的所有空值（nil）。 md5:df6d66c2056b4815

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

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

X删除所有空值 移除数组中的所有空值。 被认为是空的值包括：0，nil，false，""，切片、映射（map）或通道（channel）的长度为0。 md5:da01f627cd0962db

func (*SortedArray) X去重 

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

X去重 函数用于清除非唯一元素，确保数组中的每个元素都是唯一的。 md5:6dfd767cdbb67ed2

func (*SortedArray) X取any数组 

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

X取any数组 将当前数组作为 []interface{} 返回。 md5:f7a2e3459e185314

func (*SortedArray) X取值 

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

X取值 通过指定的索引返回值。 如果给定的`index`超出了数组的范围，它将返回`nil`。 md5:09a7e6585d2eba1a

func (*SortedArray) X取值2 

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

X取值2 函数通过指定的索引返回值。 如果给定的 `index` 超出了数组范围，`found` 将为 false。 md5:ab300cfc0d6dd8ee

func (*SortedArray) X取值随机 

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

X取值随机 随机从数组中返回一个元素（不进行删除）。 md5:e152d2c5bc15ecd7

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

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

X取值随机多个 随机从数组中返回 `size` 个元素（不删除）。 md5:09ad7802f8190e3c

func (*SortedArray) X取副本 

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

X取副本 返回一个新的数组，它是当前数组的副本。 md5:52ada4030c562295

func (*SortedArray) X取数组 

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

X取数组 返回数组的底层数据。 注意，如果在并发安全的使用情况下，它会返回底层数据的副本，否则返回底层数据的指针。 md5:111cbee45795a58b

func (*SortedArray) X取数组并按数量 

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

X取数组并按数量 返回数组中指定的一段元素切片。 如果在并发安全的使用场景下，它将返回切片的一个副本；否则返回切片的指针。

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

如果提供了长度（size）且为正数，那么序列将包含最多这么多元素。 如果数组比指定的长度短，则序列只包含可用的数组元素。 如果长度为负数，则序列将在距离数组末尾该数量的元素处停止。 如果省略长度参数，那么序列将从偏移量开始直到数组末尾的所有元素。

如果切片范围的起始位置超出数组左侧边界，操作将失败。 md5:f87ecd35d1dd7ac8

func (*SortedArray) X取数组并按范围 

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

X取数组并按范围通过范围选择并返回项目，就像数组[start:end]一样。 请注意，如果在并发安全使用中，它将返回切片的副本；否则返回底层数据的指针。

如果`end`为负数，则偏移量将从数组末尾开始。 如果省略`end`，则序列将包含从`start`到数组结尾的所有内容。 md5:8b71690536bb9ec5

func (*SortedArray) X取文本 

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

zj:

func (*SortedArray) X取长度 

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

X取长度 返回数组的长度。 md5:593b37501e98da95

func (*SortedArray) X合并 

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

X合并 将 `array` 合并到当前数组中。 参数 `array` 可以是任何 garray 或切片类型。 X合并 和 Append 的区别在于，Append 只支持特定的切片类型， 而 X合并 支持更多种类的参数类型。 md5:465caccda38e84f8

func (*SortedArray) X排序递增 

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

X排序递增 对数组进行升序排序。 参数 `reverse` 控制排序方式，如果为 true，则降序排列（默认为升序）。 md5:35d4650a0f563ccf

func (*SortedArray) X是否为空 

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

X是否为空 检查数组是否为空。 md5:fb6684351506a02d

func (*SortedArray) X是否存在 

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

X是否存在 检查值是否存在于数组中。 md5:f209e1f30dd53cb2

func (*SortedArray) X查找 

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

X查找 在数组中搜索 `value`，返回 `value` 的索引， 如果不存在则返回 -1。 md5:787617bfeade8f93

func (*SortedArray) X求和 

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

X求和 返回数组中所有值的和。 md5:b2148175a749b162

func (*SortedArray) X清空 

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

X清空 删除当前数组中的所有项目。 md5:3d9c6d68a5719979

func (*SortedArray) X统计 

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

X统计 计算数组中所有值出现的次数。 md5:95b4772dcb002365

func (*SortedArray) X设置去重 

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

X设置去重 将唯一标记设置到数组中， 这意味着它不包含任何重复的项目。 它还会进行唯一性检查，删除所有重复项。 md5:acbac75bf944670c

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

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

X设置排序函数 设置/更改排序的比较器。 当比较器更改时，它会重新对数组进行排序。 md5:1323d8fba2b97b75

func (*SortedArray) X设置数组 

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

X设置数组 使用给定的 `array` 设置底层切片数组。 md5:160b43a5c0ec752c

func (*SortedArray) X连接 

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

X连接 使用字符串 `glue` 连接数组元素。 md5:ec3894b049af1251

func (*SortedArray) X遍历 

func (a *SortedArray) X遍历(f func(k int, v interface{}) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

func (*SortedArray) X遍历修改 

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

X遍历修改 将用户提供的函数 `f` 应用到数组的每个元素上。 md5:51e35ea7c2c6525c

func (*SortedArray) X遍历写锁定 

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

X遍历写锁定 通过回调函数 `f` 实现写入锁定。 md5:d45a130fa9aa0af2

func (*SortedArray) X遍历删除 

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

X遍历删除 遍历数组，并使用自定义回调函数过滤元素。 如果回调函数`filter`返回true，它将从数组中移除该元素，否则不做任何操作并继续遍历。 md5:d33873cfb9f1bb38

func (*SortedArray) X遍历升序 

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

X遍历升序 遍历数组，按照给定的回调函数 `f` 以升序进行只读访问。如果 `f` 返回 true，则继续遍历；否则停止。 md5:8a125e2dd8982d48

func (*SortedArray) X遍历读锁定 

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

X遍历读锁定 通过回调函数 `f` 实现读取锁定。 md5:a45deee1e6f17c88

func (*SortedArray) X遍历降序 

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

X遍历降序 以降序遍历数组，并使用给定的回调函数`f`进行只读迭代。 如果`f`返回true，则继续遍历；如果返回false，则停止遍历。 md5:ea0a3805bccce0f7

type SortedIntArray 

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

SortedIntArray 是一个具有丰富功能的 Go 语言排序整数数组。 默认情况下，它使用升序排序，但可以通过设置自定义比较器来改变。 它包含一个并发安全/不安全的开关，应在初始化时设置，并且之后不能更改。 md5:5106a295d33aeafe

func X创建整数排序 

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

X创建整数排序 创建并返回一个空的排序数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:29a3eb47ff7212a7

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

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

X创建整数排序并从数组 创建并返回一个已排序的整数数组，使用给定的切片 `array`。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:31b8ab8b3ab6bf88

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

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

X创建整数排序并从数组复制 从给定切片 `array` 的副本创建并返回一个排序的整数数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:b520af8a99d30fcc

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

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

X创建整数排序并带排序函数 创建并返回一个空的已排序整数数组，使用指定的比较器。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:9049bb870ab7f29a

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

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

X创建整数排序并按大小 创建并返回一个给定大小和容量的有序整数数组。 参数 `safe` 用于指定是否使用并发安全的数组，默认为false。 md5:8ae629092f076b83

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

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

X创建整数排序并按范围 根据范围 `start` 到 `end` 以及步长 `step` 创建并返回一个排序后的整数数组。 md5:7835c3ca423dbb6b

func (*SortedIntArray) Append别名 

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

Append别名 向已排序的数组中添加一个或多个值，数组将始终保持排序状态。 md5:f839b377c2c77f6b

func (*SortedIntArray) DeepCopy 

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

DeepCopy实现当前类型的深拷贝接口。 md5:9cfbcb08109f6ce1

func (SortedIntArray) MarshalJSON 

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

MarshalJSON实现了json.Marshal接口的MarshalJSON方法。 注意，这里不要使用指针作为接收者。 md5:b4f76062b07a5263

func (*SortedIntArray) String 

func (a *SortedIntArray) String() string

String 将当前数组转换为字符串，其实现方式类似于 json.Marshal。 md5:feda8f29233cde8d

func (*SortedIntArray) UnmarshalJSON 

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

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

func (*SortedIntArray) UnmarshalValue 

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

UnmarshalValue 是一个接口实现，用于为数组设置任何类型的数据值。 md5:35211e747ab939ab

func (*SortedIntArray) X入栈右 

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

X入栈右 将一个或多个值添加到已排序的数组中，数组始终保持排序。它是Append函数的别名，请参阅Append。 md5:34facedfc7e1b731

func (*SortedIntArray) X出栈右 

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

X出栈右 从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。 md5:207fa7c7c4a04a10

func (*SortedIntArray) X出栈右多个 

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

X出栈右多个 从数组末尾弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组中的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:4f44f32fbb68fb50

func (*SortedIntArray) X出栈左 

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

X出栈左 从数组的开头弹出并返回一个项目。 注意，如果数组为空，`found` 为 false。 md5:68f14002d84594a4

func (*SortedIntArray) X出栈左多个 

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

X出栈左多个 从数组开始处弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的长度，它将返回数组中的所有元素。 请注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:3ecbe066336a9849

func (*SortedIntArray) X出栈随机 

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

X出栈随机 从数组中随机弹出并返回一个元素。 注意，如果数组为空，`found` 将为 false。 md5:29338267db400401

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

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

X出栈随机多个 随机地从数组中弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:9fd270d3d3021d32

func (*SortedIntArray) X分割 

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

X分割 将一个数组分割成多个子数组，每个子数组的大小由 `size` 决定。最后一个子数组可能包含少于 `size` 个元素。 md5:0f1f74ff34633d24

func (*SortedIntArray) X删除 

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

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

func (*SortedIntArray) X删除值 

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

X删除值 函数根据值删除一个元素。 如果值在数组中找到，它将返回 true，否则如果未找到则返回 false。 md5:c49c7706ce703d00

func (*SortedIntArray) X删除多个值 

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

X删除多个值 通过 `values` 删除一个项目。 md5:05e01eb00e998269

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

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

X删除所有空值 移除数组中的所有零值。 md5:9155868b39243912

func (*SortedIntArray) X去重 

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

X去重 函数用于清除非唯一元素，确保数组中的每个元素都是唯一的。 md5:6dfd767cdbb67ed2

func (*SortedIntArray) X取any数组 

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

X取any数组 将当前数组作为 []interface{} 返回。 md5:f7a2e3459e185314

func (*SortedIntArray) X取值 

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

X取值 函数返回指定索引处的值。 如果给定的 `index` 超出了数组的范围，它将返回 `0`。 md5:f1565bd13293ecb5

func (*SortedIntArray) X取值2 

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

X取值2 函数通过指定的索引返回值。 如果给定的 `index` 超出了数组范围，`found` 将为 false。 md5:ab300cfc0d6dd8ee

func (*SortedIntArray) X取值随机 

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

X取值随机 随机从数组中返回一个元素（不进行删除）。 md5:e152d2c5bc15ecd7

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

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

X取值随机多个 随机从数组中返回 `size` 个元素（不删除）。 md5:09ad7802f8190e3c

func (*SortedIntArray) X取副本 

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

X取副本 返回一个新的数组，它是当前数组的副本。 md5:52ada4030c562295

func (*SortedIntArray) X取数组 

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

X取数组 返回数组的底层数据。 注意，如果在并发安全的使用情况下，它会返回底层数据的副本，否则返回底层数据的指针。 md5:111cbee45795a58b

func (*SortedIntArray) X取数组并按数量 

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

X取数组并按数量 返回数组中指定的一段元素切片。 如果在并发安全的使用场景下，它将返回切片的一个副本；否则返回切片的指针。

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

如果提供了长度（size）且为正数，那么序列将包含最多这么多元素。 如果数组比指定的长度短，则序列只包含可用的数组元素。 如果长度为负数，则序列将在距离数组末尾该数量的元素处停止。 如果省略长度参数，那么序列将从偏移量开始直到数组末尾的所有元素。

如果切片范围的起始位置超出数组左侧边界，操作将失败。 md5:f87ecd35d1dd7ac8

func (*SortedIntArray) X取数组并按范围 

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

X取数组并按范围通过范围选择并返回项目，就像数组[start:end]一样。 请注意，如果在并发安全使用中，它将返回切片的副本；否则返回底层数据的指针。

如果`end`为负数，则偏移量将从数组末尾开始。 如果省略`end`，则序列将包含从`start`到数组结尾的所有内容。 md5:8b71690536bb9ec5

func (*SortedIntArray) X取文本 

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

zj:

func (*SortedIntArray) X取长度 

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

X取长度 返回数组的长度。 md5:593b37501e98da95

func (*SortedIntArray) X合并 

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

X合并 将 `array` 合并到当前数组中。 参数 `array` 可以是任何 garray 或切片类型。 X合并 和 Append 的区别在于，Append 只支持特定的切片类型， 而 X合并 支持更多种类的参数类型。 md5:465caccda38e84f8

func (*SortedIntArray) X排序递增 

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

X排序递增 按照递增顺序对数组进行排序。 参数 `reverse` 控制排序方式，如果为真，则按递减顺序排序（默认为递增排序）。 md5:13939809cd029411

func (*SortedIntArray) X是否为空 

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

X是否为空 检查数组是否为空。 md5:fb6684351506a02d

func (*SortedIntArray) X是否存在 

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

X是否存在 检查值是否存在于数组中。 md5:f209e1f30dd53cb2

func (*SortedIntArray) X查找 

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

X查找 在数组中搜索 `value`，返回 `value` 的索引， 如果不存在则返回 -1。 md5:787617bfeade8f93

func (*SortedIntArray) X求和 

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

X求和 返回数组中所有值的和。 md5:b2148175a749b162

func (*SortedIntArray) X清空 

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

X清空 删除当前数组中的所有项目。 md5:3d9c6d68a5719979

func (*SortedIntArray) X统计 

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

X统计 计算数组中所有值出现的次数。 md5:95b4772dcb002365

func (*SortedIntArray) X设置去重 

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

X设置去重 将唯一标记设置到数组中， 表示数组不包含任何重复的元素。 它还执行唯一性检查，移除所有重复的项。 md5:52bf11e8153b2459

func (*SortedIntArray) X设置数组 

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

X设置数组 使用给定的 `array` 设置底层切片数组。 md5:160b43a5c0ec752c

func (*SortedIntArray) X连接 

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

X连接 使用字符串 `glue` 连接数组元素。 md5:ec3894b049af1251

func (*SortedIntArray) X遍历 

func (a *SortedIntArray) X遍历(f func(k int, v int) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

func (*SortedIntArray) X遍历修改 

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

X遍历修改 将用户提供的函数 `f` 应用到数组的每个元素上。 md5:51e35ea7c2c6525c

func (*SortedIntArray) X遍历写锁定 

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

X遍历写锁定 通过回调函数 `f` 实现写入锁定。 md5:d45a130fa9aa0af2

func (*SortedIntArray) X遍历删除 

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

X遍历删除 遍历数组，并使用自定义回调函数过滤元素。 如果回调函数`filter`返回true，它将从数组中移除该元素，否则不做任何操作并继续遍历。 md5:d33873cfb9f1bb38

func (*SortedIntArray) X遍历升序 

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

X遍历升序 遍历数组，按照给定的回调函数 `f` 以升序进行只读访问。如果 `f` 返回 true，则继续遍历；否则停止。 md5:8a125e2dd8982d48

func (*SortedIntArray) X遍历读锁定 

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

X遍历读锁定 通过回调函数 `f` 实现读取锁定。 md5:a45deee1e6f17c88

func (*SortedIntArray) X遍历降序 

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

X遍历降序 以降序遍历数组，并使用给定的回调函数`f`进行只读迭代。 如果`f`返回true，则继续遍历；如果返回false，则停止遍历。 md5:ea0a3805bccce0f7

type SortedStrArray 

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

SortedStrArray 是一个具有丰富功能的 Go 语言排序字符串数组。 默认情况下，它使用递增顺序，可以通过设置自定义比较器来改变。 它包含一个并发安全/非安全开关，应在初始化时设置并且不能更改。 md5:5738650138eb500e

func X创建文本排序 

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

X创建文本排序 创建并返回一个空的有序数组。 参数 `safe` 用于指定是否使用并发安全的数组， 默认情况下为 false。 md5:99d40d03c8301a35

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

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

X创建文本排序并从数组 创建并返回一个已排序的数组，使用给定的切片 `array`。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:992cfc5cad0e6f7a

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

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

X创建文本排序并从数组复制 根据给定的切片`array`的副本创建并返回一个排序后的数组。 参数`safe`用于指定是否使用并发安全的数组，默认为false。 md5:e8cbae9d3604f7fc

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

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

X创建文本排序并带排序函数 创建并返回一个使用指定比较器的空排序数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:94666fc48998c3d3

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

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

X创建文本排序并按大小 创建并返回一个已排序的数组，给定大小和容量。 参数 `safe` 用于指定是否使用并发安全的数组，默认为 false。 md5:dd1a2b286a0cce79

func (*SortedStrArray) Append别名 

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

Append别名 向已排序的数组中添加一个或多个值，数组将始终保持排序状态。 md5:f839b377c2c77f6b

func (*SortedStrArray) DeepCopy 

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

DeepCopy实现当前类型的深拷贝接口。 md5:9cfbcb08109f6ce1

func (SortedStrArray) MarshalJSON 

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

MarshalJSON实现了json.Marshal接口的MarshalJSON方法。 注意，这里不要使用指针作为接收者。 md5:b4f76062b07a5263

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"
	"gitee.com/go_888/goframe/internal/json"
)

func main() {
	type Student struct {
		ID     int
		Name   string
		Levels garray.SortedStrArray
	}
	r := garray.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。 md5:feda8f29233cde8d

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"
)

func main() {
	s := garray.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方法。 md5:f6766b88cf3d63c2

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/internal/json"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
	type Student struct {
		Id      int
		Name    string
		Lessons *garray.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 是一个接口实现，用于为数组设置任何类型的数据值。 md5:35211e747ab939ab

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"

	gconv "gitee.com/go_888/goframe/util/gconv"
)

func main() {
	type Student struct {
		Name    string
		Lessons *garray.StrArray
	}
	var s *Student
	gconv.Struct(g.Map{
		"name":    "john",
		"lessons": []byte(`["Math","English","Sport"]`),
	}, &s)
	fmt.Println(s)

	var s1 *Student
	gconv.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

X入栈右 将一个或多个值添加到已排序的数组中，数组始终保持排序。它是Append函数的别名，请参阅Append。 md5:34facedfc7e1b731

func (*SortedStrArray) X出栈右 

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

X出栈右 从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。 md5:207fa7c7c4a04a10

func (*SortedStrArray) X出栈右多个 

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

X出栈右多个 从数组末尾弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组中的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:4f44f32fbb68fb50

func (*SortedStrArray) X出栈左 

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

X出栈左 从数组的开头弹出并返回一个项目。 注意，如果数组为空，`found` 为 false。 md5:68f14002d84594a4

func (*SortedStrArray) X出栈左多个 

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

X出栈左多个 从数组开始处弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的长度，它将返回数组中的所有元素。 请注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:3ecbe066336a9849

func (*SortedStrArray) X出栈随机 

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

X出栈随机 从数组中随机弹出并返回一个元素。 注意，如果数组为空，`found` 将为 false。 md5:29338267db400401

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

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

X出栈随机多个 随机地从数组中弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:9fd270d3d3021d32

func (*SortedStrArray) X分割 

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

X分割 将一个数组分割成多个子数组，每个子数组的大小由 `size` 决定。最后一个子数组可能包含少于 `size` 个元素。 md5:0f1f74ff34633d24

func (*SortedStrArray) X删除 

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

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

func (*SortedStrArray) X删除值 

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

X删除值 函数根据值删除一个元素。 如果值在数组中找到，它将返回 true，否则如果未找到则返回 false。 md5:c49c7706ce703d00

func (*SortedStrArray) X删除多个值 

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

X删除多个值 通过 `values` 删除一个项目。 md5:05e01eb00e998269

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

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

X删除所有空值 函数移除数组中的所有空字符串值。 md5:2b2e8cd6c844936a

func (*SortedStrArray) X去重 

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

X去重 函数用于清除非唯一元素，确保数组中的每个元素都是唯一的。 md5:6dfd767cdbb67ed2

func (*SortedStrArray) X取any数组 

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

X取any数组 将当前数组作为 []interface{} 返回。 md5:f7a2e3459e185314

func (*SortedStrArray) X取值 

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

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

func (*SortedStrArray) X取值2 

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

X取值2 函数通过指定的索引返回值。 如果给定的 `index` 超出了数组范围，`found` 将为 false。 md5:ab300cfc0d6dd8ee

func (*SortedStrArray) X取值随机 

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

X取值随机 随机从数组中返回一个元素（不进行删除）。 md5:e152d2c5bc15ecd7

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

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

X取值随机多个 随机从数组中返回 `size` 个元素（不删除）。 md5:09ad7802f8190e3c

func (*SortedStrArray) X取副本 

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

X取副本 返回一个新的数组，它是当前数组的副本。 md5:52ada4030c562295

func (*SortedStrArray) X取数组 

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

X取数组 返回数组的底层数据。 注意，如果在并发安全的使用情况下，它会返回底层数据的副本，否则返回底层数据的指针。 md5:111cbee45795a58b

func (*SortedStrArray) X取数组并按数量 

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

X取数组并按数量 返回数组中指定的一段元素切片。 如果在并发安全的使用场景下，它将返回切片的一个副本；否则返回切片的指针。

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

如果提供了长度（size）且为正数，那么序列将包含最多这么多元素。 如果数组比指定的长度短，则序列只包含可用的数组元素。 如果长度为负数，则序列将在距离数组末尾该数量的元素处停止。 如果省略长度参数，那么序列将从偏移量开始直到数组末尾的所有元素。

如果切片范围的起始位置超出数组左侧边界，操作将失败。 md5:f87ecd35d1dd7ac8

func (*SortedStrArray) X取数组并按范围 

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

X取数组并按范围通过范围选择并返回项目，就像数组[start:end]一样。 请注意，如果在并发安全使用中，它将返回切片的副本；否则返回底层数据的指针。

如果`end`为负数，则偏移量将从数组末尾开始。 如果省略`end`，则序列将包含从`start`到数组结尾的所有内容。 md5:8b71690536bb9ec5

func (*SortedStrArray) X取长度 

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

X取长度 返回数组的长度。 md5:593b37501e98da95

func (*SortedStrArray) X合并 

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

X合并 将 `array` 合并到当前数组中。 参数 `array` 可以是任何 garray 或切片类型。 X合并 和 Append 的区别在于，Append 只支持特定的切片类型， 而 X合并 支持更多种类的参数类型。 md5:465caccda38e84f8

func (*SortedStrArray) X排序递增 

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

X排序递增 按照递增顺序对数组进行排序。 参数 `reverse` 控制排序方式，如果为真，则按递减顺序排序（默认为递增排序）。 md5:13939809cd029411

func (*SortedStrArray) X是否为空 

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

X是否为空 检查数组是否为空。 md5:fb6684351506a02d

func (*SortedStrArray) X是否存在 

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

X是否存在 检查值是否存在于数组中。 md5:f209e1f30dd53cb2

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

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

X是否存在并忽略大小写 检查数组中是否存在某个值（忽略大小写）。 注意，它内部会遍历整个数组以进行不区分大小写的比较。 md5:faf76a65365aa0ac

func (*SortedStrArray) X查找 

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

X查找 在数组中搜索 `value`，返回 `value` 的索引， 如果不存在则返回 -1。 md5:787617bfeade8f93

func (*SortedStrArray) X求和 

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

X求和 返回数组中所有值的和。 md5:b2148175a749b162

func (*SortedStrArray) X清空 

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

X清空 删除当前数组中的所有项目。 md5:3d9c6d68a5719979

func (*SortedStrArray) X统计 

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

X统计 计算数组中所有值出现的次数。 md5:95b4772dcb002365

func (*SortedStrArray) X设置去重 

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

X设置去重 将唯一标记设置到数组中， 表示数组不包含任何重复的元素。 它还执行唯一性检查，移除所有重复的项。 md5:52bf11e8153b2459

func (*SortedStrArray) X设置数组 

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

X设置数组 使用给定的 `array` 设置底层切片数组。 md5:160b43a5c0ec752c

func (*SortedStrArray) X连接 

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

X连接 使用字符串 `glue` 连接数组元素。 md5:ec3894b049af1251

func (*SortedStrArray) X遍历 

func (a *SortedStrArray) X遍历(f func(k int, v string) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

func (*SortedStrArray) X遍历修改 

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

X遍历修改 将用户提供的函数 `f` 应用到数组的每个元素上。 md5:51e35ea7c2c6525c

func (*SortedStrArray) X遍历写锁定 

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

X遍历写锁定 通过回调函数 `f` 实现写入锁定。 md5:d45a130fa9aa0af2

func (*SortedStrArray) X遍历删除 

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

X遍历删除 遍历数组，并使用自定义回调函数过滤元素。 如果回调函数`filter`返回true，它将从数组中移除该元素，否则不做任何操作并继续遍历。 md5:d33873cfb9f1bb38

func (*SortedStrArray) X遍历升序 

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

X遍历升序 遍历数组，按照给定的回调函数 `f` 以升序进行只读访问。如果 `f` 返回 true，则继续遍历；否则停止。 md5:8a125e2dd8982d48

func (*SortedStrArray) X遍历读锁定 

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

X遍历读锁定 通过回调函数 `f` 实现读取锁定。 md5:a45deee1e6f17c88

func (*SortedStrArray) X遍历降序 

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

X遍历降序 以降序遍历数组，并使用给定的回调函数`f`进行只读迭代。 如果`f`返回true，则继续遍历；如果返回false，则停止遍历。 md5:ea0a3805bccce0f7

type StrArray 

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

StrArray 是一个具有丰富功能的 Go 语言字符串数组。 它包含一个并发安全/不安全的开关，该开关应在初始化时设置，并且之后不能更改。 md5:60bf9d0fe402df8a

func X创建文本 

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

X创建文本 创建并返回一个空数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:1a16d6b7fa6dc90d

func X创建文本并从数组 

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

X创建文本并从数组 根据给定的切片 `array` 创建并返回一个数组。 参数 `safe` 用于指定是否使用并发安全的数组，默认为 false。 md5:719d22a529b420db

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

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

X创建文本并从数组复制 根据给定切片 `array` 的副本创建并返回一个数组。 参数 `safe` 用于指定是否在并发安全环境下使用数组，默认为 false。 md5:71bd55b1c0df65be

func X创建文本并按大小 

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

X创建文本并按大小 创建并返回一个给定大小和容量的数组。 参数 `safe` 用于指定是否在并发安全模式下使用数组，默认为 false。 md5:d419c5b3ffb2a682

func (*StrArray) Append别名 

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

Append别名 是 PushRight 的别名，详情请参阅 PushRight。 md5:2f083a022f7fd9c3

func (*StrArray) DeepCopy 

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

DeepCopy实现当前类型的深拷贝接口。 md5:9cfbcb08109f6ce1

func (StrArray) MarshalJSON 

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

MarshalJSON实现了json.Marshal接口的MarshalJSON方法。 注意，这里不要使用指针作为接收者。 md5:b4f76062b07a5263

Example 
package main

import (
	"fmt"

	"gitee.com/go_888/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。 md5:feda8f29233cde8d

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"
)

func main() {
	s := garray.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方法。 md5:f6766b88cf3d63c2

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/internal/json"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
	type Student struct {
		Id      int
		Name    string
		Lessons *garray.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 是一个接口实现，用于为数组设置任何类型的数据值。 md5:35211e747ab939ab

Example 
package main

import (
	"fmt"

	garray "gitee.com/go_888/goframe/container/garray"
	"gitee.com/go_888/goframe/frame/g"

	gconv "gitee.com/go_888/goframe/util/gconv"
)

func main() {
	type Student struct {
		Name    string
		Lessons *garray.StrArray
	}
	var s *Student
	gconv.Struct(g.Map{
		"name":    "john",
		"lessons": []byte(`["Math","English","Sport"]`),
	}, &s)
	fmt.Println(s)

	var s1 *Student
	gconv.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

X倒排序 函数将数组元素反转顺序。 md5:cc34cd0a2fa08e1c

func (*StrArray) X入栈右 

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

X入栈右 将一个或多个元素添加到数组的末尾。 它等同于 Append。 md5:bb33f2edfdfd9896

func (*StrArray) X入栈左 

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

X入栈左 将一个或多个项目推送到数组的开头。 md5:9062afab48970bed

func (*StrArray) X出栈右 

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

X出栈右 从数组的末尾弹出并返回一个元素。 注意，如果数组为空，则 `found` 为 false。 md5:207fa7c7c4a04a10

func (*StrArray) X出栈右多个 

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

X出栈右多个 从数组末尾弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组中的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:4f44f32fbb68fb50

func (*StrArray) X出栈左 

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

X出栈左 从数组的开头弹出并返回一个项目。 注意，如果数组为空，`found` 为 false。 md5:68f14002d84594a4

func (*StrArray) X出栈左多个 

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

X出栈左多个 从数组开始处弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的长度，它将返回数组中的所有元素。 请注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:3ecbe066336a9849

func (*StrArray) X出栈随机 

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

X出栈随机 从数组中随机弹出并返回一个元素。 注意，如果数组为空，`found` 将为 false。 md5:29338267db400401

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

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

X出栈随机多个 随机地从数组中弹出并返回 `size` 个元素。 如果给定的 `size` 大于数组的大小，它将返回数组的所有元素。 注意，如果给定的 `size` 小于等于 0 或数组为空，它将返回 nil。 md5:9fd270d3d3021d32

func (*StrArray) X分割 

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

X分割 将一个数组分割成多个子数组，每个子数组的大小由 `size` 决定。最后一个子数组可能包含少于 `size` 个元素。 md5:0f1f74ff34633d24

func (*StrArray) X删除 

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

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

func (*StrArray) X删除值 

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

X删除值 函数根据值删除一个元素。 如果值在数组中找到，它将返回 true，否则如果未找到则返回 false。 md5:c49c7706ce703d00

func (*StrArray) X删除多个值 

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

X删除多个值 根据`values`移除多个项目。 md5:fbdf68fa6a8cdd26

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

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

X删除所有空值 函数移除数组中的所有空字符串值。 md5:2b2e8cd6c844936a

func (*StrArray) X去重 

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

X去重 去除数组中的重复元素。 例如：[1,1,2,3,2] -> [1,2,3] md5:5083aa414231fd30

func (*StrArray) X取any数组 

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

X取any数组 将当前数组作为 []interface{} 返回。 md5:f7a2e3459e185314

func (*StrArray) X取值 

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

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

func (*StrArray) X取值2 

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

X取值2 函数通过指定的索引返回值。 如果给定的 `index` 超出了数组范围，`found` 将为 false。 md5:ab300cfc0d6dd8ee

func (*StrArray) X取值随机 

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

X取值随机 随机从数组中返回一个元素（不进行删除）。 md5:e152d2c5bc15ecd7

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

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

X取值随机多个 随机从数组中返回 `size` 个元素（不删除）。 md5:09ad7802f8190e3c

func (*StrArray) X取副本 

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

X取副本 返回一个新的数组，它是当前数组的副本。 md5:52ada4030c562295

func (*StrArray) X取数组 

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

X取数组 返回数组的底层数据。 注意，如果在并发安全的使用情况下，它会返回底层数据的副本，否则返回底层数据的指针。 md5:111cbee45795a58b

func (*StrArray) X取数组并按数量 

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

X取数组并按数量 返回数组中指定的一段元素切片。 如果在并发安全的使用场景下，它将返回切片的一个副本；否则返回切片的指针。

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

如果提供了长度（size）且为正数，那么序列将包含最多这么多元素。 如果数组比指定的长度短，则序列只包含可用的数组元素。 如果长度为负数，则序列将在距离数组末尾该数量的元素处停止。 如果省略长度参数，那么序列将从偏移量开始直到数组末尾的所有元素。

如果切片范围的起始位置超出数组左侧边界，操作将失败。 md5:f87ecd35d1dd7ac8

func (*StrArray) X取数组并按范围 

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

X取数组并按范围通过范围选择并返回项目，就像数组[start:end]一样。 请注意，如果在并发安全使用中，它将返回切片的副本；否则返回底层数据的指针。

如果`end`为负数，则偏移量将从数组末尾开始。 如果省略`end`，则序列将包含从`start`到数组结尾的所有内容。 md5:8b71690536bb9ec5

func (*StrArray) X取文本 

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

zj:

func (*StrArray) X取长度 

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

X取长度 返回数组的长度。 md5:593b37501e98da95

func (*StrArray) X合并 

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

X合并 将 `array` 合并到当前数组中。 参数 `array` 可以是任何 garray 或切片类型。 X合并 和 Append 的区别在于，Append 只支持特定的切片类型， 而 X合并 支持更多种类的参数类型。 md5:465caccda38e84f8

func (*StrArray) X填充 

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

X填充 使用`value`值填充数组，从`startIndex`参数开始的num个条目。 md5:0a7d3daa806b72ca

func (*StrArray) X填满 

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

X填满 用`value`将数组填充到指定的长度。 如果大小为正数，则在右侧填充数组，如果为负数，则在左侧填充。 如果`size`的绝对值小于或等于数组的长度，则不进行填充。 md5:fbe08b371c540418

func (*StrArray) X排序函数 

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

X排序函数 使用自定义函数 `less` 对数组进行排序。 md5:8da07d09bbd08513

func (*StrArray) X排序递增 

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

X排序递增 对数组进行升序排序。 参数 `reverse` 控制排序方式，如果为 true，则降序排列（默认为升序）。 md5:35d4650a0f563ccf

func (*StrArray) X插入前面 

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

X插入前面 将`values`插入到`index`的前面。 md5:f5f3b46cd17ba885

func (*StrArray) X插入后面 

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

X插入后面 将 `values` 插入到 `index` 后面。 md5:b90b80fa75b6b6e0

func (*StrArray) X是否为空 

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

X是否为空 检查数组是否为空。 md5:fb6684351506a02d

func (*StrArray) X是否存在 

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

X是否存在 检查值是否存在于数组中。 md5:f209e1f30dd53cb2

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

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

X是否存在并忽略大小写 检查数组中是否存在某个值（忽略大小写）。 注意，它内部会遍历整个数组以进行不区分大小写的比较。 md5:faf76a65365aa0ac

func (*StrArray) X替换 

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

X替换 从数组的起始位置开始，使用给定的 `array` 替换数组中的元素。 md5:5acead2fd9ec0761

func (*StrArray) X查找 

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

X查找 在数组中搜索 `value`，返回 `value` 的索引， 如果不存在则返回 -1。 md5:787617bfeade8f93

func (*StrArray) X求和 

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

X求和 返回数组中所有值的和。 md5:b2148175a749b162

func (*StrArray) X清空 

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

X清空 删除当前数组中的所有项目。 md5:3d9c6d68a5719979

func (*StrArray) X统计 

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

X统计 计算数组中所有值出现的次数。 md5:95b4772dcb002365

func (*StrArray) X设置值 

func (a *StrArray) X设置值(index int, value string) error

X设置值 设置指定索引的值。 md5:7c1d7ea9df0b722c

func (*StrArray) X设置数组 

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

X设置数组 使用给定的 `array` 设置底层切片数组。 md5:160b43a5c0ec752c

func (*StrArray) X连接 

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

X连接 使用字符串 `glue` 连接数组元素。 md5:ec3894b049af1251

func (*StrArray) X遍历 

func (a *StrArray) X遍历(f func(k int, v string) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

func (*StrArray) X遍历修改 

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

X遍历修改 将用户提供的函数 `f` 应用到数组的每个元素上。 md5:51e35ea7c2c6525c

func (*StrArray) X遍历写锁定 

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

X遍历写锁定 通过回调函数 `f` 实现写入锁定。 md5:d45a130fa9aa0af2

func (*StrArray) X遍历删除 

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

X遍历删除 遍历数组，并使用自定义回调函数过滤元素。 如果回调函数`filter`返回true，它将从数组中移除该元素，否则不做任何操作并继续遍历。 md5:d33873cfb9f1bb38

func (*StrArray) X遍历升序 

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

X遍历升序 遍历数组，按照给定的回调函数 `f` 以升序进行只读访问。如果 `f` 返回 true，则继续遍历；否则停止。 md5:8a125e2dd8982d48

func (*StrArray) X遍历读锁定 

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

X遍历读锁定 通过回调函数 `f` 实现读取锁定。 md5:a45deee1e6f17c88

func (*StrArray) X遍历降序 

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

X遍历降序 以降序遍历数组，并使用给定的回调函数`f`进行只读迭代。 如果`f`返回true，则继续遍历；如果返回false，则停止遍历。 md5:ea0a3805bccce0f7

func (*StrArray) X随机排序 

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

随机打乱数组。 md5:5897797461d9f11a

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.