Underscore.go

                  /\ \                                                       
 __  __    ___    \_\ \     __   _ __   ____    ___    ___   _ __    __	         __     ___
/\ \/\ \ /' _ `\  /'_  \  /'__`\/\  __\/ ,__\  / ___\ / __`\/\  __\/'__`\      /'_ `\  / __`\
\ \ \_\ \/\ \/\ \/\ \ \ \/\  __/\ \ \//\__, `\/\ \__//\ \ \ \ \ \//\  __/  __ /\ \L\ \/\ \L\ \
 \ \____/\ \_\ \_\ \___,_\ \____\\ \_\\/\____/\ \____\ \____/\ \_\\ \____\/\_\\ \____ \ \____/
  \/___/  \/_/\/_/\/__,_ /\/____/ \/_/ \/___/  \/____/\/___/  \/_/ \/____/\/_/ \/___L\ \/___/
                                                                                 /\____/
                                                                                 \_/__/

Underscore.go

like underscore.js and C# LINQ, but for Go

Installation

$ go get github.com/ahl5esoft/golang-underscore

Update

$ go get -u github.com/ahl5esoft/golang-underscore

Lack

Concat/ThenBy

Documentation

API

Aggregate
All, AllBy
Any, AnyBy
Chain
Count
Distinct, DistinctBy
Each
Field, FieldValue
Filter, FilterBy
Find, FindBy
FindIndex, FindIndexBy
First
Group, GroupBy
Index, IndexBy
IsArray
IsMatch
Keys
Last
Map, MapBy
MapMany, MapManyBy
Object
Order, OrderBy
Range
Reduce
Reject, RejectBy
Reverse, ReverseBy
Select, SelectBy
SelectMany, SelectManyBy
Size
Skip
Sort, SortBy
Take
Uniq, UniqBy
Value
Values
Where, WhereBy

Aggregate(memo, fn) IEnumerable

Arguments

iterator - func(element or value, key or index, memo) memo
memo - anyType

Examples

var res []int
Chain([]int{1, 2}).Aggregate(
	func(memo []int, n, _ int) []int {
		memo = append(memo, n)
		memo = append(memo, n+10)
		return memo
	},
	make([]int, 0),
).Value(&res)
// res = [1 11 2 12]

Same

Reduce

All(predicate) bool

Arguments

predicate - func(element, index or key) bool

Return

bool - all the values that pass a truth test predicate

Examples

ok := Chain([]testModel{
	{ID: 1, Name: "one"},
	{ID: 1, Name: "two"},
	{ID: 1, Name: "three"},
}).All(func(r testModel, _ int) bool {
	return r.ID == 1
})
// ok == true

AllBy(fields) bool

Arguments

fields - map[string]interface{}

Return

bool - all the values that pass a truth test predicate

Examples

ok := Chain([]testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "one"},
	{ID: 3, Name: "one"},
}).AllBy(map[string]interface{}{
	"name": "one",
})
// ok == true

Any(predicate) bool

Arguments

predicate - func(element or value, index or key) bool

Return

bool - any of the values that pass a truth test predicate

Examples

ok := Chain([]testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
	{ID: 3, Name: "three"},
}).Any(func(r testModel, _ int) bool {
	return r.ID == 0
})
// ok == false

AnyBy(fields) bool

Arguments

fields - map[string]interface{}

Return

bool

Examples

ok := Chain([]testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
	{ID: 3, Name: "three"},
}).AnyBy(map[string]interface{}{
	"name": "two",
})
// ok == true

Chain(source) IEnumerable

Arguments

source - array or map

Examples

var dst int
Range(1, benchmarkSize, 1).Select(func(r, _ int) int {
	return -r
}).Where(func(r, _ int) bool {
	return r < -20
}).First().Value(&dst)
// dst = -21

Count() int

Examples

src := []string{"a", "b", "c"}
dst := Chain(src).Count()
// dst = 3

Same

