garray

package
v1.15.4-0...-d475b66 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 21, 2021 License: MIT Imports: 13 Imported by: 0

Documentation

Overview

Package garray provides most commonly used array containers which also support concurrent-safe/unsafe switch feature.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Array

type Array struct {
	// contains filtered or unexported fields
}

Array is a golang array with rich features. It contains a concurrent-safe/unsafe switch, which should be set when its initialization and cannot be changed then.

func New

func New(safe ...bool) *Array

New creates and returns an empty array. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

Example
package main

import (
	"fmt"

	"github.com/gogf/gf/container/garray"
)

func main() {
	// A normal array.
	a := garray.New()

	// Adding items.
	for i := 0; i < 10; i++ {
		a.Append(i)
	}

	// Print the array length.
	fmt.Println(a.Len())

	// Print the array items.
	fmt.Println(a.Slice())

	// Retrieve item by index.
	fmt.Println(a.Get(6))

	// Check item existence.
	fmt.Println(a.Contains(6))
	fmt.Println(a.Contains(100))

	// Insert item before specified index.
	a.InsertAfter(9, 11)
	// Insert item after specified index.
	a.InsertBefore(10, 10)

	fmt.Println(a.Slice())

	// Modify item by index.
	a.Set(0, 100)
	fmt.Println(a.Slice())

	// Search item and return its index.
	fmt.Println(a.Search(5))

	// Remove item by index.
	a.Remove(0)
	fmt.Println(a.Slice())

	// Empty the array, removes all items of it.
	fmt.Println(a.Slice())
	a.Clear()
	fmt.Println(a.Slice())

}
Output:

10
[0 1 2 3 4 5 6 7 8 9]
6 true
true
false
[0 1 2 3 4 5 6 7 8 9 10 11]
[100 1 2 3 4 5 6 7 8 9 10 11]
5
[1 2 3 4 5 6 7 8 9 10 11]
[1 2 3 4 5 6 7 8 9 10 11]
[]

func NewArray

func NewArray(safe ...bool) *Array

See New.

func NewArrayFrom

func NewArrayFrom(array []interface{}, safe ...bool) *Array

NewArrayFrom creates and returns an array with given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewArrayFromCopy

func NewArrayFromCopy(array []interface{}, safe ...bool) *Array

NewArrayFromCopy creates and returns an array from a copy of given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewArrayRange

func NewArrayRange(start, end, step int, safe ...bool) *Array

NewArrayRange creates and returns a array by a range from `start` to `end` with step value `step`.

func NewArraySize

func NewArraySize(size int, cap int, safe ...bool) *Array

NewArraySize create and returns an array with given size and cap. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewFrom

func NewFrom(array []interface{}, safe ...bool) *Array

NewFrom is alias of NewArrayFrom. See NewArrayFrom.

func NewFromCopy

func NewFromCopy(array []interface{}, safe ...bool) *Array

NewFromCopy is alias of NewArrayFromCopy. See NewArrayFromCopy.

func (*Array) Append

func (a *Array) Append(value ...interface{}) *Array

See PushRight.

func (*Array) At

func (a *Array) At(index int) (value interface{})

At returns the value by the specified index. If the given `index` is out of range of the array, it returns `nil`.

func (*Array) Chunk

func (a *Array) Chunk(size int) [][]interface{}

Chunk splits an array into multiple arrays, the size of each array is determined by `size`. The last chunk may contain less than size elements.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Chunk splits an array into multiple arrays,
	// the size of each array is determined by `size`.
	// The last chunk may contain less than size elements.
	fmt.Println(array.Chunk(2))

}
Output:

[[1 2] [3 4] [5 6] [7 8] [9]]

func (*Array) Clear

func (a *Array) Clear() *Array

Clear deletes all items of current array.

func (*Array) Clone

func (a *Array) Clone() (newArray *Array)

Clone returns a new array, which is a copy of current array.

func (*Array) Contains

func (a *Array) Contains(value interface{}) bool

Contains checks whether a value exists in the array.

Example
package main

import (
	"fmt"

	"github.com/gogf/gf/container/garray"
)

func main() {
	var array garray.StrArray
	array.Append("a")
	fmt.Println(array.Contains("a"))
	fmt.Println(array.Contains("A"))
	fmt.Println(array.ContainsI("A"))

}
Output:

true
false
true

func (*Array) CountValues

func (a *Array) CountValues() map[interface{}]int

CountValues counts the number of occurrences of all values in the array.

func (*Array) Fill

func (a *Array) Fill(startIndex int, num int, value interface{}) error

Fill fills an array with num entries of the value `value`, keys starting at the `startIndex` parameter.

func (*Array) FilterEmpty

func (a *Array) FilterEmpty() *Array

FilterEmpty removes all empty value of the array. Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
	fmt.Printf("%#v\n", array1.FilterNil().Slice())
	fmt.Printf("%#v\n", array2.FilterEmpty().Slice())

}
Output:

[]interface {}{0, 1, 2, "", []interface {}{}, "john"}
[]interface {}{1, 2, "john"}

func (*Array) FilterNil

func (a *Array) FilterNil() *Array

FilterNil removes all nil value of the array.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
	fmt.Printf("%#v\n", array1.FilterNil().Slice())
	fmt.Printf("%#v\n", array2.FilterEmpty().Slice())

}
Output:

[]interface {}{0, 1, 2, "", []interface {}{}, "john"}
[]interface {}{1, 2, "john"}

func (*Array) Get

func (a *Array) Get(index int) (value interface{}, found bool)

Get returns the value by the specified index. If the given `index` is out of range of the array, the `found` is false.

func (*Array) InsertAfter

func (a *Array) InsertAfter(index int, value interface{}) error

InsertAfter inserts the `value` to the back of `index`.

func (*Array) InsertBefore

func (a *Array) InsertBefore(index int, value interface{}) error

InsertBefore inserts the `value` to the front of `index`.

func (*Array) Interfaces

func (a *Array) Interfaces() []interface{}

Interfaces returns current array as []interface{}.

func (*Array) IsEmpty

func (a *Array) IsEmpty() bool

IsEmpty checks whether the array is empty.

func (*Array) Iterator

func (a *Array) Iterator(f func(k int, v interface{}) bool)

Iterator is alias of IteratorAsc.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewArrayFrom(g.Slice{"a", "b", "c"})
	// Iterator is alias of IteratorAsc, which iterates the array readonly in ascending order
	//  with given callback function `f`.
	// If `f` returns true, then it continues iterating; or false to stop.
	array.Iterator(func(k int, v interface{}) bool {
		fmt.Println(k, v)
		return true
	})
	// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
	// If `f` returns true, then it continues iterating; or false to stop.
	array.IteratorDesc(func(k int, v interface{}) bool {
		fmt.Println(k, v)
		return true
	})

}
Output:

0 a
1 b
2 c
2 c
1 b
0 a

func (*Array) IteratorAsc

func (a *Array) IteratorAsc(f func(k int, v interface{}) bool)

IteratorAsc iterates the array readonly in ascending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*Array) IteratorDesc

func (a *Array) IteratorDesc(f func(k int, v interface{}) bool)

IteratorDesc iterates the array readonly in descending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*Array) Join

func (a *Array) Join(glue string) string

Join joins array elements with a string `glue`.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom(g.Slice{"a", "b", "c", "d"})
	fmt.Println(array.Join(","))

}
Output:

a,b,c,d

func (*Array) Len

func (a *Array) Len() int

Len returns the length of array.

func (*Array) LockFunc

func (a *Array) LockFunc(f func(array []interface{})) *Array

LockFunc locks writing by callback function `f`.

func (Array) MarshalJSON

func (a Array) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal. Note that do not use pointer as its receiver here.

func (*Array) Merge

func (a *Array) Merge(array interface{}) *Array

