数组类型-方法介绍

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：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

• 示例：建立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和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]
}