以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档:https://pkg.go.dev/github.com/gogf/gf/v2/container/garray

Append

  • 说明:向数组的尾部追加数据,可以添加任意数量字符串。Append的方法是PushRight的别名
  • 格式:

    1. Append(value ...string) *StrArray
  • 示例:建立一个空数组,设置完数据后,并在数组尾部添加新的数据。

    1. func ExampleStrArray_Append() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"We", "are", "GF", "fans"})
    4. s.Append("a", "b", "c")
    5. fmt.Println(s)
    6. // Output:
    7. // ["We","are","GF","fans","a","b","c"]
    8. }

At

  • 说明:返回数组指定索引的数据
  • 格式:

    1. At(index int) (value string)
  • 示例:建立一个数组,找到index为2的数据。

    1. func ExampleStrArray_At() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"We", "are", "GF", "fans", "!"})
    3. sAt := s.At(2)
    4. fmt.Println(sAt)
    5. // Output:
    6. // GF
    7. }

Chunk

  • 说明:把指定数组按指定的大小Size,分割成多个数组,返回值为[][]string。最后一个数组包含数据的数量可能小于Size
  • 格式:

    1. Chunk(size int) [][]string
  • 示例:建立一个数组,并将该数组分割成3个数组。

    1. func ExampleStrArray_Chunk() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    3. r := s.Chunk(3)
    4. fmt.Println(r)
    5. // Output:
    6. // [[a b c] [d e f] [g h]]
    7. }

Clear

  • 说明:删除当前数组中所有的数据
  • 格式:

    1. Clear() *StrArray
  • 示例:建立一个空数组,赋值后,并删除该数组的数据。

    1. func ExampleStrArray_Clear() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. fmt.Println(s)
    5. fmt.Println(s.Clear())
    6. fmt.Println(s)
    7. // Output:
    8. // ["a","b","c","d","e","f","g","h"]
    9. // []
    10. // []
    11. }

Clone

  • 说明:克隆当前的数组。返回一个与当前数组相同的数组拷贝
  • 格式:

    1. Clone() (newArray *StrArray)
  • 示例:建立一个空数组,赋值后,克隆出一个新数组。

    1. func ExampleStrArray_Clone() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r := s.Clone()
    5. fmt.Println(r)
    6. fmt.Println(s)
    7. // Output:
    8. // ["a","b","c","d","e","f","g","h"]
    9. // ["a","b","c","d","e","f","g","h"]
    10. }

Contains

  • 说明:判断一个数组是否包含给定的String值。字符串严格区分大小写。返回值为bool
  • 格式:

    1. Contains(value string) bool
  • 示例:建立一个空数组,设置完数据后,判断是否包含指定数据ez

    1. func ExampleStrArray_Contains() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. fmt.Println(s.Contains("e"))
    5. fmt.Println(s.Contains("z"))
    6. // Output:
    7. // true
    8. // false
    9. }

ContainsI

  • 说明:判断一个数组是否包含给定的String值。字符串不区分大小写。返回值为bool
  • 格式:

    1. ContainsI(value string) bool
  • 示例:建立一个空数组,设置完数据后,判断是否包含指定数据Ez

    1. func ExampleStrArray_ContainsI() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. fmt.Println(s.ContainsI("E"))
    5. fmt.Println(s.ContainsI("z"))
    6. // Output:
    7. // true
    8. // false
    9. }

CountValues

  • 说明:统计每个值在数组中出现的次数。返回值为map[string]int
  • 格式:

    1. CountValues() map[string]int
  • 示例:建立一个数组,统计数组中每个字符串包含的个数

    1. func ExampleStrArray_CountValues() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
    3. fmt.Println(s.CountValues())
    4. // Output:
    5. // map[a:1 b:1 c:3 d:2]
    6. }

Fill

  • 说明:在数组中指定的开始位置startIndex,用指定的value进行填充。返回值为error
  • 格式:

    1. Fill(startIndex int, num int, value string) error
  • 示例:建立一个数组,在数组开始位置index为2的地方,用字符串here填充3个数据

    1. func ExampleStrArray_Fill() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    3. s.Fill(2, 3, "here")
    4. fmt.Println(s)
    5. // Output:
    6. // ["a","b","here","here","here","f","g","h"]
    7. }