Merge merges `array` into current array. The parameter `array` can be any garray or slice type. The difference between Merge and Append is Append supports only specified slice type, but Merge supports more parameter types.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array1 := garray.NewFrom(g.Slice{1, 2})
	array2 := garray.NewFrom(g.Slice{3, 4})
	slice1 := g.Slice{5, 6}
	slice2 := []int{7, 8}
	slice3 := []string{"9", "0"}
	fmt.Println(array1.Slice())
	array1.Merge(array1)
	array1.Merge(array2)
	array1.Merge(slice1)
	array1.Merge(slice2)
	array1.Merge(slice3)
	fmt.Println(array1.Slice())

}
Output:

[1 2]
[1 2 1 2 3 4 5 6 7 8 9 0]

func (*Array) Pad

func (a *Array) Pad(size int, val interface{}) *Array

Pad pads array to the specified length with `value`. If size is positive then the array is padded on the right, or negative on the left. If the absolute value of `size` is less than or equal to the length of the array then no padding takes place.

func (*Array) PopLeft

func (a *Array) PopLeft() (value interface{}, found bool)

PopLeft pops and returns an item from the beginning of array. Note that if the array is empty, the `found` is false.

Example
package main

import (
	"fmt"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Any Pop* functions pick, delete and return the item from array.

	fmt.Println(array.PopLeft())
	fmt.Println(array.PopLefts(2))
	fmt.Println(array.PopRight())
	fmt.Println(array.PopRights(2))

}
Output:

1 true
[2 3]
9 true
[7 8]

func (*Array) PopLefts

func (a *Array) PopLefts(size int) []interface{}

PopLefts pops and returns `size` items from the beginning of array.

Example
package main

import (
	"fmt"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Any Pop* functions pick, delete and return the item from array.

	fmt.Println(array.PopLeft())
	fmt.Println(array.PopLefts(2))
	fmt.Println(array.PopRight())
	fmt.Println(array.PopRights(2))

}
Output:

1 true
[2 3]
9 true
[7 8]

func (*Array) PopRand

func (a *Array) PopRand() (value interface{}, found bool)

PopRand randomly pops and return an item out of array. Note that if the array is empty, the `found` is false.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Randomly retrieve and return 2 items from the array.
	// It does not delete the items from array.
	fmt.Println(array.Rands(2))

	// Randomly pick and return one item from the array.
	// It deletes the picked up item from array.
	fmt.Println(array.PopRand())
}
Output:

func (*Array) PopRands

func (a *Array) PopRands(size int) []interface{}

PopRands randomly pops and returns `size` items out of array.

func (*Array) PopRight

func (a *Array) PopRight() (value interface{}, found bool)

PopRight pops and returns an item from the end of array. Note that if the array is empty, the `found` is false.

Example
package main

import (
	"fmt"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Any Pop* functions pick, delete and return the item from array.

	fmt.Println(array.PopLeft())
	fmt.Println(array.PopLefts(2))
	fmt.Println(array.PopRight())
	fmt.Println(array.PopRights(2))

}
Output:

1 true
[2 3]
9 true
[7 8]

func (*Array) PopRights

func (a *Array) PopRights(size int) []interface{}

PopRights pops and returns `size` items from the end of array.

Example
package main

import (
	"fmt"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Any Pop* functions pick, delete and return the item from array.

	fmt.Println(array.PopLeft())
	fmt.Println(array.PopLefts(2))
	fmt.Println(array.PopRight())
	fmt.Println(array.PopRights(2))

}
Output:

1 true
[2 3]
9 true
[7 8]

func (*Array) PushLeft

func (a *Array) PushLeft(value ...interface{}) *Array

PushLeft pushes one or multiple items to the beginning of array.

func (*Array) PushRight

func (a *Array) PushRight(value ...interface{}) *Array

PushRight pushes one or multiple items to the end of array. It equals to Append.

func (*Array) RLockFunc

func (a *Array) RLockFunc(f func(array []interface{})) *Array

RLockFunc locks reading by callback function `f`.

func (*Array) Rand

func (a *Array) Rand() (value interface{}, found bool)

Rand randomly returns one item from array(no deleting).

func (*Array) Rands

func (a *Array) Rands(size int) []interface{}

Rands randomly returns `size` items from array(no deleting).

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Randomly retrieve and return 2 items from the array.
	// It does not delete the items from array.
	fmt.Println(array.Rands(2))

	// Randomly pick and return one item from the array.
	// It deletes the picked up item from array.
	fmt.Println(array.PopRand())
}
Output:

func (*Array) Range

func (a *Array) Range(start int, end ...int) []interface{}

Range picks and returns items by range, like array[start:end]. Notice, if in concurrent-safe usage, it returns a copy of slice; else a pointer to the underlying data.

If `end` is negative, then the offset will start from the end of array. If `end` is omitted, then the sequence will have everything from start up until the end of the array.

func (*Array) Remove

func (a *Array) Remove(index int) (value interface{}, found bool)

Remove removes an item by index. If the given `index` is out of range of the array, the `found` is false.

func (*Array) RemoveValue

func (a *Array) RemoveValue(value interface{}) bool

RemoveValue removes an item by value. It returns true if value is found in the array, or else false if not found.

func (*Array) Replace

func (a *Array) Replace(array []interface{}) *Array

Replace replaces the array items by given `array` from the beginning of array.

func (*Array) Reverse

func (a *Array) Reverse() *Array

Reverse makes array with elements in reverse order.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Reverse makes array with elements in reverse order.
	fmt.Println(array.Reverse().Slice())

}
Output:

[9 8 7 6 5 4 3 2 1]

func (*Array) Search

func (a *Array) Search(value interface{}) int

Search searches array by `value`, returns the index of `value`, or returns -1 if not exists.

func (*Array) Set

func (a *Array) Set(index int, value interface{}) error

Set sets value to specified index.

func (*Array) SetArray

func (a *Array) SetArray(array []interface{}) *Array

SetArray sets the underlying slice array with the given `array`.

func (*Array) Shuffle

func (a *Array) Shuffle() *Array

Shuffle randomly shuffles the array.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/frame/g"

	"github.com/gogf/gf/container/garray"
)

func main() {
	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})

	// Shuffle randomly shuffles the array.
	fmt.Println(array.Shuffle().Slice())
}
Output:

func (*Array) Slice

func (a *Array) Slice() []interface{}

Slice returns the underlying data of array. Note that, if it's in concurrent-safe usage, it returns a copy of underlying data, or else a pointer to the underlying data.

func (*Array) SortFunc

func (a *Array) SortFunc(less func(v1, v2 interface{}) bool) *Array

SortFunc sorts the array by custom function `less`.

func (*Array) String

func (a *Array) String() string

String returns current array as a string, which implements like json.Marshal does.

func (*Array) SubSlice

func (a *Array) SubSlice(offset int, length ...int) []interface{}

SubSlice returns a slice of elements from the array as specified by the `offset` and `size` parameters. If in concurrent safe usage, it returns a copy of the slice; else a pointer.

If offset is non-negative, the sequence will start at that offset in the array. If offset is negative, the sequence will start that far from the end of the array.

If length is given and is positive, then the sequence will have up to that many elements in it. If the array is shorter than the length, then only the available array elements will be present. If length is given and is negative then the sequence will stop that many elements from the end of the array. If it is omitted, then the sequence will have everything from offset up until the end of the array.

Any possibility crossing the left border of array, it will fail.

func (*Array) Sum

func (a *Array) Sum() (sum int)

Sum returns the sum of values in an array.

func (*Array) Unique

func (a *Array) Unique() *Array

Unique uniques the array, clear repeated items. Example: [1,1,2,3,2] -> [1,2,3]

func (*Array) UnmarshalJSON

func (a *Array) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

func (*Array) UnmarshalValue

func (a *Array) UnmarshalValue(value interface{}) error

UnmarshalValue is an interface implement which sets any type of value for array.

func (*Array) Walk

func (a *Array) Walk(f func(value interface{}) interface{}) *Array

Walk applies a user supplied function `f` to every item of array.

type IntArray

type IntArray struct {
	// contains filtered or unexported fields
}

IntArray is a golang int array with rich features. It contains a concurrent-safe/unsafe switch, which should be set when its initialization and cannot be changed then.