Size

Distinct(selector) IEnumerable

Arguments

selector - nil or func(element or value, index or key) anyType

Examples

src := []int{1, 2, 1, 4, 1, 3}
dst := make([]int, 0)
Chain(src).Distinct(func(n, _ int) (int, error) {
	return n % 2, nil
}).Value(&dst)
// dst = [1 2]

Same

Uniq

DistinctBy(fieldName) IEnumerable

Arguments

fieldName - string

Examples

src := []testModel{
	{ID: 1, Name: "a"},
	{ID: 2, Name: "a"},
	{ID: 3, Name: "a"},
}
dst := make([]testModel, 0)
Chain(src).DistinctBy("name").Value(&dst)
// dst = [{1 a}]

Same

UniqBy

Each(iterator)

Arguments

iterator - func(element or value, index or key)

Examples

arr := []testModel{
	{ID: 1, Name: "one"},
	{ID: 1, Name: "two"},
	{ID: 1, Name: "three"},
}
Chain(arr).Each(func(r testModel, i int) {
	if !(r.ID == arr[i].ID && r.Name == arr[i].Name) {
		// wrong
	}
})

Field(name)

Arguments

name - field name

Return

func(interface{}) interface{}

Examples

item := testModel{ 1, "one" }

getAge := Field("age")
_, err := getAge(item)
// err != nil

getName := Field("name")
name, err := getName(item)
// name = "one"

FieldValue(name)

Arguments

name - field name

Return

func(interface{}) reflect.Value

Examples

item := testModel{ 1, "one" }

getAgeValue := FieldValue("age")
res := getAgeValue(item)
// res != reflect.Value(nil)

getNameValue := FieldValue("name")
nameValue, err := getNameValue(item)
// nameValue = reflect.ValueOf("one")

Find(predicate) IEnumerable

Arguments

predicate - func(element or value, index or key) bool

Examples

var dst int
Chain([]int{1, 2, 3}).Find(func(r, _ int) bool {
	return r == 2
}).Value(&dst)
// dst == 2
// or
var dst int
Chain([][]int{
	[]int{1, 3, 5, 7},
	[]int{2, 4, 6, 8},
}).Find(func(r []int, _ int) bool {
	return r[0]%2 == 0
}).Find(func(r, _ int) bool {
	return r > 6
}).Value(&dst)
// dst == 8

FindBy(fields) IEnumerable

Arguments

fields - map[string]interface{}

Examples

src := []testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
	{ID: 3, Name: "three"},
}
var dst testModel
Chain(src).FindBy(map[string]interface{}{
	"id": 2,
}).Value(&dst)
// dst == src[1]

FindIndex(predicate) int

Arguments

predicate - func(element or value, index or key) bool

Return

int - index

Examples

src := []testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
	{ID: 3, Name: "three"},
}
index := Chain(src).FindIndex(func(r testModel, _ int) bool {
	return r.Name == src[1].Name
})
// i == 1

FindIndexBy(fields) int

Arguments

fields - map[string]interface{}

Return

int - index

Examples

src := []testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
	{ID: 3, Name: "three"},
}
index := Chain(src).FindIndexBy(map[string]interface{}{
	"id": 1,
})
// index == 0

First() IEnumerable

Arguments

predicate - func(element or value, index or key) bool

Examples

var dst int
Chain([]int{1, 2, 3}).First().Value(&dst)
// dst == 1
// or
var dst int
Chain([][]int{
	[]int{1, 3, 5, 7},
	[]int{2, 4, 6, 8},
}).First().First().Value(&dst)
// dst == 1

Group(keySelector) IEnumerable

Arguments

keySelector - func(element or value, index or key) anyType

Examples

dst := make(map[string][]int)
Chain([]int{1, 2, 3, 4, 5}).Group(func(n, _ int) string {
	if n%2 == 0 {
		return "even"
	}
	return "odd"
}).Value(&dst)
// dst = map[odd:[1 3 5] even:[2 4]]

