创新互联GoFrame教程：GoFrame garray-方法介绍

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

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

Join(glue string) string

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

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]
}

网站题目：创新互联GoFrame教程：GoFrame garray-方法介绍
文章出自：http://www.zsjierui.cn/article/djjjdoe.html

网站建设知识