func NewIntArray

func NewIntArray(safe ...bool) *IntArray

NewIntArray creates and returns an empty array. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewIntArrayFrom

func NewIntArrayFrom(array []int, safe ...bool) *IntArray

NewIntArrayFrom creates and returns an array with given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewIntArrayFromCopy

func NewIntArrayFromCopy(array []int, safe ...bool) *IntArray

NewIntArrayFromCopy creates and returns an array from a copy of given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewIntArrayRange

func NewIntArrayRange(start, end, step int, safe ...bool) *IntArray

NewIntArrayRange creates and returns a array by a range from `start` to `end` with step value `step`.

func NewIntArraySize

func NewIntArraySize(size int, cap int, safe ...bool) *IntArray

NewIntArraySize create and returns an array with given size and cap. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func (*IntArray) Append

func (a *IntArray) Append(value ...int) *IntArray

See PushRight.

func (*IntArray) At

func (a *IntArray) At(index int) (value int)

At returns the value by the specified index. If the given `index` is out of range of the array, it returns `0`.

func (*IntArray) Chunk

func (a *IntArray) Chunk(size int) [][]int

Chunk splits an array into multiple arrays, the size of each array is determined by `size`. The last chunk may contain less than size elements.

func (*IntArray) Clear

func (a *IntArray) Clear() *IntArray

Clear deletes all items of current array.

func (*IntArray) Clone

func (a *IntArray) Clone() (newArray *IntArray)

Clone returns a new array, which is a copy of current array.

func (*IntArray) Contains

func (a *IntArray) Contains(value int) bool

Contains checks whether a value exists in the array.

func (*IntArray) CountValues

func (a *IntArray) CountValues() map[int]int

CountValues counts the number of occurrences of all values in the array.

func (*IntArray) Fill

func (a *IntArray) Fill(startIndex int, num int, value int) error

Fill fills an array with num entries of the value `value`, keys starting at the `startIndex` parameter.

func (*IntArray) FilterEmpty

func (a *IntArray) FilterEmpty() *IntArray

FilterEmpty removes all zero value of the array.

func (*IntArray) Get

func (a *IntArray) Get(index int) (value int, found bool)

Get returns the value by the specified index. If the given `index` is out of range of the array, the `found` is false.

func (*IntArray) InsertAfter

func (a *IntArray) InsertAfter(index int, value int) error

InsertAfter inserts the `value` to the back of `index`.

func (*IntArray) InsertBefore

func (a *IntArray) InsertBefore(index int, value int) error

InsertBefore inserts the `value` to the front of `index`.

func (*IntArray) Interfaces

func (a *IntArray) Interfaces() []interface{}

Interfaces returns current array as []interface{}.

func (*IntArray) IsEmpty

func (a *IntArray) IsEmpty() bool

IsEmpty checks whether the array is empty.

func (*IntArray) Iterator

func (a *IntArray) Iterator(f func(k int, v int) bool)

Iterator is alias of IteratorAsc.

func (*IntArray) IteratorAsc

func (a *IntArray) IteratorAsc(f func(k int, v int) bool)

IteratorAsc iterates the array readonly in ascending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*IntArray) IteratorDesc

func (a *IntArray) IteratorDesc(f func(k int, v int) bool)

IteratorDesc iterates the array readonly in descending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*IntArray) Join

func (a *IntArray) Join(glue string) string

Join joins array elements with a string `glue`.

func (*IntArray) Len

func (a *IntArray) Len() int

Len returns the length of array.

func (*IntArray) LockFunc

func (a *IntArray) LockFunc(f func(array []int)) *IntArray

LockFunc locks writing by callback function `f`.

func (IntArray) MarshalJSON

func (a IntArray) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal. Note that do not use pointer as its receiver here.

func (*IntArray) Merge

func (a *IntArray) Merge(array interface{}) *IntArray

Merge merges `array` into current array. The parameter `array` can be any garray or slice type. The difference between Merge and Append is Append supports only specified slice type, but Merge supports more parameter types.

func (*IntArray) Pad

func (a *IntArray) Pad(size int, value int) *IntArray

Pad pads array to the specified length with `value`. If size is positive then the array is padded on the right, or negative on the left. If the absolute value of `size` is less than or equal to the length of the array then no padding takes place.

func (*IntArray) PopLeft

func (a *IntArray) PopLeft() (value int, found bool)

PopLeft pops and returns an item from the beginning of array. Note that if the array is empty, the `found` is false.

func (*IntArray) PopLefts

func (a *IntArray) PopLefts(size int) []int

PopLefts pops and returns `size` items from the beginning of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*IntArray) PopRand

func (a *IntArray) PopRand() (value int, found bool)

PopRand randomly pops and return an item out of array. Note that if the array is empty, the `found` is false.

func (*IntArray) PopRands

func (a *IntArray) PopRands(size int) []int

PopRands randomly pops and returns `size` items out of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*IntArray) PopRight

func (a *IntArray) PopRight() (value int, found bool)

PopRight pops and returns an item from the end of array. Note that if the array is empty, the `found` is false.

func (*IntArray) PopRights

func (a *IntArray) PopRights(size int) []int

PopRights pops and returns `size` items from the end of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*IntArray) PushLeft

func (a *IntArray) PushLeft(value ...int) *IntArray

PushLeft pushes one or multiple items to the beginning of array.

func (*IntArray) PushRight

func (a *IntArray) PushRight(value ...int) *IntArray

PushRight pushes one or multiple items to the end of array. It equals to Append.

func (*IntArray) RLockFunc

func (a *IntArray) RLockFunc(f func(array []int)) *IntArray

RLockFunc locks reading by callback function `f`.

func (*IntArray) Rand

func (a *IntArray) Rand() (value int, found bool)

Rand randomly returns one item from array(no deleting).

func (*IntArray) Rands

func (a *IntArray) Rands(size int) []int

Rands randomly returns `size` items from array(no deleting).

func (*IntArray) Range

func (a *IntArray) Range(start int, end ...int) []int

Range picks and returns items by range, like array[start:end]. Notice, if in concurrent-safe usage, it returns a copy of slice; else a pointer to the underlying data.

If `end` is negative, then the offset will start from the end of array. If `end` is omitted, then the sequence will have everything from start up until the end of the array.

func (*IntArray) Remove

func (a *IntArray) Remove(index int) (value int, found bool)

Remove removes an item by index. If the given `index` is out of range of the array, the `found` is false.

func (*IntArray) RemoveValue

func (a *IntArray) RemoveValue(value int) bool

RemoveValue removes an item by value. It returns true if value is found in the array, or else false if not found.

func (*IntArray) Replace

func (a *IntArray) Replace(array []int) *IntArray

Replace replaces the array items by given `array` from the beginning of array.

func (*IntArray) Reverse

func (a *IntArray) Reverse() *IntArray

Reverse makes array with elements in reverse order.

func (*IntArray) Search

func (a *IntArray) Search(value int) int

Search searches array by `value`, returns the index of `value`, or returns -1 if not exists.

func (*IntArray) Set

func (a *IntArray) Set(index int, value int) error

Set sets value to specified index.

func (*IntArray) SetArray

func (a *IntArray) SetArray(array []int) *IntArray

SetArray sets the underlying slice array with the given `array`.

func (*IntArray) Shuffle

func (a *IntArray) Shuffle() *IntArray

Shuffle randomly shuffles the array.

func (*IntArray) Slice

func (a *IntArray) Slice() []int

Slice returns the underlying data of array. Note that, if it's in concurrent-safe usage, it returns a copy of underlying data, or else a pointer to the underlying data.

func (*IntArray) Sort

func (a *IntArray) Sort(reverse ...bool) *IntArray

Sort sorts the array in increasing order. The parameter `reverse` controls whether sort in increasing order(default) or decreasing order.

func (*IntArray) SortFunc

func (a *IntArray) SortFunc(less func(v1, v2 int) bool) *IntArray

SortFunc sorts the array by custom function `less`.

func (*IntArray) String

func (a *IntArray) String() string