FilterEmpty

  • 说明:过滤指定数组中的空字符串
  • 格式:

    1. FilterEmpty() *StrArray
  • 示例:建立一个数组,在赋值后,过滤该数组中的空字符串

    1. func ExampleStrArray_FilterEmpty() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "", "c", "", "", "d"})
    3. fmt.Println(s.FilterEmpty())
    4. // Output:
    5. // ["a","b","c","d"]
    6. }

Get

  • 说明:返回数组中指定index的值,返回值有2个参数,返回值value,和是否找到指定位置的数据found,为true则找到,为false则未找到
  • 格式:

    1. Get(index int) (value string, found bool)
  • 示例:建立一个数组,在赋值后,得到数组index为3的值

    1. func ExampleStrArray_Get() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"We", "are", "GF", "fans", "!"})
    3. sGet, sBool := s.Get(3)
    4. fmt.Println(sGet, sBool)
    5. // Output:
    6. // fans true
    7. }

InsertAfter

  • 说明:在数组中指定index的位置之后插入值value,返回值为error
  • 格式:

    1. InsertAfter(index int, value string) error
  • 示例:建立一个数组,在index为1的值之后,插入字符串here

    1. func ExampleStrArray_InsertAfter() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.InsertAfter(1, "here")
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [a b here c d]
    8. }

InsertBefore

  • 说明:在数组中指定index的位置之前插入值value,返回值为error
  • 格式:

    1. InsertBefore(index int, value string) error
  • 示例:建立一个数组并初始化,在index为1的值之前,插入字符串here

    1. func ExampleStrArray_InsertBefore() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.InsertBefore(1, "here")
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [a here b c d]
    8. }

Interfaces

  • 说明:把当前数组作为[]interface{}进行返回
  • 格式:

    1. Interfaces() []interface{}
  • 示例:建立一个数组并初始化,并打印出返回值[]interface{}的内容

    1. func ExampleStrArray_Interfaces() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r := s.Interfaces()
    5. fmt.Println(r)
    6. // Output:
    7. // [a b c d e f g h]
    8. }

IsEmpty

  • 说明:判断当前数组是不是空数组,如果是空数组,则返回true,如果不是空数组,则返回false
  • 格式:

    1. IsEmpty() bool
  • 示例:建立2个数组并初始化,并判断是否为空数组

    1. func ExampleStrArray_IsEmpty() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "", "c", "", "", "d"})
    3. fmt.Println(s.IsEmpty())
    4. s1 := garray.NewStrArray()
    5. fmt.Println(s1.IsEmpty())
    6. // Output:
    7. // false
    8. // true
    9. }

Iterator

  • 说明:数组遍历
  • 格式:

    1. Iterator(f func(k int, v string) bool)
  • 示例:建立1个数组,并对其进行遍历

    1. func ExampleStrArray_Iterator() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
    3. s.Iterator(func(k int, v string) bool {
    4. fmt.Println(k, v)
    5. return true
    6. })
    7. // Output:
    8. // 0 a
    9. // 1 b
    10. // 2 c
    11. }

IteratorAsc

  • 说明:根据给定的回调函数f,按升序对数组进行遍历,如果f返回true,则继续进行遍历,否则停止遍历
  • 格式:

    1. IteratorAsc(f func(k int, v string) bool)
  • 示例:建立1个数组,并按照自定义函数对其进行升序遍历

    1. func ExampleStrArray_Iterator() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
    3. s.Iterator(func(k int, v string) bool {
    4. fmt.Println(k, v)
    5. return true
    6. })
    7. // Output:
    8. // 0 a
    9. // 1 b
    10. // 2 c
    11. }

IteratorDesc

  • 说明:根据给定的回调函数f,按降序对数组进行遍历,如果f返回true,则继续进行遍历,否则停止遍历
  • 格式:

    1. IteratorAsc(f func(k int, v string) bool)
  • 示例:建立1个数组,并按照自定义函数对其进行降序遍历

    1. func ExampleStrArray_IteratorDesc() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
    3. s.IteratorDesc(func(k int, v string) bool {
    4. fmt.Println(k, v)
    5. return true
    6. })
    7. // Output:
    8. // 2 c
    9. // 1 b
    10. // 0 a
    11. }

