Underscore.go

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

Underscore.go

==========================================

like underscore.js, but for Go

Installation

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

Update

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

Lack

* to be continued...

Documentation

API

All, AllBy
Any, AnyBy
AsParallel
Chain
Clone
Each
Find, FindBy
FindIndex, FindIndexBy
First
Group, GroupBy
IsArray
IsMatch
Keys
Last
Map, MapBy
Md5
Object
Property, PropertyRV
Range
Reduce
Reject, RejectBy
Reverse, ReverseBy
Size
Sort, SortBy
Take
Uniq, UniqBy
UUID
Value
Values
Where, WhereBy

All(source, predicate)

Arguments

source - array or map
predicate - func(element, index or key) bool

Return

bool - all the values that pass a truth test predicate

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{1, "two"},
	TestModel{1, "three"},
}
ok := All(arr, func(r TestModel, _ int) bool {
	return r.Id == 1
})
// ok == true

AllBy(source, properties)

Arguments

source - array or map
properties - map[string]interface{}

Return

bool

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{1, "two"},
	TestModel{1, "three"},
}
ok := AllBy(arr, nil)
// ok == true

ok = AllBy(arr, map[string]interface{}{
	"name": "a",
})
// ok == false

ok = AllBy(arr, map[string]interface{}{
	"id": 1,
})
// ok == true

Any(source, predicate)

Arguments

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

Return

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

Examples

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

AnyBy(source, properties)

Arguments

source - array or map
properties - map[string]interface{}

Return

bool

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{2, "two"},
	TestModel{3, "three"},
}
ok := AnyBy(arr, map[string]interface{}{
	"Id": 0,
})
// ok == false

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

Chain(source).AsParallel()...

Support

Each
Object

Examples

arr := []int{ 1, 2, 3 }
Chain(arr).AsParallel().Each(func (n, i int) {
	// code
})

Chain(source)

Arguments

source - array or map

Return

IQuery - a wrapped object, wrapped objects until value is called

Examples

res := make(map[string][]int)
Chain([]int{1, 2, 1, 4, 1, 3}).Uniq(nil).Group(func(n, _ int) string {
	if n%2 == 0 {
		return "even"
	}

	return "old"
}).Value(&res)
// len(res) == 2 && ok == true

Clone()

Return

interface{}

Examples

arr := []int{1, 2, 3}
duplicate := Clone(arr)
ok := All(duplicate, func(n, i int) bool {
	return arr[i] == n
})
// ok == true

Each(source, iterator)

Arguments

source - array or map
iterator - func(element or value, index or key)

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{1, "two"},
	TestModel{1, "three"},
}
Each(arr, func (r TestModel, i int) {
	// coding
})

Find(source, predicate, match)

Arguments

source - array or map
predicate - func(element or value, index or key) bool
match - result

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{2, "two"},
	TestModel{3, "three"},
}
var item TestModel
Find(arr, func(r TestModel, _ int) bool {
	return r.Id == 1
}, &item)
// item == arr[0]

FindBy(source, properties, match)

Arguments

source - array or map
properties - map[string]interface{}
match - result

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{2, "two"},
	TestModel{3, "three"},
}
var item TestModel
FindBy(arr, map[string]interface{}{
	"id": 2,
}, &item)
// item == arr[1]

FindIndex(source, predicate)

Arguments

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

Return

int - index

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{1, "two"},
	TestModel{1, "three"},
}
i := FindIndex(arr, func(r TestModel, _ int) bool {
	return r.Name == arr[1].Name
})
// i == 1

FindIndexBy(source, properties)

Arguments

source - array or map
properties - map[string]interface{}

Return

int - index

Examples

arr := []TestModel{
	TestModel{1, "one"},
	TestModel{2, "two"},
	TestModel{3, "three"},
}
i := FindIndexBy(arr, map[string]interface{}{
	"id": 1,
})
// i == 0

First(source, first)

Arguments

source - array or map
first - first element of source

Examples

arr := []int{ 1, 2, 3 }
var n int
First(arr, &n)
if n != 1 {
	//wrong
}

Group(source, keySelector, result)

Arguments

source - array or map
keySelector - func(element or value, index or key) anyType
result - map[anyType][](element or value)

Examples

dic := make(map[string][]int)
Group([]int{1, 2, 3, 4, 5}, func(n, _ int) string {
	if n%2 == 0 {
		return "even"
	}
	return "odd"
}, &dic)
if len(dic["even"]) != 2 {
	t.Error("wrong")
}

GroupBy(source, property, result)

Arguments

source - array or map
property - property name
result - map[property type][](element or value)

Examples

arr := []TestModel{
	TestModel{ID: 1, Name: "a"},
	TestModel{ID: 2, Name: "a"},
	TestModel{ID: 3, Name: "b"},
	TestModel{ID: 4, Name: "b"},
}
dic := make(map[string][]TestModel)
GroupBy(arr, "name", &dic)
if len(dic) != 2 {
	t.Error("wrong")
}