GroupBy(fieldName) IEnumerable

Arguments

fieldName - field name

Examples

dst := make(map[string][]testModel)
Chain([]testModel{
	{ID: 1, Name: "a"},
	{ID: 2, Name: "a"},
	{ID: 3, Name: "b"},
	{ID: 4, Name: "b"},
}).GroupBy("Name").Value(&dst)
// dst = map[a:[{1 a} {2 a}] b:[{3 b} {4 b}]]

Index(indexSelector) IEnumerable

Arguments

indexSelector - func(element or value, index or key) anyType

Examples

src := []string{"a", "b"}
res := make(map[string]string)
Chain(src).Index(func(item string, _ int) string {
	return item
}).Value(&res)
// res = map[a:a b:b]

IndexBy(property) IEnumerable

Arguments

property - string

Examples

arr := []testModel{
	{ID: 1, Name: "a"},
	{ID: 2, Name: "a"},
	{ID: 3, Name: "b"},
	{ID: 4, Name: "b"},
}
res := make(map[string]testModel)
Chain(arr).IndexBy("id").Value(&res)
// res = map[1:{{0} 1 a} 2:{{0} 2 a} 3:{{0} 3 b} 4:{{0} 4 b}]

IsArray(element) bool

Arguments

element - object

Examples

if !IsArray([]int{}) {
	// wrong
}

if IsArray(map[string]int{}) {
	// wrong
}

IsMatch(element, fields) bool

Arguments

element - object
fields - map[string]interface{}

Examples

m := testModel{ 1, "one" }
ok := IsMatch(nil, nil)
// ok = false

ok = IsMatch(m, nil)
// ok = false

ok = IsMatch(m, map[string]interface{}{
	"id": m.Id,
	"name": "a",
})
// ok = false

ok = IsMatch(m, map[string]interface{}{
	"id": m.Id,
	"name": m.Name,
})
// ok = true

Keys() IEnumerable

Examples

src := []string{"aa", "bb", "cc"}
dst := make([]int, 0)
Chain(src).Keys().Value(&dst)
// dst = [0 1 2]

src := map[int]string{
	1: "a",
	2: "b",
	3: "c",
	4: "d",
}
dst := make([]int, 0)
Chain(src).Keys().Value(&dst)
// dst = [1 2 3 4]

Last() IEnumerable

Examples

arr := []int{1, 2, 3}
var res int
chain(arr).Last().Value(&res)
// res = 3

var res []int
src := [][]int{
	{1, 2, 3, 4},
	{5, 6},
}
Chain(src).Last().Map(func(r, _ int) int {
	return r + 5
}).Value(&res)
// res = [10, 11]

Object() IEnumerable

Examples

src := [][]interface{}{
	[]interface{}{"a", 1},
	[]interface{}{"b", 2},
}
dst := make(map[string]int)
Chain(src).Object().Value(&dst)
// dst = map[a:1 b:2]

Order(selector) IEnumerable

Arguments

selector - func(element, key or index) anyType

Examples

arr := []testModel{
	{ID: 2, Name: "two"},
	{ID: 1, Name: "one"},
	{ID: 3, Name: "three"},
}
var res []testModel
Chain(arr).Order(func(n testModel, _ int) int {
	return n.ID
}).Value(&res)
// res = [{{0} 1 one} {{0} 2 two} {{0} 3 three}]

Same

Sort

OrderBy(fieldName) IEnumerable

Arguments

fieldName - string

Examples

arr := []testModel{
	{ID: 2, Name: "two"},
	{ID: 1, Name: "one"},
	{ID: 3, Name: "three"},
}
var res []testModel
Chain(arr).OrderBy("id").Value(&res)
// res = [{{0} 1 one} {{0} 2 two} {{0} 3 three}]

Same

SortBy

Range(start, stop, step) IEnumerable

Arguments

start - int
stop - int
step - int