Join

  • 说明:将数组元素根据给定的字符串连接符gule,连接起来
  • 格式:

    1. Join(glue string) string
  • 示例:给定连接符',',将数组中的字符串连接起来

    1. func ExampleStrArray_Join() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
    3. fmt.Println(s.Join(","))
    4. // Output:
    5. // a,b,c
    6. }

Len

  • 说明:得到数组的长度
  • 格式:

    1. Join(glue string) string
  • 示例:建立一个新数组,初始化后得到该数组的长度

    1. func ExampleStrArray_Len() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. fmt.Println(s.Len())
    5. // Output:
    6. // 8
    7. }

LockFunc

  • 说明:通过回调函数f对数组进行写锁定
  • 格式:

    1. LockFunc(f func(array []string)) *StrArray
  • 示例:建立一个新数组,并对该数组在写锁定的状态下,修改最后一个数据

    1. func ExampleStrArray_LockFunc() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
    3. s.LockFunc(func(array []string) {
    4. array[len(array)-1] = "GF fans"
    5. })
    6. fmt.Println(s)
    7. // Output:
    8. // ["a","b","GF fans"]
    9. }

MarshalJSON

  • 说明:实现json.MarshalJSON格式的序列化接口
  • 格式:

    1. MarshalJSON() ([]byte, error)
  • 示例:建立一个新JSON格式的数据,并对该数据进行序列化的操作后,打印出相应结果

    1. func ExampleStrArray_MarshalJSON() {
    2. type Student struct {
    3. Id int
    4. Name string
    5. Lessons []string
    6. }
    7. s := Student{
    8. Id: 1,
    9. Name: "john",
    10. Lessons: []string{"Math", "English", "Music"},
    11. }
    12. b, _ := json.Marshal(s)
    13. fmt.Println(string(b))
    14. // Output:
    15. // {"Id":1,"Name":"john","Lessons":["Math","English","Music"]}
    16. }

Merge

  • 说明:合并数组,将指定数组中的内容合并到当前数组中。参数array可以是任意garrayslice类型。MergeAppend的主要区别是Append仅仅支持slice类型,Merge则支持更多的参数类型
  • 格式:

    1. Merge(array interface{}) *StrArray
  • 示例:建立2个新数组s1s2,并将s2的数据合并到s1

    1. func ExampleStrArray_Merge() {
    2. s1 := garray.NewStrArray()
    3. s2 := garray.NewStrArray()
    4. s1.SetArray(g.SliceStr{"a", "b", "c"})
    5. s2.SetArray(g.SliceStr{"d", "e", "f"})
    6. s1.Merge(s2)
    7. fmt.Println(s1)
    8. // Output:
    9. // ["a","b","c","d","e","f"]
    10. }

NewStrArray

  • 说明:创建一个新数组。safe为非必需参数,布尔型,是并发安全的开关,缺省值为False
  • 格式:

    1. NewStrArray(safe ...bool) *StrArray
  • 示例:建立一个空数组,并添加数据。此时没有指定 Safe参数,默认为非并发安全设置

    1. func ExampleNewStrArray() {
    2. s := garray.NewStrArray()
    3. s.Append("We")
    4. s.Append("are")
    5. s.Append("GF")
    6. s.Append("Fans")
    7. fmt.Println(s.Slice())
    8. // Output:
    9. // [We are GF Fans]
    10. }

NewStrArrayFrom

  • 说明:根据给定的数组内容,创建一个新数组。safe为非必需参数,布尔型,是并发安全的开关,缺省值为False
  • 格式:

    1. NewStrArrayFrom(array []string, safe ...bool) *StrArray
  • 示例:建立一个空数组,并根据指定内容添加数据。此时没有指定 Safe参数,默认为非并发安全设置

    1. func ExampleNewStrArrayFrom() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"We", "are", "GF", "fans", "!"})
    3. fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
    4. // Output:
    5. // [We are GF fans !] 5 5
    6. }

NewStrArrayFromCopy

  • 说明:根据给定的数组内容的拷贝,创建一个新数组。safe为非必需参数,布尔型,是并发安全的开关,缺省值为False
  • 格式:

    1. NewStrArrayFrom(array []string, safe ...bool) *StrArray
  • 示例:建立一个空数组,并根据指定内容添加数据。此时没有指定 Safe参数,默认为非并发安全设置

    1. func ExampleNewStrArrayFromCopy() {
    2. s := garray.NewStrArrayFromCopy(g.SliceStr{"We", "are", "GF", "fans", "!"})
    3. fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
    4. // Output:
    5. // [We are GF fans !] 5 5
    6. }