String returns current array as a string, which implements like json.Marshal does.

func (*IntArray) SubSlice

func (a *IntArray) SubSlice(offset int, length ...int) []int

SubSlice returns a slice of elements from the array as specified by the `offset` and `size` parameters. If in concurrent safe usage, it returns a copy of the slice; else a pointer.

If offset is non-negative, the sequence will start at that offset in the array. If offset is negative, the sequence will start that far from the end of the array.

If length is given and is positive, then the sequence will have up to that many elements in it. If the array is shorter than the length, then only the available array elements will be present. If length is given and is negative then the sequence will stop that many elements from the end of the array. If it is omitted, then the sequence will have everything from offset up until the end of the array.

Any possibility crossing the left border of array, it will fail.

func (*IntArray) Sum

func (a *IntArray) Sum() (sum int)

Sum returns the sum of values in an array.

func (*IntArray) Unique

func (a *IntArray) Unique() *IntArray

Unique uniques the array, clear repeated items. Example: [1,1,2,3,2] -> [1,2,3]

func (*IntArray) UnmarshalJSON

func (a *IntArray) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

func (*IntArray) UnmarshalValue

func (a *IntArray) UnmarshalValue(value interface{}) error

UnmarshalValue is an interface implement which sets any type of value for array.

func (*IntArray) Walk

func (a *IntArray) Walk(f func(value int) int) *IntArray

Walk applies a user supplied function `f` to every item of array.

type SortedArray

type SortedArray struct {
	// contains filtered or unexported fields
}

SortedArray is a golang sorted array with rich features. It is using increasing order in default, which can be changed by setting it a custom comparator. It contains a concurrent-safe/unsafe switch, which should be set when its initialization and cannot be changed then.

func NewSortedArray

func NewSortedArray(comparator func(a, b interface{}) int, safe ...bool) *SortedArray

NewSortedArray creates and returns an empty sorted array. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default. The parameter `comparator` used to compare values to sort in array, if it returns value < 0, means v1 < v2; the v1 will be inserted before v2; if it returns value = 0, means v1 = v2; the v1 will be replaced by v2; if it returns value > 0, means v1 > v2; the v1 will be inserted after v2;

func NewSortedArrayFrom

func NewSortedArrayFrom(array []interface{}, comparator func(a, b interface{}) int, safe ...bool) *SortedArray

NewSortedArrayFrom creates and returns an sorted array with given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedArrayFromCopy

func NewSortedArrayFromCopy(array []interface{}, comparator func(a, b interface{}) int, safe ...bool) *SortedArray

NewSortedArrayFromCopy creates and returns an sorted array from a copy of given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedArrayRange

func NewSortedArrayRange(start, end, step int, comparator func(a, b interface{}) int, safe ...bool) *SortedArray

NewSortedArrayRange creates and returns a array by a range from `start` to `end` with step value `step`.

func NewSortedArraySize

func NewSortedArraySize(cap int, comparator func(a, b interface{}) int, safe ...bool) *SortedArray

NewSortedArraySize create and returns an sorted array with given size and cap. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func (*SortedArray) Add

func (a *SortedArray) Add(values ...interface{}) *SortedArray

Add adds one or multiple values to sorted array, the array always keeps sorted. It's alias of function Append, see Append.

func (*SortedArray) Append

func (a *SortedArray) Append(values ...interface{}) *SortedArray

Append adds one or multiple values to sorted array, the array always keeps sorted.

func (*SortedArray) At

func (a *SortedArray) At(index int) (value interface{})

At returns the value by the specified index. If the given `index` is out of range of the array, it returns `nil`.

func (*SortedArray) Chunk

func (a *SortedArray) Chunk(size int) [][]interface{}

Chunk splits an array into multiple arrays, the size of each array is determined by `size`. The last chunk may contain less than size elements.

func (*SortedArray) Clear

func (a *SortedArray) Clear() *SortedArray

Clear deletes all items of current array.

func (*SortedArray) Clone

func (a *SortedArray) Clone() (newArray *SortedArray)

Clone returns a new array, which is a copy of current array.

func (*SortedArray) Contains

func (a *SortedArray) Contains(value interface{}) bool

Contains checks whether a value exists in the array.

func (*SortedArray) CountValues

func (a *SortedArray) CountValues() map[interface{}]int

CountValues counts the number of occurrences of all values in the array.

func (*SortedArray) FilterEmpty

func (a *SortedArray) FilterEmpty() *SortedArray

FilterEmpty removes all empty value of the array. Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.

func (*SortedArray) FilterNil

func (a *SortedArray) FilterNil() *SortedArray

FilterNil removes all nil value of the array.

func (*SortedArray) Get

func (a *SortedArray) Get(index int) (value interface{}, found bool)

Get returns the value by the specified index. If the given `index` is out of range of the array, the `found` is false.

func (*SortedArray) Interfaces

func (a *SortedArray) Interfaces() []interface{}

Interfaces returns current array as []interface{}.

func (*SortedArray) IsEmpty

func (a *SortedArray) IsEmpty() bool

IsEmpty checks whether the array is empty.

func (*SortedArray) Iterator

func (a *SortedArray) Iterator(f func(k int, v interface{}) bool)

Iterator is alias of IteratorAsc.

func (*SortedArray) IteratorAsc

func (a *SortedArray) IteratorAsc(f func(k int, v interface{}) bool)

IteratorAsc iterates the array readonly in ascending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*SortedArray) IteratorDesc

func (a *SortedArray) IteratorDesc(f func(k int, v interface{}) bool)

IteratorDesc iterates the array readonly in descending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*SortedArray) Join

func (a *SortedArray) Join(glue string) string

Join joins array elements with a string `glue`.

func (*SortedArray) Len

func (a *SortedArray) Len() int

Len returns the length of array.

func (*SortedArray) LockFunc

func (a *SortedArray) LockFunc(f func(array []interface{})) *SortedArray

LockFunc locks writing by callback function `f`.

func (SortedArray) MarshalJSON

func (a SortedArray) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal. Note that do not use pointer as its receiver here.

func (*SortedArray) Merge

func (a *SortedArray) Merge(array interface{}) *SortedArray

Merge merges `array` into current array. The parameter `array` can be any garray or slice type. The difference between Merge and Append is Append supports only specified slice type, but Merge supports more parameter types.

func (*SortedArray) PopLeft

func (a *SortedArray) PopLeft() (value interface{}, found bool)

PopLeft pops and returns an item from the beginning of array. Note that if the array is empty, the `found` is false.

func (*SortedArray) PopLefts

func (a *SortedArray) PopLefts(size int) []interface{}

PopLefts pops and returns `size` items from the beginning of array.

func (*SortedArray) PopRand

func (a *SortedArray) PopRand() (value interface{}, found bool)

PopRand randomly pops and return an item out of array. Note that if the array is empty, the `found` is false.

func (*SortedArray) PopRands

func (a *SortedArray) PopRands(size int) []interface{}

PopRands randomly pops and returns `size` items out of array.

func (*SortedArray) PopRight

func (a *SortedArray) PopRight() (value interface{}, found bool)

PopRight pops and returns an item from the end of array. Note that if the array is empty, the `found` is false.

func (*SortedArray) PopRights

func (a *SortedArray) PopRights(size int) []interface{}

PopRights pops and returns `size` items from the end of array.

func (*SortedArray) RLockFunc

func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray

RLockFunc locks reading by callback function `f`.

func (*SortedArray) Rand

func (a *SortedArray) Rand() (value interface{}, found bool)

Rand randomly returns one item from array(no deleting).

func (*SortedArray) Rands

func (a *SortedArray) Rands(size int) []interface{}

Rands randomly returns `size` items from array(no deleting).

func (*SortedArray) Range

func (a *SortedArray) Range(start int, end ...int) []interface{}

Range picks and returns items by range, like array[start:end]. Notice, if in concurrent-safe usage, it returns a copy of slice; else a pointer to the underlying data.

If `end` is negative, then the offset will start from the end of array. If `end` is omitted, then the sequence will have everything from start up until the end of the array.