Examples

var res []int
Range2(0, 0, 1).Value(&res)
// res = []

var res []int
Range2(0, 10, 0).Value(&res)
// panic

var res []int
Range2(4, 0, -1).Value(&res)
// res = [4 3 2 1]

var res []int
Range2(0, 2, 1).Value(&res)
// res = [0 1]

var res []int
Range2(0, 3, 2).Value(&res)
// res = [0 2]

Reject(predicate) IEnumerable

Arguments

predicate - func(element or value, index or key) bool

Examples

arr := []int{1, 2, 3, 4}
var res []int
Chain(arr).Reject(func(n, i int) bool {
	return n%2 == 0
}).Value(&res)
// res = [1, 3]

Same

Except

RejectBy(fields) IEnumerable

Arguments

fields - map[string]interface{}

Examples

arr := []testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
	{ID: 3, Name: "three"},
}
var res []testModel
Chain(arr).RejectBy(map[string]interface{}{
	"Id": 1,
}).Value(&res)
// res = []testModel{ {ID: 2, Name: "two"}, {ID: 3, Name: "three"} }

Same

ExceptBy

Reverse(selector) IEnumerable

Arguments

selector - func(element, index or key) anyType

Examples

src := []testModel{
	{ID: 2, Name: "two"},
	{ID: 1, Name: "one"},
	{ID: 3, Name: "three"},
}
var res []testModel
Chain(src).Reverse(func(r testModel, _ int) int {
	return r.ID
}).Value(&res)
// res = []testModel{ {ID: 3, Name: "three"}, {ID: 2, Name: "two"}, {ID: 1, Name: "one"} }

ReverseBy(fieldName) IEnumerable

Arguments

fieldName - string

Examples

src := []testModel{
	{ID: 2, Name: "two"},
	{ID: 1, Name: "one"},
	{ID: 3, Name: "three"},
}
var res []testModel
Chain(src).ReverseBy("id").Value(&res)
// res = []testModel{ {ID: 3, Name: "three"}, {ID: 2, Name: "two"}, {ID: 1, Name: "one"} }

Select(selector) IEnumerable

Arguments

selector - func(element, index or key) anyType

Examples

src := []string{"11", "12", "13"}
dst := make([]int, 0)
Chain(src).Select(func(s string, _ int) int {
	n, _ := strconv.Atoi(s)
	return n
}).Value(&dst)
// dst = [11 12 13]

Same

Map

SelectBy(fieldName) IEnumerable

Arguments

fieldName - string

Examples

src := []testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
	{ID: 3, Name: "three"},
}
dst := make([]string, 0)
Chain(src).SelectBy("name").Value(&dst)
// dst = [one two three]

Same

MapBy

SelectMany(selector) IEnumerable

Arguments

selector - func(element, index or key) anyType with array or slice

Examples

src := [2]int{1, 2}
var dst []int
Chain(src).SelectMany(func(r, _ int) []int {
	return []int{r - 1, r + 1}
}).Value(&dst)
// dst = [0 2 1 3]

Same

MapMany

SelectManyBy(property) IEnumerable

Arguments

property - string

Examples

src := []testSelectManyModel{
	{Array: [2]int{1, 2}},
	{Array: [2]int{3, 4}},
}
var dst []int
Chain(src).SelectManyBy("Array").Value(&dst)
// res = [1 2 3 4]

Same

MapManyBy

Skip(count) IEnumerable

Arguments

count - int

Examples

src := []int{1, 2, 3}
dst := make([]int, 0)
Chain(src).Skip(2).Value(&dst)
// dst = [3]

Take(count) IEnumerable

Arguments

count - int

Examples

src := []int{1, 2, 3}
dst := make([]int, 0)
Chain(src).Take(1).Value(&dst)
// res = [1]

Value(res interface{})

Arguments

res - array or slice or reflect.Value(array) or reflect.Value(map)

Examples