NewStrArraySize

  • 说明:根据给定的sizecap,创建一个新数组。safe为非必需参数,布尔型,是并发安全的开关,缺省值为False
  • 格式:

    1. NewStrArraySize(size int, cap int, safe ...bool) *StrArray
  • 示例:建立一个空数组,Size为3Cap为5,并添加数据。打印出相应的内容。此时没有指定 Safe参数,默认为非并发安全设置

    1. func ExampleNewStrArraySize() {
    2. s := garray.NewStrArraySize(3, 5)
    3. s.Set(0, "We")
    4. s.Set(1, "are")
    5. s.Set(2, "GF")
    6. s.Set(3, "fans")
    7. fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
    8. // Output:
    9. // [We are GF] 3 5
    10. }

Pad

  • 说明:填充指定大小为size的值value到数组中。如果大小size是正数,则从数组的右边开始填充。如果size是负数,则从数组的左边开始填充。如果size的大小正好等于数组的长度,那么将不会填充任何数据。
  • 格式:

    1. Pad(size int, value string) *StrArray
  • 示例:建立1个新数组,先从左边将数组,用指定的字符串here填充到size为7,然后用指定的字符串there将数组用字符串填充到size为10

    1. func ExampleStrArray_Pad() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
    3. s.Pad(7, "here")
    4. fmt.Println(s)
    5. s.Pad(-10, "there")
    6. fmt.Println(s)
    7. // Output:
    8. // ["a","b","c","here","here","here","here"]
    9. // ["there","there","there","a","b","c","here","here","here","here"]
    10. }

PopLeft

  • 说明:从数组的左侧将一个字符串数据出栈,返回值value为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时,foundfalse。
  • 格式:

    1. PopLeft() (value string, found bool)
  • 示例:建立1个新数组,将最左边的数据出栈,并打印出剩余的数据

    1. func ExampleStrArray_PopLeft() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.PopLeft()
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [b c d]
    8. }

PopLefts

  • 说明:从数组的左侧将多个字符串数据出栈,返回值为出栈的字符串数据,出栈数据的个数为size。如果size比数组的size大,那么方法将返回数组中所有的数据。如果size<=0或者为空,那么将返回nil
  • 格式:

    1. PopLefts(size int) []string
  • 示例:建立1个新数组,将最左边的2个数据做出栈操作,并打印出出栈的数据和原数组的剩余数据

    1. func ExampleStrArray_PopLefts() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r := s.PopLefts(2)
    5. fmt.Println(r)
    6. fmt.Println(s)
    7. // Output:
    8. // [a b]
    9. // ["c","d","e","f","g","h"]
    10. }

PopRand

  • 说明:从数组中随机出栈1个数据,返回值为出栈的字符串数据。如果数组为空,那么found将返回false
  • 格式:

    1. PopRand() (value string, found bool)
  • 示例:建立1个新数组,从数组中随机出栈1个数据,并打印出出栈的数据

    1. func ExampleStrArray_PopRand() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r, _ := s.PopRand()
    5. fmt.Println(r)
    6. // May Output:
    7. // e
    8. }

PopRands

  • 说明:从数组中随机出栈size个数据,返回值为出栈的字符串数据。如果size<=0或者为空,那么将返回nil
  • 格式:

    1. PopRands(size int) []string
  • 示例:建立1个新数组,从数组中随机出栈2个数据,并打印出出栈的数据

    1. func ExampleStrArray_PopRands() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r := s.PopRands(2)
    5. fmt.Println(r)
    6. // May Output:
    7. // [e c]
    8. }

PopRight

  • 说明:从数组的右侧将一个字符串数据出栈,返回值value为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时,foundfalse。
  • 格式:

    1. PopRight() (value string, found bool)
  • 示例:建立1个新数组,将最右边的数据出栈,并打印出剩余的数据

    1. func ExampleStrArray_PopRight() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.PopRight()
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [a b c]
    8. }