func (*SortedArray) Remove

func (a *SortedArray) Remove(index int) (value interface{}, found bool)

Remove removes an item by index. If the given `index` is out of range of the array, the `found` is false.

func (*SortedArray) RemoveValue

func (a *SortedArray) RemoveValue(value interface{}) bool

RemoveValue removes an item by value. It returns true if value is found in the array, or else false if not found.

func (*SortedArray) Search

func (a *SortedArray) Search(value interface{}) (index int)

Search searches array by `value`, returns the index of `value`, or returns -1 if not exists.

func (*SortedArray) SetArray

func (a *SortedArray) SetArray(array []interface{}) *SortedArray

SetArray sets the underlying slice array with the given `array`.

func (*SortedArray) SetComparator

func (a *SortedArray) SetComparator(comparator func(a, b interface{}) int)

SetComparator sets/changes the comparator for sorting. It resorts the array as the comparator is changed.

func (*SortedArray) SetUnique

func (a *SortedArray) SetUnique(unique bool) *SortedArray

SetUnique sets unique mark to the array, which means it does not contain any repeated items. It also do unique check, remove all repeated items.

func (*SortedArray) Slice

func (a *SortedArray) Slice() []interface{}

Slice returns the underlying data of array. Note that, if it's in concurrent-safe usage, it returns a copy of underlying data, or else a pointer to the underlying data.

func (*SortedArray) Sort

func (a *SortedArray) Sort() *SortedArray

Sort sorts the array in increasing order. The parameter `reverse` controls whether sort in increasing order(default) or decreasing order

func (*SortedArray) String

func (a *SortedArray) String() string

String returns current array as a string, which implements like json.Marshal does.

func (*SortedArray) SubSlice

func (a *SortedArray) SubSlice(offset int, length ...int) []interface{}

SubSlice returns a slice of elements from the array as specified by the `offset` and `size` parameters. If in concurrent safe usage, it returns a copy of the slice; else a pointer.

If offset is non-negative, the sequence will start at that offset in the array. If offset is negative, the sequence will start that far from the end of the array.

If length is given and is positive, then the sequence will have up to that many elements in it. If the array is shorter than the length, then only the available array elements will be present. If length is given and is negative then the sequence will stop that many elements from the end of the array. If it is omitted, then the sequence will have everything from offset up until the end of the array.

Any possibility crossing the left border of array, it will fail.

func (*SortedArray) Sum

func (a *SortedArray) Sum() (sum int)

Sum returns the sum of values in an array.

func (*SortedArray) Unique

func (a *SortedArray) Unique() *SortedArray

Unique uniques the array, clear repeated items.

func (*SortedArray) UnmarshalJSON

func (a *SortedArray) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. Note that the comparator is set as string comparator in default.

func (*SortedArray) UnmarshalValue

func (a *SortedArray) UnmarshalValue(value interface{}) (err error)

UnmarshalValue is an interface implement which sets any type of value for array. Note that the comparator is set as string comparator in default.

func (*SortedArray) Walk

func (a *SortedArray) Walk(f func(value interface{}) interface{}) *SortedArray

Walk applies a user supplied function `f` to every item of array.

type SortedIntArray

type SortedIntArray struct {
	// contains filtered or unexported fields
}

SortedIntArray is a golang sorted int array with rich features. It is using increasing order in default, which can be changed by setting it a custom comparator. It contains a concurrent-safe/unsafe switch, which should be set when its initialization and cannot be changed then.

func NewSortedIntArray

func NewSortedIntArray(safe ...bool) *SortedIntArray

NewSortedIntArray creates and returns an empty sorted array. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedIntArrayComparator

func NewSortedIntArrayComparator(comparator func(a, b int) int, safe ...bool) *SortedIntArray

NewSortedIntArrayComparator creates and returns an empty sorted array with specified comparator. The parameter `safe` is used to specify whether using array in concurrent-safety which is false in default.

func NewSortedIntArrayFrom

func NewSortedIntArrayFrom(array []int, safe ...bool) *SortedIntArray

NewSortedIntArrayFrom creates and returns an sorted array with given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedIntArrayFromCopy

func NewSortedIntArrayFromCopy(array []int, safe ...bool) *SortedIntArray

NewSortedIntArrayFromCopy creates and returns an sorted array from a copy of given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedIntArrayRange

func NewSortedIntArrayRange(start, end, step int, safe ...bool) *SortedIntArray

NewSortedIntArrayRange creates and returns a array by a range from `start` to `end` with step value `step`.

func NewSortedIntArraySize

func NewSortedIntArraySize(cap int, safe ...bool) *SortedIntArray

NewSortedIntArraySize create and returns an sorted array with given size and cap. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func (*SortedIntArray) Add

func (a *SortedIntArray) Add(values ...int) *SortedIntArray

Add adds one or multiple values to sorted array, the array always keeps sorted. It's alias of function Append, see Append.

func (*SortedIntArray) Append

func (a *SortedIntArray) Append(values ...int) *SortedIntArray

Append adds one or multiple values to sorted array, the array always keeps sorted.

func (*SortedIntArray) At

func (a *SortedIntArray) At(index int) (value int)

At returns the value by the specified index. If the given `index` is out of range of the array, it returns `0`.

func (*SortedIntArray) Chunk

func (a *SortedIntArray) Chunk(size int) [][]int

Chunk splits an array into multiple arrays, the size of each array is determined by `size`. The last chunk may contain less than size elements.

func (*SortedIntArray) Clear

func (a *SortedIntArray) Clear() *SortedIntArray

Clear deletes all items of current array.

func (*SortedIntArray) Clone

func (a *SortedIntArray) Clone() (newArray *SortedIntArray)

Clone returns a new array, which is a copy of current array.

func (*SortedIntArray) Contains

func (a *SortedIntArray) Contains(value int) bool

Contains checks whether a value exists in the array.

func (*SortedIntArray) CountValues

func (a *SortedIntArray) CountValues() map[int]int

CountValues counts the number of occurrences of all values in the array.

func (*SortedIntArray) FilterEmpty

func (a *SortedIntArray) FilterEmpty() *SortedIntArray

FilterEmpty removes all zero value of the array.

func (*SortedIntArray) Get

func (a *SortedIntArray) Get(index int) (value int, found bool)

Get returns the value by the specified index. If the given `index` is out of range of the array, the `found` is false.

func (*SortedIntArray) Interfaces

func (a *SortedIntArray) Interfaces() []interface{}

Interfaces returns current array as []interface{}.

func (*SortedIntArray) IsEmpty

func (a *SortedIntArray) IsEmpty() bool

IsEmpty checks whether the array is empty.

func (*SortedIntArray) Iterator

func (a *SortedIntArray) Iterator(f func(k int, v int) bool)

Iterator is alias of IteratorAsc.

func (*SortedIntArray) IteratorAsc

func (a *SortedIntArray) IteratorAsc(f func(k int, v int) bool)

IteratorAsc iterates the array readonly in ascending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*SortedIntArray) IteratorDesc

func (a *SortedIntArray) IteratorDesc(f func(k int, v int) bool)

IteratorDesc iterates the array readonly in descending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*SortedIntArray) Join

func (a *SortedIntArray) Join(glue string) string

Join joins array elements with a string `glue`.

func (*SortedIntArray) Len

func (a *SortedIntArray) Len() int

Len returns the length of array.

func (*SortedIntArray) LockFunc

func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray

LockFunc locks writing by callback function `f`.

func (SortedIntArray) MarshalJSON

func (a SortedIntArray) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal. Note that do not use pointer as its receiver here.

func (*SortedIntArray) Merge

func (a *SortedIntArray) Merge(array interface{}) *SortedIntArray

Merge merges `array` into current array. The parameter `array` can be any garray or slice type. The difference between Merge and Append is Append supports only specified slice type, but Merge supports more parameter types.

func (*SortedIntArray) PopLeft

func (a *SortedIntArray) PopLeft() (value int, found bool)

PopLeft pops and returns an item from the beginning of array. Note that if the array is empty, the `found` is false.