Index(source, indexSelector, result)

Arguments

source - array or map
indexSelector - func(element or value, index or key) anyType
result - map[anyType](element or value)

Examples

res := make(map[string]string)
Index([]string{"a", "b"}, func(r string, _ int) string {
	return r
}, &res)
if res["a"] != "a" {
	// error
}

IndexBy(source, property, result)

Arguments

source - array or map
property - string
result - map[propertyType](element or value)

Examples

arr := []TestModel{
	TestModel{ID: 1, Name: "a"},
	TestModel{ID: 2, Name: "a"},
	TestModel{ID: 3, Name: "b"},
	TestModel{ID: 4, Name: "b"},
}
res := make(map[string]TestModel)
IndexBy(arr, "Name", &res)
if len(res) != 2 {
	// error
}

IsArray(element)

Arguments

element - object

Return

bool

Examples

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

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

IsMatch(element, properties)

Arguments

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

Return

bool

Examples

m := TestModel{ 1, "one" }
ok := IsMatch(nil, nil)
if ok {
	// wrong
}

ok = IsMatch(m, nil)
if ok {
	// wrong
}

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

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

Keys(keys)

Arguments

source - map
keys - []keyType

Examples

dict := map[int]string{
	1: "a",
	2: "b",
	3: "c",
	4: "d",
}
res := make([]int, 0)
Keys(dict, &res)
if len(res) != len(dict) {
	// wrong
}

Last(source, last)

Arguments

source - array or map
last - last element of source

Examples

arr := []int{1, 2, 3}
var n int
Last(arr, &n)
if n != 3 {
	// wrong
}

dict := map[string]string{
	"a": "aa",
	"b": "bb",
}
var str string
Last(dict, &str)
if !(str == "aa" || str == "bb") {
	// wrong
}

Map(source, selector, result)

Arguments

source - array or map
selector - func(element, index or key) anyType
result - an array of anyType

Examples

arr := []string{"11", "12", "13"}
res := make([]int, 0)
Map(arr, func(s string, _ int) int {
	n, _ := strconv.Atoi(s)
	return n
}, &res)
if len(res) != len(arr) {
	// wrong
}

MapBy(source, property, result)

Arguments

source - array
property - string
result - an array of property type

Examples

arr := []TestModel{
	TestModel{ID: 1, Name: "one"},
	TestModel{ID: 2, Name: "two"},
	TestModel{ID: 3, Name: "three"},
}
res := make([]string, 0)
MapBy(arr, "name", &res)
if len(res) != len(arr) {
	// wrong
}

for i := 0; i < 3; i++ {
	if res[i] != arr[i].Name {
		// wrong
	}
}

Md5(plaintext)

Arguments

plaintext - string

Return

string - md5 string

Examples

if Md5("123456") != "e10adc3949ba59abbe56e057f20f883e" {
	// wrong
}

Object(arr, result)

Arguments

arr - array
result - map

Examples

arr := []interface{}{
	[]interface{}{"a", 1},
	[]interface{}{"b", 2},
}
dic := make(map[string]int)
Object(arr, &dic)
if len(dic) != 2 {
	// wrong
}

if v, ok := dic["a"]; !(ok && v == 1) {
	// wrong
}

if v, ok := dic["b"]; !(ok && v == 2) {
	// wrong
}

Property(name)

Arguments

name - property name

Return

func(interface{}) (interface{}, error)

Examples

item := TestModel{ 1, "one" }

getAge := Property("age")
_, err := getAge(item)
if err == nil {
	// wrong
}

getName := Property("name")
name, err := getName(item)
if !(err == nil && name.(string) == item.Name) {
	// wrong
}

Property(name)

Arguments

name - property name

Return

func(interface{}) (reflect.Value, error)

Examples

item := TestModel{ 1, "one" }

getAgeRV := PropertyRV("age")
_, err := getAgeRV(item)
if err == nil {
	// wrong
}

getNameRV := PropertyRV("name")
nameRV, err := getNameRV(item)
if !(err == nil && nameRV.String() == item.Name) {
	// wrong
}

Range(start, stop, step)

Arguments

start - int
stop - int
step - int

Return

IQuery - a wrapped object, wrapped objects until value is called

Examples

arr := make([]int, 0)
Range(0, 0, 1).Value(&arr)
if len(arr) != 0 {
	// wrong
}

Range(0, 10, 0).Value(&arr)
if len(arr) != 0 {
	// wrong
}

Range(10, 0, 1).Value(&arr)
if len(arr) != 0 {
	// wrong
}

Range(0, 2, 1).Value(&arr)
if !(len(arr) == 2 && arr[0] == 0 && arr[1] == 1) {
	// wrong
}