PopRights

  • 说明:从数组的右侧将多个字符串数据出栈,返回值为出栈的字符串数据,出栈数据的个数为size。如果size比数组的size大,那么方法将返回数组中所有的数据。如果size<=0或者为空,那么将返回nil
  • 格式:

    1. PopRights(size int) []string
  • 示例:建立1个新数组,将最右边的2个数据做出栈操作,并打印出出栈的数据和原数组的剩余数据

    1. func ExampleStrArray_PopRights() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r := s.PopRights(2)
    5. fmt.Println(r)
    6. fmt.Println(s)
    7. // Output:
    8. // [g h]
    9. // ["a","b","c","d","e","f"]
    10. }

PushLeft

  • 说明:从数组的左侧入栈一个或多个字符串
  • 格式:

    1. PushLeft(value ...string) *StrArray
  • 示例:建立1个新数组,从数组的左侧入栈多个字符串数据,并打印出更新后的数据

    1. func ExampleStrArray_PushLeft() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.PushLeft("We", "are", "GF", "fans")
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [We are GF fans a b c d]
    8. }

PushRight

  • 说明:从数组的右侧入栈一个或多个字符串
  • 格式:

    1. PushRight(value ...string) *StrArray
  • 示例:建立1个新数组,从数组的右侧入栈多个字符串数据,并打印出更新后的数据

    1. func ExampleStrArray_PushRight() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.PushRight("We", "are", "GF", "fans")
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [a b c d We are GF fans]
    8. }

Rand

  • 说明:从数组中随机取出1个字符串(非删除式)
  • 格式:

    1. Rand() (value string, found bool)
  • 示例:建立1个新数组,从数组中随机取出一个字符串

    1. func ExampleStrArray_Rand() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    3. fmt.Println(s.Rand())
    4. // May Output:
    5. // c true
    6. }

Rands

  • 说明:从数组中随机取出size个字符串(非删除式)
  • 格式:

    1. Rands(size int) []string
  • 示例:建立1个新数组,从数组中随机取出3个字符串

    1. func ExampleStrArray_Rands() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    3. fmt.Println(s.Rands(3))
    4. // May Output:
    5. // [e h e]
    6. }

Range

  • 说明:获取数组中指定范围的数据。如果是在并发安全的模式下使用,则该方法返回一个slice拷贝。
  • 格式:

    1. Range(start int, end ...int) []string
  • 示例:建立1个新数组,获取数组从index为2至5位置的数据

    1. func ExampleStrArray_Range() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r := s.Range(2, 5)
    5. fmt.Println(r)
    6. // Output:
    7. // [c d e]
    8. }

Remove

  • 说明:从数组中移除位置在index处的数据。如果index超过数组的边界,则found返回false
  • 格式:

    1. Remove(index int) (value string, found bool)
  • 示例:建立1个新数组,移除数组index为1的数据

    1. func ExampleStrArray_Remove() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.Remove(1)
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [a c d]
    8. }

RemoveValue

  • 说明:从数组中移除指定的数据value。如果value在数组中被找到,则found返回true,否则found返回false
  • 格式:

    1. RemoveValue(value string) bool
  • 示例:建立1个新数组,移除数组中值为b的数据

    1. func ExampleStrArray_RemoveValue() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d"})
    4. s.RemoveValue("b")
    5. fmt.Println(s.Slice())
    6. // Output:
    7. // [a c d]
    8. }

Replace

  • 说明:将原字符串数组用指定的字符串数组进行替换,替换从原数组的头部位置开始。
  • 格式:

    1. Replace(array []string) *StrArray
  • 示例:建立1个新数组,并用指定的字符串数组进行替换

    1. func ExampleStrArray_Replace() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"We", "are", "GF", "fans", "!"})
    4. fmt.Println(s.Slice())
    5. s.Replace(g.SliceStr{"Happy", "coding"})
    6. fmt.Println(s.Slice())
    7. // Output:
    8. // [We are GF fans !]
    9. // [Happy coding GF fans !]
    10. }

Reverse

  • 说明:将数组中的所有元素用倒序进行排序
  • 格式:

    1. Replace(array []string) *StrArray
  • 示例:建立1个新数组,初始化后执行倒序操作并打印

    1. func ExampleStrArray_Reverse() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    3. fmt.Println(s.Reverse())
    4. // Output:
    5. // ["h","g","f","e","d","c","b","a"]
    6. }

