以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: https://pkg.go.dev/github.com/gogf/gf/v2/container/garray
Append
- 说明:向数组的尾部追加 数据,可以添加任意数量字符串。
Append
的方法是PushRight
的别名 - 格式:
Append(value ...string) *StrArray
- 示例:建立一个空数组,设置完数据后,并在数组尾部添加新的数据。
func ExampleStrArray_Append() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"We", "are", "GF", "fans"})
s.Append("a", "b", "c")
fmt.Println(s)
// Output:
// ["We","are","GF","fans","a","b","c"]
}
At
- 说明:返回数组指定索引的数据
- 格式:
At(index int) (value string)
- 示例:建立一个数组,找到
index
为2的数据。
func ExampleStrArray_At() {
s := garray.NewStrArrayFrom(g.SliceStr{"We", "are", "GF", "fans", "!"})
sAt := s.At(2)
fmt.Println(sAt)
// Output:
// GF
}
Chunk
- 说明:把指定数组按指定的大小
Size
,分割成多个数组,返回值为[][]string
。最后一个数组包含数据的数量可能小于Size
- 格式:
Chunk(size int) [][]string
- 示例:建立一个数组,并将该数组分割成3个数组。
func ExampleStrArray_Chunk() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.Chunk(3)
fmt.Println(r)
// Output:
// [[a b c] [d e f] [g h]]
}
Clear
- 说明:删除当前数组中所有的数据
- 格式:
Clear() *StrArray
- 示例:建立一个空数组,赋值后,并删除该数组的数据。
func ExampleStrArray_Clear() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s)
fmt.Println(s.Clear())
fmt.Println(s)
// Output:
// ["a","b","c","d","e","f","g","h"]
// []
// []
}
Clone
- 说明:克隆当前的数组。返回一个与当前数组相同的数组拷贝
- 格式:
Clone() (newArray *StrArray)
- 示例:建立一个空数组,赋值后,克隆出一个新数组。
func ExampleStrArray_Clone() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.Clone()
fmt.Println(r)
fmt.Println(s)
// Output:
// ["a","b","c","d","e","f","g","h"]
// ["a","b","c","d","e","f","g","h"]
}
Contains
- 说明:判断一个数组是否包含给定的
String
值。字符串严格区分大小写。返回值为bool
- 格式:
Contains(value string) bool
- 示例:建立一个空数组,设置完数据后,判断是否包含指定数据
e
和z
func ExampleStrArray_Contains() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Contains("e"))
fmt.Println(s.Contains("z"))
// Output:
// true
// false
}
ContainsI
- 说明:判断一个数组是否 包含给定的
String
值。字符串不区分大小写。返回值为bool
- 格式:
ContainsI(value string) bool
- 示例:建立一个空数组,设置完数据后,判断是否包含指定数据
E
和z
func ExampleStrArray_ContainsI() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.ContainsI("E"))
fmt.Println(s.ContainsI("z"))
// Output:
// true
// false
}
CountValues
- 说明:统计每个值在数组中出现的次数。返回值为
map[string]int
- 格式:
CountValues() map[string]int
- 示例:建立一个数组,统计数组中每个字符串包含的个数
func ExampleStrArray_CountValues() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
fmt.Println(s.CountValues())
// Output:
// map[a:1 b:1 c:3 d:2]
}
Fill
- 说明:在数组中指定的开始位置
startIndex
,用指定的value
进行填充。返回值为error
- 格式:
Fill(startIndex int, num int, value string) error
- 示例:建立一个数组,在数组开始位置
index
为2的地方,用字符串here
填充3个数据
func ExampleStrArray_Fill() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
s.Fill(2, 3, "here")
fmt.Println(s)
// Output:
// ["a","b","here","here","here","f","g","h"]
}
FilterEmpty
- 说明:过滤指定数组中的空字符串
- 格式:
FilterEmpty() *StrArray
- 示例:建立一个数组,在赋值后,过滤该数组中的空字符串
func ExampleStrArray_FilterEmpty() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "", "c", "", "", "d"})
fmt.Println(s.FilterEmpty())
// Output:
// ["a","b","c","d"]
}
Get
- 说明:返回数组中指定
index
的值,返回值有2个参数,返回值value
,和是否找到指定位置的数据found
,为true
则找到,为false
则未找到 - 格式:
Get(index int) (value string, found bool)
- 示例:建立一个数组,在赋值后,得到数组
index
为3的值
func ExampleStrArray_Get() {
s := garray.NewStrArrayFrom(g.SliceStr{"We", "are", "GF", "fans", "!"})
sGet, sBool := s.Get(3)
fmt.Println(sGet, sBool)
// Output:
// fans true
}
InsertAfter
- 说明:在数组中指定
index
的位置之后插入值value
,返回值为error
- 格式:
InsertAfter(index int, value string) error
- 示例:建立一个数组,在
index
为1的值之后,插入字符串here
func ExampleStrArray_InsertAfter() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.InsertAfter(1, "here")
fmt.Println(s.Slice())
// Output:
// [a b here c d]
}
InsertBefore
- 说明:在数组中指定
index
的位置之前插入值value
,返回值为error
- 格式:
InsertBefore(index int, value string) error
- 示例:建立一个数组并初始化,在
index
为1的值之前,插入字符串here
func ExampleStrArray_InsertBefore() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.InsertBefore(1, "here")
fmt.Println(s.Slice())
// Output:
// [a here b c d]
}
Interfaces
- 说明:把当前数组作为
[]interface{}
进行返回 - 格式:
Interfaces() []interface{}
- 示例:建立一个数组并初始化,并打印出返回值
[]interface{}
的内容
func ExampleStrArray_Interfaces() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.Interfaces()
fmt.Println(r)
// Output:
// [a b c d e f g h]
}
IsEmpty
- 说明:判断当前数组是不是 空数组,如果是空数组,则返回
true
,如果不是空数组,则返回false
- 格式:
IsEmpty() bool
- 示例:建立2个数组并初始化,并判断是否为空数组
func ExampleStrArray_IsEmpty() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "", "c", "", "", "d"})
fmt.Println(s.IsEmpty())
s1 := garray.NewStrArray()
fmt.Println(s1.IsEmpty())
// Output:
// false
// true
}
Iterator
- 说明:数组遍历
- 格式:
Iterator(f func(k int, v string) bool)
- 示例:建立1个数组,并对其进行遍历
func ExampleStrArray_Iterator() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
s.Iterator(func(k int, v string) bool {
fmt.Println(k, v)
return true
})
// Output:
// 0 a
// 1 b
// 2 c
}
IteratorAsc
- 说明:根据给定的回调函数
f
,按升序对数组进行遍历,如果f
返回true
,则继续进行遍历,否则停止遍历 - 格式:
IteratorAsc(f func(k int, v string) bool)
- 示例:建立1个数组,并按照自定义函数对其进行升序遍历
func ExampleStrArray_Iterator() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
s.Iterator(func(k int, v string) bool {
fmt.Println(k, v)
return true
})
// Output:
// 0 a
// 1 b
// 2 c
}
IteratorDesc
- 说明:根据给定的回调函数
f
,按降序对数组进行遍历,如果f
返回true
,则继续进行遍历,否则停止遍历 - 格式:
IteratorAsc(f func(k int, v string) bool)
- 示例:建立1个数组,并按照自定义函数对其进行降序遍历
func ExampleStrArray_IteratorDesc() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
s.IteratorDesc(func(k int, v string) bool {
fmt.Println(k, v)
return true
})
// Output:
// 2 c
// 1 b
// 0 a
}
Join
- 说明:将数组元素根据给定的字符串连接符
gule
,连接起来 - 格式:
Join(glue string) string
- 示例:给定连接符
','
,将数组中的字符串连接起来
func ExampleStrArray_Join() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
fmt.Println(s.Join(","))
// Output:
// a,b,c
}
Len
- 说明:得到数组的长度
- 格式:
Len() int
- 示例:建立一个新数组,初始化后得到该数组的长度
func ExampleStrArray_Len() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Len())
// Output:
// 8
}
LockFunc
- 说明:通过回调函数
f
对数组进行写锁定 - 格式:
LockFunc(f func(array []string)) *StrArray
- 示例:建立一个新数组,并对该数组在写锁定的状态下,修改最后一个数据
func ExampleStrArray_LockFunc() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
s.LockFunc(func(array []string) {
array[len(array)-1] = "GF fans"
})
fmt.Println(s)
// Output:
// ["a","b","GF fans"]
}
MarshalJSON
- 说明:实现
json.Marshal
的JSON
格式的序列化接口 - 格式:
MarshalJSON() ([]byte, error)
- 示例:建立一个新
JSON
格式的数据,并对该数据进行序列化的操作后,打印出相应结果
func ExampleStrArray_MarshalJSON() {
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"]}
}
Merge
- 说明:合并数组,将指定数组中的内容合并到当前数组中。参数
array
可以是任意garray
或slice
类型。Merge
和Append
的主要区别是Append
仅仅支持slice
类型,Merge
则支持更多 的参数类型 - 格式:
Merge(array interface{}) *StrArray
- 示例:建立2个新数组
s1
和s2
,并将s2
的数据合并到s1
上
func ExampleStrArray_Merge() {
s1 := garray.NewStrArray()
s2 := garray.NewStrArray()
s1.SetArray(g.SliceStr{"a", "b", "c"})
s2.SetArray(g.SliceStr{"d", "e", "f"})
s1.Merge(s2)
fmt.Println(s1)
// Output:
// ["a","b","c","d","e","f"]
}
NewStrArray
- 说明:创建一个新数组。
safe
为非必需参数,布尔型,是并发安全的开关,缺省值为False
- 格式:
NewStrArray(safe ...bool) *StrArray
- 示例:建立一个空数组,并添加数据。此时没有指定
Safe
参数,默认为非并发安全设置
func ExampleNewStrArray() {
s := garray.NewStrArray()
s.Append("We")
s.Append("are")
s.Append("GF")
s.Append("Fans")
fmt.Println(s.Slice())
// Output:
// [We are GF Fans]
}
NewStrArrayFrom
- 说明:根据给定的数组内容,创建一个新数组。
safe
为非必需参数,布尔型,是并发安全的开关,缺省值为False
- 格式:
NewStrArrayFrom(array []string, safe ...bool) *StrArray
- 示例:建立一个空数组,并根据指定内容添加数据。此时没有指定
Safe
参数,默认为非并发安全设置
func ExampleNewStrArrayFrom() {
s := garray.NewStrArrayFrom(g.SliceStr{"We", "are", "GF", "fans", "!"})
fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
// Output:
// [We are GF fans !] 5 5
}
NewStrArrayFromCopy
- 说明:根据给定的数组内容的拷贝,创建一个新数组。
safe
为非必需参数,布尔型,是并发安全的开关,缺省值为False
- 格式:
NewStrArrayFrom(array []string, safe ...bool) *StrArray
- 示例:建立一个空数组,并根据指定内容添加数据。此时没有指定
Safe
参数,默认为非并发安全设置
func ExampleNewStrArrayFromCopy() {
s := garray.NewStrArrayFromCopy(g.SliceStr{"We", "are", "GF", "fans", "!"})
fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
// Output:
// [We are GF fans !] 5 5
}
NewStrArraySize
- 说明:根据给定的
size
和cap
,创建一个新数组。safe
为非必需参数,布尔型,是并发安全的开关,缺省值为False
- 格式:
NewStrArraySize(size int, cap int, safe ...bool) *StrArray
- 示例:建立一个空数组,
Size为3
,Cap为5
,并添加数据。打印出相应的内容。此时没有指定Safe
参数,默认为非并发安全设置
func ExampleNewStrArraySize() {
s := garray.NewStrArraySize(3, 5)
s.Set(0, "We")
s.Set(1, "are")
s.Set(2, "GF")
s.Set(3, "fans")
fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
// Output:
// [We are GF] 3 5
}
Pad
- 说明:填充指定大小为
size
的值value
到数组中。如果大小size
是正数,则从数组的右边开始填充。如果size
是负数,则从数组的左边开始填充。如果size
的大小正好等于数组的长度,那么将不会填充任何数据。 - 格式:
Pad(size int, value string) *StrArray
- 示例:建立1个新数组,先从左边将数组,用指定的字符串
here
填充到size
为7,然后用指定的字符串there
将数组用字符串填充到size
为10
func ExampleStrArray_Pad() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
s.Pad(7, "here")
fmt.Println(s)
s.Pad(-10, "there")
fmt.Println(s)
// Output:
// ["a","b","c","here","here","here","here"]
// ["there","there","there","a","b","c","here","here","here","here"]
}
PopLeft
- 说明:从数组的左侧将一个字符串数据出栈,返回值
value
为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时,found
为false。
- 格式:
PopLeft() (value string, found bool)
- 示例:建立1个新数组,将最左边的数据出栈,并打印出剩余的数据
func ExampleStrArray_PopLeft() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.PopLeft()
fmt.Println(s.Slice())
// Output:
// [b c d]
}
PopLefts
- 说明:从数组的左侧将多个字符串数据出栈,返回值为出栈的字符串数据,出栈数据的个数为
size
。如果size
比数组的size
大,那么方法将返回数组中所有的数据。如果size<=0或者为空
,那么将返回nil
- 格式:
PopLefts(size int) []string
- 示例:建立1个新数组,将最左边的2个数据做出栈操作,并打印出出栈的数据和原数组的剩余数据
func ExampleStrArray_PopLefts() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.PopLefts(2)
fmt.Println(r)
fmt.Println(s)
// Output:
// [a b]
// ["c","d","e","f","g","h"]
}
PopRand
- 说明:从数组中随机出栈1个数据,返回值为出栈的字符串数据。如果数组
为空
,那么found
将返回false
- 格式:
PopRand() (value string, found bool)
- 示例:建立1个新数组,从数组中随机出栈1个数据,并打印出出栈的数据
func ExampleStrArray_PopRand() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r, _ := s.PopRand()
fmt.Println(r)
// May Output:
// e
}
PopRands
- 说明:从数组中随机出栈
size
个数据,返回值为出栈的字符串数据。如果size<=0或者为空
,那么将返回nil
- 格式:
PopRands(size int) []string
- 示例:建立1个新数组,从数组中随机出栈2个数据,并打印出出栈的数据
func ExampleStrArray_PopRands() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.PopRands(2)
fmt.Println(r)
// May Output:
// [e c]
}
PopRight
- 说明:从数组的右侧将一个字符串数据出栈,返回值
value
为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时,found
为false。
- 格式:
PopRight() (value string, found bool)
- 示例:建立1个新数组,将最右边的数据出栈,并打印出剩余的数据
func ExampleStrArray_PopRight() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.PopRight()
fmt.Println(s.Slice())
// Output:
// [a b c]
}
PopRights
- 说明:从数组的右侧将多个字符串数据出栈,返回值为出栈的字符串数据,出栈数据的个数为
size
。如果size
比数组的size
大,那么方法将返回数组中所有的数据。如果size<=0或者为空
,那么将返回nil
- 格式:
PopRights(size int) []string
- 示例:建立1个新数组,将最右边的2个数据做出栈操作,并打印出出栈的数据和原数组的剩余数据
func ExampleStrArray_PopRights() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.PopRights(2)
fmt.Println(r)
fmt.Println(s)
// Output:
// [g h]
// ["a","b","c","d","e","f"]
}
PushLeft
- 说明:从数组的左侧入栈一个或多个字符串
- 格式:
PushLeft(value ...string) *StrArray
- 示例:建立1个新数组,从数组的左侧入栈多个字符串数据,并打印出更新后的数据
func ExampleStrArray_PushLeft() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.PushLeft("We", "are", "GF", "fans")
fmt.Println(s.Slice())
// Output:
// [We are GF fans a b c d]
}
PushRight
- 说明:从数组的右侧入栈一个或多个字符串
- 格式:
PushRight(value ...string) *StrArray