Range(0, 3, 2).Value(&arr)
if !(len(arr) == 2 && arr[0] == 0 && arr[1] == 2) {
	// wrong
}

Reduce(source, iterator)

Arguments

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

Return

interface{} - memo

Examples

v := Reduce([]int{ 1, 2 }, func (memo []int, n, _ int) []int {
	memo = append(memo, n)
	memo = append(memo, n + 10)
	return memo
}, make([]int, 0))
res, ok := v.([]int)
if !(ok && len(res) == 4) {
	// wrong
}

if !(res[0] == 1 && res[1] == 11 && res[2] == 2 && res[3] == 12) {
	// wrong
}

Reject(source, predicate, result)

Arguments

source - array or map
predicate - func(element or value, index or key) bool
result - an array of all the values that without pass a truth test predicate

Examples

arr := []int{ 1, 2, 3, 4 }
v := Reject(arr, func (n, i int) bool {
	return n % 2 == 0
})
res, ok := v.([]int)
if !(ok && len(res) == 2) {
	// wrong
}

if !(res[0] == 1 && res[1] == 3) {
	// wrong
}

RejectBy(source, properties, result)

Arguments

source - array or map
properties - map[string]interface{}
result - an array of all the values that without pass a truth test properties

Examples

arr := []TestModel{
	TestModel{ 1, "one" },
	TestModel{ 2, "two" },
	TestModel{ 3, "three" },
}
v := RejectBy(arr, map[string]interface{}{
	"Id": 1,
})
res, ok := v.([]TestModel)
if !(ok && len(res) == 2) {
	// wrong
}

Reverse(source, selector, result)

Arguments

source - array or map
selector - func(element, key or index) anyType
result - an array of source that reversed

Examples

arr := []TestModel{
	TestModel{ID: 2, Name: "two"},
	TestModel{ID: 1, Name: "one"},
	TestModel{ID: 3, Name: "three"},
}
res := make([]TestModel, 0)
Reverse(arr, func(n TestModel, _ int) int {
	return n.ID
}, &res)
if len(res) != len(arr) {
	// error
}

if !(res[0].ID == 3 && res[1].ID == 2 && res[2].ID == 1) {
	// error
}

ReverseBy(source, selector, result)

Arguments

source - array or map
property - string
result - an array of source that reversed

Examples

arr := []TestModel{
	TestModel{ID: 2, Name: "two"},
	TestModel{ID: 1, Name: "one"},
	TestModel{ID: 3, Name: "three"},
}
res := make([]TestModel, 0)
ReverseBy(arr, "id", &res)
if len(res) != len(arr) {
	// error
}

if !(res[0].ID == 3 && res[1].ID == 2 && res[2].ID == 1) {
	// error
}

Size(source)

Arguments

source - array or map

Return

int

Examples

dict := map[string]int{
	"a": 1,
	"b": 2,
	"c": 3,
}
if Size(dict) != len(dict) {
	// wrong
}

Sort(source, selector, result)

Arguments

source - array or map
selector - func(element, key or index) anyType
result - an array of source that sorted

Examples

arr := []TestModel{
	TestModel{ID: 2, Name: "two"},
	TestModel{ID: 1, Name: "one"},
	TestModel{ID: 3, Name: "three"},
}
res := make([]TestModel, 0)
Sort(arr, func(n TestModel, _ int) int {
	return n.ID
}, &res)
if len(res) != len(arr) {
	// error
}

if !(res[0].ID == 1 && res[1].ID == 2 && res[2].ID == 3) {
	// error
}

SortBy(source, property, result)

Arguments

source - array or map
property - string
result - an array of source that sorted

Examples

arr := []TestModel{
	TestModel{ID: 2, Name: "two"},
	TestModel{ID: 1, Name: "one"},
	TestModel{ID: 3, Name: "three"},
}
res := make([]TestModel, 0)
SortBy(arr, "id", &res)
if len(res) != len(arr) {
	// error
}

if !(res[0].ID < res[1].ID && res[1].ID < res[2].ID) {
	// error
}

Take(source, count, result)

Arguments

source - array or map
count - int
result - array

Examples

arr := []int{1, 2, 3}
res := make([]int, 0)
Take(arr, 1, &res)
if len(res) != 1 || res[0] != 1 {
	// wrong
}

Uniq(source, selector)

Arguments

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

Return

interface{} - only the first occurence of each value is kept

Examples

v := Uniq([]int{ 1, 2, 1, 4, 1, 3 }, func (n, _ int) int {
	return n % 2
})
res, ok := v.([]int)
if !(ok && len(res) == 2) {
	// wrong
}

UniqBy(source, property)

Arguments

source - array
property - string

Return

interface{}

Examples