RLockFunc

  • 说明:通过自定义回调函数f进行数组的读锁定
  • 格式:

    1. RLockFunc(f func(array []string)) *StrArray
  • 示例:建立1个新数组,在回调函数f中,对数组进行遍历,并打印出数组元素

    1. func ExampleStrArray_RLockFunc() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e"})
    3. s.RLockFunc(func(array []string) {
    4. for i := 0; i < len(array); i++ {
    5. fmt.Println(array[i])
    6. }
    7. })
    8. // Output:
    9. // a
    10. // b
    11. // c
    12. // d
    13. // e
    14. }

Search

  • 说明:在数组中搜索指定的字符串,返回值为该值在数组中的index,如果没有查询到,则返回-1
  • 格式:

    1. Search(value string) int
  • 示例:建立1个新数组,并在该数组中搜索字符串e和z

    1. func ExampleStrArray_Search() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. fmt.Println(s.Search("e"))
    5. fmt.Println(s.Search("z"))
    6. // Output:
    7. // 4
    8. // -1
    9. }

Set

  • 说明:给数组中指定位置的index设置值value,如果index<0或者index超出了数组的边界,则返回错误error
  • 格式:

    1. Set(index int, value string) error
  • 示例:建立1个新数组,长度为3,给数组设置值,值最终只按顺序设置到了index为2的位置,因为数组长度限制,最后一个值未设置成功

    1. func ExampleStrArray_Set() {
    2. s := garray.NewStrArraySize(3, 5)
    3. s.Set(0, "We")
    4. s.Set(1, "are")
    5. s.Set(2, "GF")
    6. s.Set(3, "fans")
    7. fmt.Println(s.Slice())
    8. // Output:
    9. // [We are GF]
    10. }

SetArray

  • 说明:根据给定的slice数组内容给数组赋值
  • 格式:

    1. SetArray(array []string) *StrArray
  • 示例:建立1个新数组,在给其赋值后,打印出来

    1. func ExampleStrArray_SetArray() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"We", "are", "GF", "fans", "!"})
    4. fmt.Println(s.Slice())
    5. // Output:
    6. // [We are GF fans !]
    7. }

Shuffle

  • 说明:将数组中的内容进行乱序排列
  • 格式:

    1. Shuffle() *StrArray
  • 示例:建立1个新数组,在给其赋值后进行乱序排列,并打印出来

    1. func ExampleStrArray_Shuffle() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    3. fmt.Println(s.Shuffle())
    4. // May Output:
    5. // ["a","c","e","d","b","g","f","h"]
    6. }

Slice

  • 说明:得到数组的slice切片数据,注意,如果是在并发安全模式下,返回的是一份拷贝数据,否则返回的是指向数据的指针
  • 格式:

    1. Shuffle() *StrArray
  • 示例:建立1个新数组,在给其赋值后,并打印该数组的切片数据

    1. func ExampleStrArray_Slice() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. fmt.Println(s.Slice())
    5. // Output:
    6. // [a b c d e f g h]
    7. }

Sort

  • 说明:对数组内容进行升序排序。reverse控制排序的方向,默认为true升序,false为降序
  • 格式:

    1. Sort(reverse ...bool) *StrArray
  • 示例:建立1个新数组,在给其赋值后,并按升序进行排序

    1. func ExampleStrArray_Sort() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"b", "d", "a", "c"})
    4. a := s.Sort()
    5. fmt.Println(a)
    6. // Output:
    7. // ["a","b","c","d"]
    8. }

SortFunc

  • 说明:通过自定义函数less对数组内容进行排序。
  • 格式:

    1. SortFunc(less func(v1, v2 string) bool) *StrArray
  • 示例:建立1个新数组,在给其赋值后,首先用自定义函数对其进行降序排序,然后用自定义函数对其进行升序排序,并打印出相应的结果

    1. func ExampleStrArray_SortFunc() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"b", "c", "a"})
    3. fmt.Println(s)
    4. s.SortFunc(func(v1, v2 string) bool {
    5. return gstr.Compare(v1, v2) > 0
    6. })
    7. fmt.Println(s)
    8. s.SortFunc(func(v1, v2 string) bool {
    9. return gstr.Compare(v1, v2) < 0
    10. })
    11. fmt.Println(s)
    12. // Output:
    13. // ["b","c","a"]
    14. // ["c","b","a"]
    15. // ["a","b","c"]
    16. }