func (*SortedIntArray) PopLefts

func (a *SortedIntArray) PopLefts(size int) []int

PopLefts pops and returns `size` items from the beginning of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*SortedIntArray) PopRand

func (a *SortedIntArray) PopRand() (value int, found bool)

PopRand randomly pops and return an item out of array. Note that if the array is empty, the `found` is false.

func (*SortedIntArray) PopRands

func (a *SortedIntArray) PopRands(size int) []int

PopRands randomly pops and returns `size` items out of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*SortedIntArray) PopRight

func (a *SortedIntArray) PopRight() (value int, found bool)

PopRight pops and returns an item from the end of array. Note that if the array is empty, the `found` is false.

func (*SortedIntArray) PopRights

func (a *SortedIntArray) PopRights(size int) []int

PopRights pops and returns `size` items from the end of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*SortedIntArray) RLockFunc

func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray

RLockFunc locks reading by callback function `f`.

func (*SortedIntArray) Rand

func (a *SortedIntArray) Rand() (value int, found bool)

Rand randomly returns one item from array(no deleting).

func (*SortedIntArray) Rands

func (a *SortedIntArray) Rands(size int) []int

Rands randomly returns `size` items from array(no deleting).

func (*SortedIntArray) Range

func (a *SortedIntArray) Range(start int, end ...int) []int

Range picks and returns items by range, like array[start:end]. Notice, if in concurrent-safe usage, it returns a copy of slice; else a pointer to the underlying data.

If `end` is negative, then the offset will start from the end of array. If `end` is omitted, then the sequence will have everything from start up until the end of the array.

func (*SortedIntArray) Remove

func (a *SortedIntArray) Remove(index int) (value int, found bool)

Remove removes an item by index. If the given `index` is out of range of the array, the `found` is false.

func (*SortedIntArray) RemoveValue

func (a *SortedIntArray) RemoveValue(value int) bool

RemoveValue removes an item by value. It returns true if value is found in the array, or else false if not found.

func (*SortedIntArray) Search

func (a *SortedIntArray) Search(value int) (index int)

Search searches array by `value`, returns the index of `value`, or returns -1 if not exists.

func (*SortedIntArray) SetArray

func (a *SortedIntArray) SetArray(array []int) *SortedIntArray

SetArray sets the underlying slice array with the given `array`.

func (*SortedIntArray) SetUnique

func (a *SortedIntArray) SetUnique(unique bool) *SortedIntArray

SetUnique sets unique mark to the array, which means it does not contain any repeated items. It also do unique check, remove all repeated items.

func (*SortedIntArray) Slice

func (a *SortedIntArray) Slice() []int

Slice returns the underlying data of array. Note that, if it's in concurrent-safe usage, it returns a copy of underlying data, or else a pointer to the underlying data.

func (*SortedIntArray) Sort

func (a *SortedIntArray) Sort() *SortedIntArray

Sort sorts the array in increasing order. The parameter `reverse` controls whether sort in increasing order(default) or decreasing order.

func (*SortedIntArray) String

func (a *SortedIntArray) String() string

String returns current array as a string, which implements like json.Marshal does.

func (*SortedIntArray) SubSlice

func (a *SortedIntArray) SubSlice(offset int, length ...int) []int

SubSlice returns a slice of elements from the array as specified by the `offset` and `size` parameters. If in concurrent safe usage, it returns a copy of the slice; else a pointer.

If offset is non-negative, the sequence will start at that offset in the array. If offset is negative, the sequence will start that far from the end of the array.

If length is given and is positive, then the sequence will have up to that many elements in it. If the array is shorter than the length, then only the available array elements will be present. If length is given and is negative then the sequence will stop that many elements from the end of the array. If it is omitted, then the sequence will have everything from offset up until the end of the array.

Any possibility crossing the left border of array, it will fail.

func (*SortedIntArray) Sum

func (a *SortedIntArray) Sum() (sum int)

Sum returns the sum of values in an array.

func (*SortedIntArray) Unique

func (a *SortedIntArray) Unique() *SortedIntArray

Unique uniques the array, clear repeated items.

func (*SortedIntArray) UnmarshalJSON

func (a *SortedIntArray) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

func (*SortedIntArray) UnmarshalValue

func (a *SortedIntArray) UnmarshalValue(value interface{}) (err error)

UnmarshalValue is an interface implement which sets any type of value for array.

func (*SortedIntArray) Walk

func (a *SortedIntArray) Walk(f func(value int) int) *SortedIntArray

Walk applies a user supplied function `f` to every item of array.

type SortedStrArray

type SortedStrArray struct {
	// contains filtered or unexported fields
}

SortedStrArray is a golang sorted string array with rich features. It is using increasing order in default, which can be changed by setting it a custom comparator. It contains a concurrent-safe/unsafe switch, which should be set when its initialization and cannot be changed then.

func NewSortedStrArray

func NewSortedStrArray(safe ...bool) *SortedStrArray

NewSortedStrArray creates and returns an empty sorted array. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedStrArrayComparator

func NewSortedStrArrayComparator(comparator func(a, b string) int, safe ...bool) *SortedStrArray

NewSortedStrArrayComparator creates and returns an empty sorted array with specified comparator. The parameter `safe` is used to specify whether using array in concurrent-safety which is false in default.

func NewSortedStrArrayFrom

func NewSortedStrArrayFrom(array []string, safe ...bool) *SortedStrArray

NewSortedStrArrayFrom creates and returns an sorted array with given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedStrArrayFromCopy

func NewSortedStrArrayFromCopy(array []string, safe ...bool) *SortedStrArray

NewSortedStrArrayFromCopy creates and returns an sorted array from a copy of given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewSortedStrArraySize

func NewSortedStrArraySize(cap int, safe ...bool) *SortedStrArray

NewSortedStrArraySize create and returns an sorted array with given size and cap. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func (*SortedStrArray) Add

func (a *SortedStrArray) Add(values ...string) *SortedStrArray

Add adds one or multiple values to sorted array, the array always keeps sorted. It's alias of function Append, see Append.

func (*SortedStrArray) Append

func (a *SortedStrArray) Append(values ...string) *SortedStrArray

Append adds one or multiple values to sorted array, the array always keeps sorted.

func (*SortedStrArray) At

func (a *SortedStrArray) At(index int) (value string)

At returns the value by the specified index. If the given `index` is out of range of the array, it returns an empty string.

func (*SortedStrArray) Chunk

func (a *SortedStrArray) Chunk(size int) [][]string

Chunk splits an array into multiple arrays, the size of each array is determined by `size`. The last chunk may contain less than size elements.

func (*SortedStrArray) Clear

func (a *SortedStrArray) Clear() *SortedStrArray

Clear deletes all items of current array.

func (*SortedStrArray) Clone

func (a *SortedStrArray) Clone() (newArray *SortedStrArray)

Clone returns a new array, which is a copy of current array.

func (*SortedStrArray) Contains

func (a *SortedStrArray) Contains(value string) bool

Contains checks whether a value exists in the array.

func (*SortedStrArray) ContainsI

func (a *SortedStrArray) ContainsI(value string) bool

ContainsI checks whether a value exists in the array with case-insensitively. Note that it internally iterates the whole array to do the comparison with case-insensitively.

func (*SortedStrArray) CountValues

func (a *SortedStrArray) CountValues() map[string]int

CountValues counts the number of occurrences of all values in the array.

func (*SortedStrArray) FilterEmpty

func (a *SortedStrArray) FilterEmpty() *SortedStrArray

FilterEmpty removes all empty string value of the array.

func (*SortedStrArray) Get

func (a *SortedStrArray) Get(index int) (value string, found bool)

Get returns the value by the specified index. If the given `index` is out of range of the array, the `found` is false.

func (*SortedStrArray) Interfaces

func (a *SortedStrArray) Interfaces() []interface{}

Interfaces returns current array as []interface{}.

func (*SortedStrArray) IsEmpty

func (a *SortedStrArray) IsEmpty() bool

IsEmpty checks whether the array is empty.

