跳到主要内容
版本:2.4.x

以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: 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
  • 示例:建立一个空数组,设置完数据后,判断是否包含指定数据 ez
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
  • 示例:建立一个空数组,设置完数据后,判断是否包含指定数据 Ez
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.MarshalJSON 格式的序列化接口
  • 格式:
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 可以是任意 garrayslice 类型。 MergeAppend 的主要区别是 Append 仅仅支持 slice 类型, Merge 则支持更多的参数类型
  • 格式:
Merge(array interface{}) *StrArray
  • 示例:建立2个新数组 s1s2,并将 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

  • 说明:根据给定的 sizecap,创建一个新数组。 safe 为非必需参数,布尔型,是并发安全的开关,缺省值为 False
  • 格式:
NewStrArraySize(size int, cap int, safe ...bool) *StrArray
  • 示例:建立一个空数组, Size为3Cap为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 为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时, foundfalse。
  • 格式:
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 为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时, foundfalse。
  • 格式:
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
}
  • 说明:在数组中搜索指定的字符串,返回值为该值在数组中的 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.UnmarshalUnmarshalJSON 接口
  • 格式:
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]
}