resValue := reflect.New(
	reflect.SliceOf(
		reflect.TypeOf(1),
	),
)
Chain([]string{"a", "b"}).Map(func(_ string, i int) int {
	return i
}).Value(resValue)
// resValue = &[0 1]

src := []testModel{
	{ID: 1, Name: "a"},
	{ID: 2, Name: "a"},
	{ID: 3, Name: "b"},
	{ID: 4, Name: "b"},
}
resValue := reflect.New(
	reflect.MapOf(
		reflect.TypeOf(src[0].Name),
		reflect.TypeOf(src),
	),
)
Chain(src).GroupBy("name").Value(resValue)
// res = &map[even:[2 4] odd:[1 3 5]]

Values() IEnumerable

Examples

src := []string{"a", "b"}
dst := make([]string, 0)
Chain(src).Values().Value(&dst)
// dst = [a b]

src := map[int]string{
	1: "a",
	2: "b",
	3: "c",
	4: "d",
}
dst := make([]string, 0)
Chain(src).Values().Value(&dst)
// dst = [a b c d]

Where(predicate) IEnumerable

Arguments

predicate - func(element or value, index or key) bool

Examples

src := []testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "one"},
	{ID: 3, Name: "three"},
	{ID: 4, Name: "three"},
}
dst := make([]testModel, 0)
Chain(src).Where(func(r testModel, _ int) bool {
	return r.ID%2 == 0
}).Value(&dst)
// len(dst) == 2 && dst[0] == src[1] && dst[1] == src[3])

Same

Filter

WhereBy(fields) IEnumerable

Arguments

fields - map[string]interface{}

Examples

src := []testModel{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "one"},
	{ID: 3, Name: "three"},
	{ID: 4, Name: "three"},
}
dst := make([]testModel, 0)
Chain(src).WhereBy(map[string]interface{}{
	"Name": "one",
}).Value(&dst)
// len(dst) == 2 && dst[0] == src[0] && dst[1] == src[1]

Same

FilterBy

Release Notes

v2.1.0 (2020-11-17)
* IEnumerable增加Order、OrderBy、Sort、SortBy
* IEnumerable.Aggregate(memo interface{}, fn interface{}) -> IEnumerable.Aggregate(fn interface{}, memo interface{})

v2.0.0 (2019-06-27)
* 删除IQuery
* IEnumerable增加MapMany、MapManyBy、SelectMany、SelectManyBy

v1.6.0 (2019-06-21)
* IEnumerable增加Count、Size
* 删除FindLastIndex

v1.5.0 (2019-06-18)
* 增加Chain Benchmark
* IEnumerable增加Group、GroupBy
* 优化IEnumerable的Distinct、Enumerator、Index、Property、Select、Where

v1.4.0 (2019-06-15)
* Reduce、Take支持IEnumerable
* IEnumerable增加Aggregate、Skip
* IQuery删除Clone
* 优化IEnumerable的First、Index、Values

v1.3.0 (2019-06-09)
* FindIndex、FindIndexBy、Keys、Map、MapBy、Object、Uniq、UniqBy、Values支持IEnumerable
* IEnumerable增加Distinct、DistinctBy、Select、SelectBy

v1.2.0 (2019-06-04)
* Each、Filter、Where支持IEnumerable

v1.1.0 (2019-06-02)
* 增加IEnumerable、IEnumerator
* All、Any、Chain、Find、First、Range2、Value支持IEnumerable

v1.0.0 (2019-04-23)
* first edition

