GoFrame garray-方法介绍

2022-04-08 11:04 更新

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


以上内容是否对您有帮助:
在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号