String

  • 说明:将当前的数组转换成string
  • 格式:

    1. String() string
  • 示例:建立1个新数组,在给其赋值后,将数组转换成string,并打印出相应的结果

    1. func ExampleStrArray_String() {
    2. s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
    3. fmt.Println(s.String())
    4. // Output:
    5. // ["a","b","c"]
    6. }

Subslice

  • 说明:根据给定的偏离值offset和长度length参数获得数组的切片,注意,如果是在并发安全模式下,返回拷贝数据,否则返回指向数据的指针。如果偏离值offset是非负数,则从数组的开始位置进行切片,否则从数组的尾部开始切片。
  • 格式:

    1. SubSlice(offset int, length ...int)
  • 示例:建立1个新数组,在给其赋值后,将数组转换成string,并打印出相应的结果

    1. func ExampleStrArray_SubSlice() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
    4. r := s.SubSlice(3, 4)
    5. fmt.Println(r)
    6. // Output:
    7. // [d e f g]
    8. }

Sum

  • 说明:对数组中的整数值进行求和
  • 格式:

    1. Sum() (sum int)
  • 示例:建立1个新数组,在给其赋值后,对数组中的整数值进行求和

    1. func ExampleStrArray_Sum() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"3", "5", "10"})
    4. a := s.Sum()
    5. fmt.Println(a)
    6. // Output:
    7. // 18
    8. }

Unique

  • 说明:对数组中的数据进行去重处理
  • 格式:

    1. Unique() *StrArray
  • 示例:建立1个新数组,在给其赋值后,对数组中的整数值进行求和

    1. func ExampleStrArray_Unique() {
    2. s := garray.NewStrArray()
    3. s.SetArray(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
    4. fmt.Println(s.Unique())
    5. // Output:
    6. // ["a","b","c","d"]
    7. }

UnmarshalJSON

  • 说明:实现json.UnmarshalUnmarshalJSON接口
  • 格式:

    1. Unique() *StrArray
  • 示例:建立1个byte切片,将其赋值给结构体后,进行反序列化操作,打印出相应的内容

    1. func ExampleStrArray_UnmarshalJSON() {
    2. b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
    3. type Student struct {
    4. Id int
    5. Name string
    6. Lessons *garray.StrArray
    7. }
    8. s := Student{}
    9. json.Unmarshal(b, &s)
    10. fmt.Println(s)
    11. // Output:
    12. // {1 john ["Math","English","Sport"]}
    13. }

UnmarshalValue

  • 说明:对任意类型的值实现反序列化接口
  • 格式:

    1. UnmarshalValue(value interface{}) error
  • 示例:建立1个结构体,并对其值 进行反序列化操作,打印出相应的内容

    1. func ExampleStrArray_UnmarshalValue() {
    2. type Student struct {
    3. Name string
    4. Lessons *garray.StrArray
    5. }
    6. var s *Student
    7. gconv.Struct(g.Map{
    8. "name": "john",
    9. "lessons": []byte(`["Math","English","Sport"]`),
    10. }, &s)
    11. fmt.Println(s)
    12. var s1 *Student
    13. gconv.Struct(g.Map{
    14. "name": "john",
    15. "lessons": g.SliceStr{"Math", "English", "Sport"},
    16. }, &s1)
    17. fmt.Println(s1)
    18. // Output:
    19. // &{john ["Math","English","Sport"]}
    20. // &{john ["Math","English","Sport"]}
    21. }

Walk

  • 说明:通过自定义函数f,对数组内容进行遍历修改
  • 格式:

    1. Walk(f func(value string) string) *StrArray
  • 示例:建立1个数组,对数组内容进行遍历修改,为每个字符串添加前缀,并打印出相应的内容

    1. func ExampleStrArray_Walk() {
    2. var array garray.StrArray
    3. tables := g.SliceStr{"user", "user_detail"}
    4. prefix := "gf_"
    5. array.Append(tables...)
    6. // Add prefix for given table names.
    7. array.Walk(func(value string) string {
    8. return prefix + value
    9. })
    10. fmt.Println(array.Slice())
    11. // Output:
    12. // [gf_user gf_user_detail]
    13. }