func (*SortedStrArray) Iterator

func (a *SortedStrArray) Iterator(f func(k int, v string) bool)

Iterator is alias of IteratorAsc.

func (*SortedStrArray) IteratorAsc

func (a *SortedStrArray) IteratorAsc(f func(k int, v string) bool)

IteratorAsc iterates the array readonly in ascending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*SortedStrArray) IteratorDesc

func (a *SortedStrArray) IteratorDesc(f func(k int, v string) bool)

IteratorDesc iterates the array readonly in descending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*SortedStrArray) Join

func (a *SortedStrArray) Join(glue string) string

Join joins array elements with a string `glue`.

func (*SortedStrArray) Len

func (a *SortedStrArray) Len() int

Len returns the length of array.

func (*SortedStrArray) LockFunc

func (a *SortedStrArray) LockFunc(f func(array []string)) *SortedStrArray

LockFunc locks writing by callback function `f`.

func (SortedStrArray) MarshalJSON

func (a SortedStrArray) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal. Note that do not use pointer as its receiver here.

func (*SortedStrArray) Merge

func (a *SortedStrArray) Merge(array interface{}) *SortedStrArray

Merge merges `array` into current array. The parameter `array` can be any garray or slice type. The difference between Merge and Append is Append supports only specified slice type, but Merge supports more parameter types.

func (*SortedStrArray) PopLeft

func (a *SortedStrArray) PopLeft() (value string, found bool)

PopLeft pops and returns an item from the beginning of array. Note that if the array is empty, the `found` is false.

func (*SortedStrArray) PopLefts

func (a *SortedStrArray) PopLefts(size int) []string

PopLefts pops and returns `size` items from the beginning of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*SortedStrArray) PopRand

func (a *SortedStrArray) PopRand() (value string, found bool)

PopRand randomly pops and return an item out of array. Note that if the array is empty, the `found` is false.

func (*SortedStrArray) PopRands

func (a *SortedStrArray) PopRands(size int) []string

PopRands randomly pops and returns `size` items out of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*SortedStrArray) PopRight

func (a *SortedStrArray) PopRight() (value string, found bool)

PopRight pops and returns an item from the end of array. Note that if the array is empty, the `found` is false.

func (*SortedStrArray) PopRights

func (a *SortedStrArray) PopRights(size int) []string

PopRights pops and returns `size` items from the end of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*SortedStrArray) RLockFunc

func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray

RLockFunc locks reading by callback function `f`.

func (*SortedStrArray) Rand

func (a *SortedStrArray) Rand() (value string, found bool)

Rand randomly returns one item from array(no deleting).

func (*SortedStrArray) Rands

func (a *SortedStrArray) Rands(size int) []string

Rands randomly returns `size` items from array(no deleting).

func (*SortedStrArray) Range

func (a *SortedStrArray) Range(start int, end ...int) []string

Range picks and returns items by range, like array[start:end]. Notice, if in concurrent-safe usage, it returns a copy of slice; else a pointer to the underlying data.

If `end` is negative, then the offset will start from the end of array. If `end` is omitted, then the sequence will have everything from start up until the end of the array.

func (*SortedStrArray) Remove

func (a *SortedStrArray) Remove(index int) (value string, found bool)

Remove removes an item by index. If the given `index` is out of range of the array, the `found` is false.

func (*SortedStrArray) RemoveValue

func (a *SortedStrArray) RemoveValue(value string) bool

RemoveValue removes an item by value. It returns true if value is found in the array, or else false if not found.

func (*SortedStrArray) Search

func (a *SortedStrArray) Search(value string) (index int)

Search searches array by `value`, returns the index of `value`, or returns -1 if not exists.

func (*SortedStrArray) SetArray

func (a *SortedStrArray) SetArray(array []string) *SortedStrArray

SetArray sets the underlying slice array with the given `array`.

func (*SortedStrArray) SetUnique

func (a *SortedStrArray) SetUnique(unique bool) *SortedStrArray

SetUnique sets unique mark to the array, which means it does not contain any repeated items. It also do unique check, remove all repeated items.

func (*SortedStrArray) Slice

func (a *SortedStrArray) Slice() []string

Slice returns the underlying data of array. Note that, if it's in concurrent-safe usage, it returns a copy of underlying data, or else a pointer to the underlying data.

func (*SortedStrArray) Sort

func (a *SortedStrArray) Sort() *SortedStrArray

Sort sorts the array in increasing order. The parameter `reverse` controls whether sort in increasing order(default) or decreasing order.

func (*SortedStrArray) String

func (a *SortedStrArray) String() string

String returns current array as a string, which implements like json.Marshal does.

func (*SortedStrArray) SubSlice

func (a *SortedStrArray) SubSlice(offset int, length ...int) []string

SubSlice returns a slice of elements from the array as specified by the `offset` and `size` parameters. If in concurrent safe usage, it returns a copy of the slice; else a pointer.

If offset is non-negative, the sequence will start at that offset in the array. If offset is negative, the sequence will start that far from the end of the array.

If length is given and is positive, then the sequence will have up to that many elements in it. If the array is shorter than the length, then only the available array elements will be present. If length is given and is negative then the sequence will stop that many elements from the end of the array. If it is omitted, then the sequence will have everything from offset up until the end of the array.

Any possibility crossing the left border of array, it will fail.

func (*SortedStrArray) Sum

func (a *SortedStrArray) Sum() (sum int)

Sum returns the sum of values in an array.

func (*SortedStrArray) Unique

func (a *SortedStrArray) Unique() *SortedStrArray

Unique uniques the array, clear repeated items.

func (*SortedStrArray) UnmarshalJSON

func (a *SortedStrArray) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

func (*SortedStrArray) UnmarshalValue

func (a *SortedStrArray) UnmarshalValue(value interface{}) (err error)

UnmarshalValue is an interface implement which sets any type of value for array.

func (*SortedStrArray) Walk

func (a *SortedStrArray) Walk(f func(value string) string) *SortedStrArray

Walk applies a user supplied function `f` to every item of array.

type StrArray

type StrArray struct {
	// contains filtered or unexported fields
}

StrArray is a golang string array with rich features. It contains a concurrent-safe/unsafe switch, which should be set when its initialization and cannot be changed then.

func NewStrArray

func NewStrArray(safe ...bool) *StrArray

NewStrArray creates and returns an empty array. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewStrArrayFrom

func NewStrArrayFrom(array []string, safe ...bool) *StrArray

NewStrArrayFrom creates and returns an array with given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewStrArrayFromCopy

func NewStrArrayFromCopy(array []string, safe ...bool) *StrArray

NewStrArrayFromCopy creates and returns an array from a copy of given slice `array`. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func NewStrArraySize

func NewStrArraySize(size int, cap int, safe ...bool) *StrArray

NewStrArraySize create and returns an array with given size and cap. The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.

func (*StrArray) Append

func (a *StrArray) Append(value ...string) *StrArray

See PushRight.

func (*StrArray) At

func (a *StrArray) At(index int) (value string)

At returns the value by the specified index. If the given `index` is out of range of the array, it returns an empty string.

func (*StrArray) Chunk

func (a *StrArray) Chunk(size int) [][]string

Chunk splits an array into multiple arrays, the size of each array is determined by `size`. The last chunk may contain less than size elements.

func (*StrArray) Clear

func (a *StrArray) Clear() *StrArray

Clear deletes all items of current array.

func (*StrArray) Clone

func (a *StrArray) Clone() (newArray *StrArray)

Clone returns a new array, which is a copy of current array.

func (*StrArray) Contains

func (a *StrArray) Contains(value string) bool

Contains checks whether a value exists in the array.

func (*StrArray) ContainsI

func (a *StrArray) ContainsI(value string) bool

ContainsI checks whether a value exists in the array with case-insensitively. Note that it internally iterates the whole array to do the comparison with case-insensitively.

func (*StrArray) CountValues

func (a *StrArray) CountValues() map[string]int

CountValues counts the number of occurrences of all values in the array.

func (*StrArray) Fill

