arrays

README

go-arrays

介绍

创建一个基于go更好的array操作，就像js的array一样

软件架构

用golang实现一个他javascript的array一样方便的函数式链式调用

安装教程

1. go get gitee.com/yaojianpin/go-arrays

使用说明

arr := []int{8, 5, 6}

// Filter
arrays.From(arr).Filter(func(item int) bool { return item > 5 })

// Count
arrays.From(arr).Count(func(item int) bool { return item > 5 })

// Contains
exists := arrays.From(arr).Contains(5)

// Map
m := arrays.From(arr).Map(func(v int) any { return v * 2 }).Map(func(v int) any { return Tuple{x: v} })

// ForEach 
arrays.From(arr).ForEach(func(v int) { 
  fmt.Println(v)
})

// to slice
m := arrays.From(arr).Slice()

// sort
sortedResult := arrays.From(arr).SortBy(func(i, j int) bool { return i < j })


// Reduce
arr := []int{3, 4, 2}
value := From(arr).Reduce(0, func(acc int, cur int) int {
  return acc + cur
})

// output 9

// Flat
arr := [][]int{{3}, {4}, {3, 5}}

newArr := From(arr).Flat(1).Slice()
for i, v := range newArr {
  fmt.Println(i, v)
}

// output  [ 3, 4, 3, 5 ]


// FlatMap
arr := []string{"it's Sunny in", "California"}

newArr := From(arr).FlatMap(func(item string) any {
  return strings.Split(item, " ")
}, 1).Slice()
// output ["it's", "Sunny", "in", "California" ]

// Take(start, count)
arr := []int{3, 4, 2, 5, 2, 3}
newArr := From(arr).Take(1, 2)

// output [3, 4]

// Find(index)
	arr := []int{3, 4, 2, 5, 2, 3}
	value, err := From(arr).Find(0)
  // output 3,nil

// Distinct
  arr := []int{3, 4, 2, 5, 2, 3}
	From(arr).Distinct(func(item int) string {
		return fmt.Sprint(item)
	}).Slice()
  // output [3,4,2,5]


// Parallel
// parallel to run the fn
	arr := []int{3, 4, 2}
	From(arr).Parallel(func(item int) {
		fmt.Println("Parallel run", item)
	})
	time.Sleep(1 * time.Second)

参与贡献

1. Fork 本仓库
2. 新建 Feat_xxx 分支
3. 提交代码
4. 新建 Pull Request

Documentation

Index

• func Flatten(target *[]any, source any, depth int)
• type Array
  • func From[T any](arr []T) *Array[T]
  • func (self *Array[T]) Any(fn func(item T) bool) bool
  • func (self *Array[T]) Contains(item T) bool
  • func (self *Array[T]) Count() int
  • func (self *Array[T]) Distinct(fn func(item T) string) *Array[T]
  • func (self *Array[T]) Filter(fn func(item T) bool) *Array[T]
  • func (self *Array[T]) Find(index int) (T, error)
  • func (self *Array[T]) Flat(depth int) *Array[any]
  • func (self *Array[T]) FlatMap(fn func(item T) any, depth int) *Array[any]
  • func (self *Array[T]) ForEach(fn func(item T, index int)) *Array[T]
  • func (self *Array[T]) Map(fn func(T) any) *Array[any]
  • func (self *Array[T]) Parallel(fn func(item T)) *Array[T]
  • func (self *Array[T]) Reduce(initial T, fn func(acc T, cur T) T) T
  • func (self *Array[T]) Slice() []T
  • func (self *Array[T]) SortBy(less func(i, j T) bool) *Array[T]
  • func (self *Array[T]) Take(start int, count int) *Array[T]

Functions

func Flatten

func Flatten(target *[]any, source any, depth int)

Types

type Array

type Array[T any] struct {
	// contains filtered or unexported fields
}

Array struct

array wrap struct which can help call a serial of useful functions

 arr := []int{3, 4, 2}
	ret := From(arr).Map(...).Filter(...).ForEach(...)

func From

func From[T any](arr []T) *Array[T]

change array to Array struct

 arr := []int{3, 4, 2}
	ret := From(arr)

func (*Array[T]) Any

func (self *Array[T]) Any(fn func(item T) bool) bool

check if it there is any item satisfing fn

func (*Array[T]) Contains

func (self *Array[T]) Contains(item T) bool

check if the array contains item given from the parameter

func (*Array[T]) Count

func (self *Array[T]) Count() int

count for the array

func (*Array[T]) Distinct

func (self *Array[T]) Distinct(fn func(item T) string) *Array[T]

distinct the array by the key fn

arr := []int{3, 4, 2, 5, 2, 3}
count := From(arr).Distinct(func(item int) string {
	return fmt.Sprint(item)
})

func (*Array[T]) Filter

func (self *Array[T]) Filter(fn func(item T) bool) *Array[T]

filter the array by fn condition

arr := []int{3, 4, 2}
ret := From(arr).Filter(func(i int) bool { return i > 3 })
fmt.Println(ret)

func (*Array[T]) Find

func (self *Array[T]) Find(index int) (T, error)

get the value by index, otherwise return error

func (*Array[T]) Flat

func (self *Array[T]) Flat(depth int) *Array[any]

flat a array

arr := [][]int{{3}, {4}, {3, 5}}
newArr := From(arr).Flat(1).Slice()
for i, v := range newArr {
	fmt.Println(i, v)
}

func (*Array[T]) FlatMap

func (self *Array[T]) FlatMap(fn func(item T) any, depth int) *Array[any]

map + flat for array

arr := []string{"it's Sunny in", "", "California"}
newArr := From(arr).FlatMap(func(item string) any {
	return strings.Split(item, " ")
}, 1).Slice()
for i, v := range newArr {
	fmt.Println(i, v)
}

func (*Array[T]) ForEach

func (self *Array[T]) ForEach(fn func(item T, index int)) *Array[T]

for each the array

arr := []int{3, 4, 2}
From(arr).ForEach(func(item, _ int) {
	fmt.Println(item)
})

func (*Array[T]) Map

func (self *Array[T]) Map(fn func(T) any) *Array[any]

map the array and return the expected struct

arr := []int{3, 4, 2}
ret := From(arr).Map(func(i int) any { return tuple{i, i} })

ret = From(arr).Map(func(i int) any { return i * 2 })

func (*Array[T]) Parallel

func (self *Array[T]) Parallel(fn func(item T)) *Array[T]

Parallel to run the item function

arr := []int{3, 4, 2}
From(arr).Parallel(func(item int) {
	fmt.Println("Parallel run", item)
})

func (*Array[T]) Reduce

func (self *Array[T]) Reduce(initial T, fn func(acc T, cur T) T) T

 Reduce function

	arr := []int{3, 4, 2}
	value := From(arr).Reduce(0, func(acc int, cur int) int {
		return acc + cur
	})

func (*Array[T]) Slice

func (self *Array[T]) Slice() []T

from Array struct to slice of T

arr := []string{"banana", "apple", "pear"}
ret := From(arr).Slice()
fmt.Println(reflect.TypeOf(ret))

func (*Array[T]) SortBy

func (self *Array[T]) SortBy(less func(i, j T) bool) *Array[T]

sort Array

func (*Array[T]) Take

func (self *Array[T]) Take(start int, count int) *Array[T]

take the data from start in count