Name		Name	Last commit message	Last commit date
Latest commit History 112 Commits
.github/workflows		.github/workflows
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
aggregate.go		aggregate.go
aggregate_test.go		aggregate_test.go
all.go		all.go
all_test.go		all_test.go
any.go		any.go
any_test.go		any_test.go
chain.go		chain.go
chain_test.go		chain_test.go
count.go		count.go
count_test.go		count_test.go
distinct.go		distinct.go
distinct_test.go		distinct_test.go
each.go		each.go
each_test.go		each_test.go
enumerable.go		enumerable.go
enumerator.go		enumerator.go
except.go		except.go
except_test.go		except_test.go
facade.go		facade.go
field.go		field.go
field_test.go		field_test.go
filter.go		filter.go
filter_test.go		filter_test.go
find-index.go		find-index.go
find-index_test.go		find-index_test.go
find.go		find.go
find_test.go		find_test.go
first.go		first.go
first_test.go		first_test.go
go.mod		go.mod
go.sum		go.sum
group.go		group.go
group_test.go		group_test.go
i-enumerable.go		i-enumerable.go
i-enumerator.go		i-enumerator.go
index.go		index.go
index_test.go		index_test.go
is-array.go		is-array.go
is-array_test.go		is-array_test.go
is-match.go		is-match.go
is-match_test.go		is-match_test.go
keys.go		keys.go
keys_test.go		keys_test.go
last.go		last.go
last_test.go		last_test.go
map-many.go		map-many.go
map-many_test.go		map-many_test.go
map.go		map.go
map_test.go		map_test.go
null-enumerator.go		null-enumerator.go
object.go		object.go
object_test.go		object_test.go
order.go		order.go
order_test.go		order_test.go
range.go		range.go
range_test.go		range_test.go
reduce.go		reduce.go
reduce_test.go		reduce_test.go
reject.go		reject.go
reject_test.go		reject_test.go
reverse.go		reverse.go
reverse_test.go		reverse_test.go
select-many.go		select-many.go
select.go		select.go
select_many_test.go		select_many_test.go
select_test.go		select_test.go
size.go		size.go
size_test.go		size_test.go
skip.go		skip.go
skip_test.go		skip_test.go
sort.go		sort.go
sort_test.go		sort_test.go
sorter.go		sorter.go
take.go		take.go
take_test.go		take_test.go
uniq.go		uniq.go
uniq_test.go		uniq_test.go
util.go		util.go
value.go		value.go
value_test.go		value_test.go
values.go		values.go
values_test.go		values_test.go
variable.go		variable.go
where.go		where.go
where_test.go		where_test.go

License

ahl5esoft/golang-underscore

Folders and files

Latest commit

History

Repository files navigation

Underscore.go

Installation

Update

Lack

Documentation

API

Aggregate(memo, fn) IEnumerable

All(predicate) bool

AllBy(fields) bool

Any(predicate) bool

AnyBy(fields) bool

Chain(source) IEnumerable

Count() int

Distinct(selector) IEnumerable

DistinctBy(fieldName) IEnumerable

Each(iterator)

Field(name)

FieldValue(name)

Find(predicate) IEnumerable

FindBy(fields) IEnumerable

FindIndex(predicate) int

FindIndexBy(fields) int

First() IEnumerable

Group(keySelector) IEnumerable

GroupBy(fieldName) IEnumerable

Index(indexSelector) IEnumerable

IndexBy(property) IEnumerable

IsArray(element) bool

IsMatch(element, fields) bool

Keys() IEnumerable

Last() IEnumerable

Object() IEnumerable

Order(selector) IEnumerable

OrderBy(fieldName) IEnumerable

Range(start, stop, step) IEnumerable

Reject(predicate) IEnumerable

RejectBy(fields) IEnumerable

Reverse(selector) IEnumerable

ReverseBy(fieldName) IEnumerable

Select(selector) IEnumerable

SelectBy(fieldName) IEnumerable

SelectMany(selector) IEnumerable

SelectManyBy(property) IEnumerable

Skip(count) IEnumerable

Take(count) IEnumerable

Value(res interface{})

Values() IEnumerable

Where(predicate) IEnumerable

WhereBy(fields) IEnumerable

Release Notes

About

Resources

License

Stars

Watchers

Forks

Releases 8

Packages 0

Contributors 2

Languages

Packages