arr := []TestModel{
	TestModel{ 1, "one" },
	TestModel{ 2, "one" },
	TestModel{ 3, "one" },
}
v := UniqBy(arr, "Name")
res, ok := v.([]TestModel)
if !(ok && len(res) == 1) {
	// wrong
}

UUID()

Return

string - uuid string

Examples

uuid := UUID()
//1a40272540e57d1c80e7b06042219d0c

Value()

Return

interface{} - Chain final result

Examples

res := make(map[string][]int)
Chain([]int{1, 2, 1, 4, 1, 3}).Uniq(nil).Group(func(n, _ int) string {
	if n%2 == 0 {
		return "even"
	}

	return "old"
}).Value(&res)
if len(res) == 2 {
	// wrong
}

Values(source, values)

Arguments

source - map
values - an array of source's values

Examples

dict := map[int]string{
	1: "a",
	2: "b",
	3: "c",
	4: "d",
}
res := make([]string, 0)
Values(dict, &res)
if len(res) != len(dict) {
	// wrong
}

Where(source, predicate, result)

Arguments

source - array or map
predicate - func(element or value, index or key) bool
result - an array of all the values that pass a truth test predicate

Examples

arr := []TestModel{
	TestModel{ID: 1, Name: "one"},
	TestModel{ID: 2, Name: "two"},
	TestModel{ID: 3, Name: "three"},
	TestModel{ID: 4, Name: "three"},
}
res := make([]TestModel, 0)
Where(arr, func(r TestModel, i int) bool {
	return r.ID%2 == 0
}, &res)
if !(len(res) == 2 && res[0].ID == 2 && res[1].ID == 4) {
	// wrong
}

WhereBy(source, properties, result)

Arguments

source - array or map
properties - map[string]interface{}
result - an array of all the values that pass a truth test properties

Examples

arr := []TestModel{
	TestModel{ID: 1, Name: "one"},
	TestModel{ID: 2, Name: "one"},
	TestModel{ID: 3, Name: "three"},
	TestModel{ID: 4, Name: "three"},
}
res := make([]TestModel, 0)
WhereBy(arr, map[string]interface{}{
	"Name": "one",
}, &res)
if !(len(res) == 2 && res[0] == arr[0] && res[1] == arr[1]) {
	// wrong
}

Name		Name	Last commit message	Last commit date
Latest commit History 68 Commits
LICENSE		LICENSE
README.md		README.md
all.go		all.go
all_test.go		all_test.go
any.go		any.go
any_test.go		any_test.go
as-parallel.go		as-parallel.go
chain.go		chain.go
clone.go		clone.go
clone_test.go		clone_test.go
each.go		each.go
each_test.go		each_test.go
facade.go		facade.go
find-index.go		find-index.go
find-index_test.go		find-index_test.go
find-last-index.go		find-last-index.go
find-last-index_test.go		find-last-index_test.go
find.go		find.go
find_test.go		find_test.go
first.go		first.go
first_test.go		first_test.go
fiter.go		fiter.go
group.go		group.go
group_test.go		group_test.go
i-query.go		i-query.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.go		map.go
map_test.go		map_test.go
object.go		object.go
object_test.go		object_test.go
property.go		property.go
property_test.go		property_test.go
query.go		query.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
size.go		size.go
size_test.go		size_test.go
sort-query.go		sort-query.go
sort.go		sort.go
sort_test.go		sort_test.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
util_test.go		util_test.go
value.go		value.go
value_test.go		value_test.go
values.go		values.go
values_test.go		values_test.go
where.go		where.go
where_test.go		where_test.go

License

crazywako/golang-underscore

Folders and files

Latest commit

History

Repository files navigation

Underscore.go

Installation

Update

Lack

Documentation

API

All(source, predicate)

AllBy(source, properties)

Any(source, predicate)

AnyBy(source, properties)

Chain(source).AsParallel()...

Chain(source)

Clone()

Each(source, iterator)

Find(source, predicate, match)

FindBy(source, properties, match)

FindIndex(source, predicate)

FindIndexBy(source, properties)

First(source, first)

Group(source, keySelector, result)

GroupBy(source, property, result)

Index(source, indexSelector, result)

IndexBy(source, property, result)

IsArray(element)

IsMatch(element, properties)

Keys(keys)

Last(source, last)

Map(source, selector, result)

MapBy(source, property, result)

Md5(plaintext)

Object(arr, result)

Property(name)

Property(name)

Range(start, stop, step)

Reduce(source, iterator)

Reject(source, predicate, result)

RejectBy(source, properties, result)

Reverse(source, selector, result)

ReverseBy(source, selector, result)

Size(source)

Sort(source, selector, result)

SortBy(source, property, result)

Take(source, count, result)

Uniq(source, selector)

UniqBy(source, property)

UUID()

Value()

Values(source, values)

Where(source, predicate, result)

WhereBy(source, properties, result)

About

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages