Skip to end of metadata
Go to start of metadata

以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: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
  • 示例:建立一个空数组,设置完数据后,判断是否包含指定数据ez

    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
  • 示例:建立一个空数组,设置完数据后,判断是否包含指定数据Ez

    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.MarshalJSON格式的序列化接口
  • 格式: 

    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可以是任意garrayslice类型。MergeAppend的主要区别是Append仅仅支持slice类型,Merge则支持更多的参数类型
  • 格式: 

    Merge(array interface{}) *StrArray
  • 示例:建立2个新数组s1s2,并将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

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

    NewStrArraySize(size int, cap int, safe ...bool) *StrArray
  • 示例:建立一个空数组,Size为3Cap为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为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时,foundfalse。
  • 格式: 

    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为出栈的字符串数据。更新后的数组数据为剩余数据。当数组为空时,foundfalse。
  • 格式: 

    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个新数组,并在该数组中搜索字符串ez

    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.UnmarshalUnmarshalJSON接口
  • 格式: 

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

  • No labels

1 Comment

  1. Join(glue string) string
    应该为len,不是join