func (a *StrArray) Fill(startIndex int, num int, value string) error

Fill fills an array with num entries of the value `value`, keys starting at the `startIndex` parameter.

func (*StrArray) FilterEmpty

func (a *StrArray) FilterEmpty() *StrArray

FilterEmpty removes all empty string value of the array.

func (*StrArray) Get

func (a *StrArray) Get(index int) (value string, found bool)

Get returns the value by the specified index. If the given `index` is out of range of the array, the `found` is false.

func (*StrArray) InsertAfter

func (a *StrArray) InsertAfter(index int, value string) error

InsertAfter inserts the `value` to the back of `index`.

func (*StrArray) InsertBefore

func (a *StrArray) InsertBefore(index int, value string) error

InsertBefore inserts the `value` to the front of `index`.

func (*StrArray) Interfaces

func (a *StrArray) Interfaces() []interface{}

Interfaces returns current array as []interface{}.

func (*StrArray) IsEmpty

func (a *StrArray) IsEmpty() bool

IsEmpty checks whether the array is empty.

func (*StrArray) Iterator

func (a *StrArray) Iterator(f func(k int, v string) bool)

Iterator is alias of IteratorAsc.

func (*StrArray) IteratorAsc

func (a *StrArray) IteratorAsc(f func(k int, v string) bool)

IteratorAsc iterates the array readonly in ascending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*StrArray) IteratorDesc

func (a *StrArray) IteratorDesc(f func(k int, v string) bool)

IteratorDesc iterates the array readonly in descending order with given callback function `f`. If `f` returns true, then it continues iterating; or false to stop.

func (*StrArray) Join

func (a *StrArray) Join(glue string) string

Join joins array elements with a string `glue`.

func (*StrArray) Len

func (a *StrArray) Len() int

Len returns the length of array.

func (*StrArray) LockFunc

func (a *StrArray) LockFunc(f func(array []string)) *StrArray

LockFunc locks writing by callback function `f`.

func (StrArray) MarshalJSON

func (a StrArray) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal. Note that do not use pointer as its receiver here.

func (*StrArray) Merge

func (a *StrArray) Merge(array interface{}) *StrArray

Merge merges `array` into current array. The parameter `array` can be any garray or slice type. The difference between Merge and Append is Append supports only specified slice type, but Merge supports more parameter types.

func (*StrArray) Pad

func (a *StrArray) Pad(size int, value string) *StrArray

Pad pads array to the specified length with `value`. If size is positive then the array is padded on the right, or negative on the left. If the absolute value of `size` is less than or equal to the length of the array then no padding takes place.

func (*StrArray) PopLeft

func (a *StrArray) PopLeft() (value string, found bool)

PopLeft pops and returns an item from the beginning of array. Note that if the array is empty, the `found` is false.

func (*StrArray) PopLefts

func (a *StrArray) PopLefts(size int) []string

PopLefts pops and returns `size` items from the beginning of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*StrArray) PopRand

func (a *StrArray) PopRand() (value string, found bool)

PopRand randomly pops and return an item out of array. Note that if the array is empty, the `found` is false.

func (*StrArray) PopRands

func (a *StrArray) PopRands(size int) []string

PopRands randomly pops and returns `size` items out of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*StrArray) PopRight

func (a *StrArray) PopRight() (value string, found bool)

PopRight pops and returns an item from the end of array. Note that if the array is empty, the `found` is false.

func (*StrArray) PopRights

func (a *StrArray) PopRights(size int) []string

PopRights pops and returns `size` items from the end of array. If the given `size` is greater than size of the array, it returns all elements of the array. Note that if given `size` <= 0 or the array is empty, it returns nil.

func (*StrArray) PushLeft

func (a *StrArray) PushLeft(value ...string) *StrArray

PushLeft pushes one or multiple items to the beginning of array.

func (*StrArray) PushRight

func (a *StrArray) PushRight(value ...string) *StrArray

PushRight pushes one or multiple items to the end of array. It equals to Append.

func (*StrArray) RLockFunc

func (a *StrArray) RLockFunc(f func(array []string)) *StrArray

RLockFunc locks reading by callback function `f`.

func (*StrArray) Rand

func (a *StrArray) Rand() (value string, found bool)

Rand randomly returns one item from array(no deleting).

func (*StrArray) Rands

func (a *StrArray) Rands(size int) []string

Rands randomly returns `size` items from array(no deleting).

func (*StrArray) Range

func (a *StrArray) Range(start int, end ...int) []string

Range picks and returns items by range, like array[start:end]. Notice, if in concurrent-safe usage, it returns a copy of slice; else a pointer to the underlying data.

If `end` is negative, then the offset will start from the end of array. If `end` is omitted, then the sequence will have everything from start up until the end of the array.

func (*StrArray) Remove

func (a *StrArray) Remove(index int) (value string, found bool)

Remove removes an item by index. If the given `index` is out of range of the array, the `found` is false.

func (*StrArray) RemoveValue

func (a *StrArray) RemoveValue(value string) bool

RemoveValue removes an item by value. It returns true if value is found in the array, or else false if not found.

func (*StrArray) Replace

func (a *StrArray) Replace(array []string) *StrArray

Replace replaces the array items by given `array` from the beginning of array.

func (*StrArray) Reverse

func (a *StrArray) Reverse() *StrArray

Reverse makes array with elements in reverse order.

func (*StrArray) Search

func (a *StrArray) Search(value string) int

Search searches array by `value`, returns the index of `value`, or returns -1 if not exists.

func (*StrArray) Set

func (a *StrArray) Set(index int, value string) error

Set sets value to specified index.

func (*StrArray) SetArray

func (a *StrArray) SetArray(array []string) *StrArray

SetArray sets the underlying slice array with the given `array`.

func (*StrArray) Shuffle

func (a *StrArray) Shuffle() *StrArray

Shuffle randomly shuffles the array.

func (*StrArray) Slice

func (a *StrArray) Slice() []string

Slice returns the underlying data of array. Note that, if it's in concurrent-safe usage, it returns a copy of underlying data, or else a pointer to the underlying data.

func (*StrArray) Sort

func (a *StrArray) Sort(reverse ...bool) *StrArray

Sort sorts the array in increasing order. The parameter `reverse` controls whether sort in increasing order(default) or decreasing order

func (*StrArray) SortFunc

func (a *StrArray) SortFunc(less func(v1, v2 string) bool) *StrArray

SortFunc sorts the array by custom function `less`.

func (*StrArray) String

func (a *StrArray) String() string

String returns current array as a string, which implements like json.Marshal does.

func (*StrArray) SubSlice

func (a *StrArray) SubSlice(offset int, length ...int) []string

SubSlice returns a slice of elements from the array as specified by the `offset` and `size` parameters. If in concurrent safe usage, it returns a copy of the slice; else a pointer.

If offset is non-negative, the sequence will start at that offset in the array. If offset is negative, the sequence will start that far from the end of the array.

If length is given and is positive, then the sequence will have up to that many elements in it. If the array is shorter than the length, then only the available array elements will be present. If length is given and is negative then the sequence will stop that many elements from the end of the array. If it is omitted, then the sequence will have everything from offset up until the end of the array.

Any possibility crossing the left border of array, it will fail.

func (*StrArray) Sum

func (a *StrArray) Sum() (sum int)

Sum returns the sum of values in an array.

func (*StrArray) Unique

func (a *StrArray) Unique() *StrArray

Unique uniques the array, clear repeated items. Example: [1,1,2,3,2] -> [1,2,3]

func (*StrArray) UnmarshalJSON

func (a *StrArray) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

func (*StrArray) UnmarshalValue

func (a *StrArray) UnmarshalValue(value interface{}) error

UnmarshalValue is an interface implement which sets any type of value for array.

func (*StrArray) Walk

func (a *StrArray) Walk(f func(value string) string) *StrArray

Walk applies a user supplied function `f` to every item of array.

Example
package main

import (
	"fmt"
	"github.com/gogf/gf/container/garray"
	"github.com/gogf/gf/frame/g"
)

func main() {
	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]

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL