Append
At
Chunk
Clear
Clone
Contains
ContainsI
CountValues
Fill
FilterEmpty
Get
InsertAfter
InsertBefore
Interfaces
IsEmpty
Iterator
IteratorAsc
IteratorDesc
Join
Len
LockFunc
MarshalJSON
Merge
NewStrArray
NewStrArrayFrom
NewStrArrayFromCopy
NewStrArraySize
Pad
PopLeft
PopLefts
PopRand
PopRands
PopRight
PopRights
PushLeft
PushRight
Rand
Rands
Range
Remove
RemoveValue
Replace
Reverse
RLockFunc
Search
Set
SetArray
Shuffle
Slice
Sort
SortFunc
String
Subslice
Sum
Unique
UnmarshalJSON
UnmarshalValue
Walk
以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: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
为10func 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
示例:建立1个新数组,从数组的右侧入栈多个字符串数据,并打印出更新后的数据
func ExampleStrArray_PushRight() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.PushRight("We", "are", "GF", "fans")
fmt.Println(s.Slice())
// Output:
// [a b c d We are GF fans]
}
Rand
- 说明:从数组中随机取出1个字符串(非删除式)
格式:
Rand() (value string, found bool)
示例:建立1个新数组,从数组中随机取出一个字符串
func ExampleStrArray_Rand() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Rand())
// May Output:
// c true
}
Rands
- 说明:从数组中随机取出
size
个字符串(非删除式) 格式:
Rands(size int) []string
示例:建立1个新数组,从数组中随机取出3个字符串
func ExampleStrArray_Rands() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Rands(3))
// May Output:
// [e h e]
}
Range
- 说明:获取数组中指定范围的数据。如果是在并发安全的模式下使用,则该方法返回一个
slice
拷贝。 格式:
Range(start int, end ...int) []string
示例:建立1个新数组,获取数组从
index
为2至5位置的数据func ExampleStrArray_Range() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.Range(2, 5)
fmt.Println(r)
// Output:
// [c d e]
}
Remove
- 说明:从数组中移除位置在
index
处的数据。如果index
超过数组的边界,则found
返回false
格式:
Remove(index int) (value string, found bool)
示例:建立1个新数组,移除数组
index
为1的数据func ExampleStrArray_Remove() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.Remove(1)
fmt.Println(s.Slice())
// Output:
// [a c d]
}
RemoveValue
- 说明:从数组中移除指定的数据
value
。如果value
在数组中被找到,则found
返回true
,否则found
返回false
格式:
RemoveValue(value string) bool
示例:建立1个新数组,移除数组中值为
b
的数据func ExampleStrArray_RemoveValue() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d"})
s.RemoveValue("b")
fmt.Println(s.Slice())
// Output:
// [a c d]
}
Replace
- 说明:将原字符串数组用指定的字符串数组进行替换,替换从原数组的头部位置开始。
格式:
Replace(array []string) *StrArray
示例:建立1个新数组,并用指定的字符串数组进行替换
func ExampleStrArray_Replace() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"We", "are", "GF", "fans", "!"})
fmt.Println(s.Slice())
s.Replace(g.SliceStr{"Happy", "coding"})
fmt.Println(s.Slice())
// Output:
// [We are GF fans !]
// [Happy coding GF fans !]
}
Reverse
- 说明:将数组中的所有元素用倒序进行排序
格式:
Replace(array []string) *StrArray
示例:建立1个新数组,初始化后执行倒序操作并打印
func ExampleStrArray_Reverse() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Reverse())
// Output:
// ["h","g","f","e","d","c","b","a"]
}
RLockFunc
- 说明:通过自定义回调函数
f
进行数组的读锁定 格式:
RLockFunc(f func(array []string)) *StrArray
示例:建立1个新数组,在回调函数
f
中,对数组进行遍历,并打印出数组元素func ExampleStrArray_RLockFunc() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e"})
s.RLockFunc(func(array []string) {
for i := 0; i < len(array); i++ {
fmt.Println(array[i])
}
})
// Output:
// a
// b
// c
// d
// e
}
Search
- 说明:在数组中搜索指定的字符串,返回值为该值在数组中的
index
,如果没有查询到,则返回-1
格式:
Search(value string) int
示例:建立1个新数组,并在该数组中搜索字符串
e
和zfunc ExampleStrArray_Search() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Search("e"))
fmt.Println(s.Search("z"))
// Output:
// 4
// -1
}
Set
- 说明:给数组中指定位置的
index
设置值value
,如果index<0
或者index
超出了数组的边界,则返回错误error
格式:
Set(index int, value string) error
示例:建立1个新数组,长度为3,给数组设置值,值最终只按顺序设置到了
index
为2的位置,因为数组长度限制,最后一个值未设置成功func ExampleStrArray_Set() {
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())
// Output:
// [We are GF]
}
SetArray
- 说明:根据给定的
slice
数组内容给数组赋值 格式:
SetArray(array []string) *StrArray
示例:建立1个新数组,在给其赋值后,打印出来
func ExampleStrArray_SetArray() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"We", "are", "GF", "fans", "!"})
fmt.Println(s.Slice())
// Output:
// [We are GF fans !]
}
Shuffle
- 说明:将数组中的内容进行乱序排列
格式:
Shuffle() *StrArray
示例:建立1个新数组,在给其赋值后进行乱序排列,并打印出来
func ExampleStrArray_Shuffle() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Shuffle())
// May Output:
// ["a","c","e","d","b","g","f","h"]
}
Slice
- 说明:得到数组的
slice
切片数据,注意,如果是在并发安全模式下,返回的是一份拷贝数据,否则返回的是指向数据的指针 格式:
Shuffle() *StrArray
示例:建立1个新数组,在给其赋值后,并打印该数组的切片数据
func ExampleStrArray_Slice() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
fmt.Println(s.Slice())
// Output:
// [a b c d e f g h]
}
Sort
- 说明:对数组内容进行升序排序。
reverse
控制排序的方向,默认为true
升序,false
为降序 格式:
Sort(reverse ...bool) *StrArray
示例:建立1个新数组,在给其赋值后,并按升序进行排序
func ExampleStrArray_Sort() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"b", "d", "a", "c"})
a := s.Sort()
fmt.Println(a)
// Output:
// ["a","b","c","d"]
}
SortFunc
- 说明:通过自定义函数
less
对数组内容进行排序。 格式:
SortFunc(less func(v1, v2 string) bool) *StrArray
示例:建立1个新数组,在给其赋值后,首先用自定义函数对其进行降序排序,然后用自定义函数对其进行升序排序,并打印出相应的结果
func ExampleStrArray_SortFunc() {
s := garray.NewStrArrayFrom(g.SliceStr{"b", "c", "a"})
fmt.Println(s)
s.SortFunc(func(v1, v2 string) bool {
return gstr.Compare(v1, v2) > 0
})
fmt.Println(s)
s.SortFunc(func(v1, v2 string) bool {
return gstr.Compare(v1, v2) < 0
})
fmt.Println(s)
// Output:
// ["b","c","a"]
// ["c","b","a"]
// ["a","b","c"]
}
String
- 说明:将当前的数组转换成
string
, 格式:
String() string
示例:建立1个新数组,在给其赋值后,将数组转换成
string
,并打印出相应的结果func ExampleStrArray_String() {
s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
fmt.Println(s.String())
// Output:
// ["a","b","c"]
}
Subslice
- 说明:根据给定的偏离值
offset
和长度length
参数获得数组的切片,注意,如果是在并发安全模式下,返回拷贝数据,否则返回指向数据的指针。如果偏离值offset
是非负数,则从数组的开始位置进行切片,否则从数组的尾部开始切片。 格式:
SubSlice(offset int, length ...int)
示例:建立1个新数组,在给其赋值后,将数组转换成
string
,并打印出相应的结果func ExampleStrArray_SubSlice() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
r := s.SubSlice(3, 4)
fmt.Println(r)
// Output:
// [d e f g]
}
Sum
- 说明:对数组中的整数值进行求和
格式:
Sum() (sum int)
示例:建立1个新数组,在给其赋值后,对数组中的整数值进行求和
func ExampleStrArray_Sum() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"3", "5", "10"})
a := s.Sum()
fmt.Println(a)
// Output:
// 18
}
Unique
- 说明:对数组中的数据进行去重处理
格式:
Unique() *StrArray
示例:建立1个新数组,在给其赋值后,对数组中的整数值进行求和
func ExampleStrArray_Unique() {
s := garray.NewStrArray()
s.SetArray(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
fmt.Println(s.Unique())
// Output:
// ["a","b","c","d"]
}
UnmarshalJSON
- 说明:实现
json.Unmarshal
的UnmarshalJSON
接口 格式:
Unique() *StrArray
示例:建立1个
byte
切片,将其赋值给结构体后,进行反序列化操作,打印出相应的内容func ExampleStrArray_UnmarshalJSON() {
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"]}
}
UnmarshalValue
- 说明:对任意类型的值实现反序列化接口
格式:
UnmarshalValue(value interface{}) error
示例:建立1个结构体,并对其值 进行反序列化操作,打印出相应的内容
func ExampleStrArray_UnmarshalValue() {
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"]}
}
Walk
- 说明:通过自定义函数
f
,对数组内容进行遍历修改 格式:
Walk(f func(value string) string) *StrArray
示例:建立1个数组,对数组内容进行遍历修改,为每个字符串添加前缀,并打印出相应的内容
func ExampleStrArray_Walk() {
var array garray.StrArray
tables := g.SliceStr{"user", "user_detail"}
prefix := "gf_"
array.Append(tables...)
// Add prefix for given table names.
array.Walk(func(value string) string {
return prefix + value
})
fmt.Println(array.Slice())
// Output:
// [gf_user gf_user_detail]
}