以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: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
为空
,那么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
格式:
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
和z
func 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] } |