Chunk
Clone
ContainsI
Fill
Get
InsertBefore
IsEmpty
IteratorAsc
Join
LockFunc
Merge
NewStrArrayFrom
NewStrArraySize
PopLeft
PopRand
PopRight
PushLeft
Rand
Range
RemoveValue
Reverse
Search
SetArray
Slice
SortFunc
Subslice
Unique
UnmarshalValue

`Append`

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

示例：建立一个空数组，设置完数据后，并在数组尾部添加新的数据。

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)

`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`

说明：得到数组的长度

示例：建立一个新数组，初始化后得到该数组的长度

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个字符串


    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拷贝。
格式:

func ExampleStrArray_Range() {
    s := garray.NewStrArray()
    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，对数组内容进行遍历修改
格式:

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

数组类型-方法介绍

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