Skip to content

GabrielHCataldo/go-helper

Folders and files

NameName
Last commit message
Last commit date

Latest commit

ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 
ย 

Repository files navigation

Go Helper

Project status Go Report Card Coverage Status Open Source Helpers GoDoc License

The go-helper project came to facilitate the use of validations, conversions, formatting in your go project with incredible flexibility and simple to use. Below we list some implemented features:

  • No more using !=, ==, >, among others, start using better described functions for this.
  • It is not necessary to use more len to check if it is empty or not, or greater than the same, just pass the values into intuitive functions.
  • Use robust validation functions out of the box.
  • Check all types of possible values in a simple and intuitive way.
  • Check single or multiple values if they are empty, null, equal, etc. without having to write lines and lines of code.
  • Easy rounding functions.
  • Format and Convert functions for you to use in the best way in your projects, without having to write repetitive lines of code.
  • Help us be the best and most complete golang utility library and help the community.

Installation

Use go get.

go get github.com/GabrielHCataldo/go-helper

Then import the go-helper package into your own code.

import "github.com/GabrielHCataldo/go-helper/helper"

Usability and documentation

IMPORTANT: Always check the documentation in the structures and functions fields. For more details on the examples, visit All examples link

Empty validate

To check if the values are empty, just do as in the example below, remembering that we also accept values of any type, see:

package main

import (
    "github.com/GabrielHCataldo/go-helper/helper"
    "log"
    "time"
)

type exampleStruct struct {
    Name      string
    BirthDate time.Time
    Map       map[string]any
}

func main() {
    // empty validations
    nStruct := exampleStruct{}
    nString := "  "
    isEmpty := helper.IsEmpty(nStruct, nString)
    log.Println("is empty?", isEmpty)
    nString = "test name"
    nStruct.Name = nString
    isNotEmpty := helper.IsNotEmpty(&nStruct, nString)
    log.Println("is not empty?", isNotEmpty)
	
    //return B value if A value is empty
    var a1 string
    var b1 string
    a1 = "a value is not empty"
    result := helper.IfEmptyReturns(a1, b1)
    log.Println("result not empty:", result)
	
    //return value not empty
    var a2 string
    var b2 string
    b2 = "b value is not empty"
    result = helper.ReturnNonEmptyValue(a2, b2)
    log.Println("result not empty:", result)
}

Outputs:

is empty? true
is not empty? true
result not empty: a value is not empty
result not empty: b value is not empty

See other types of values as examples by accessing the link.

Nil validate

Validating โ€œnilโ€ values is simple, but be careful as only the types Pointer, Map, Chan, Interface and Slice can have a null value in go, see an example below:

package main

import (
    "github.com/GabrielHCataldo/go-helper/helper"
    "log"
)

func main() {
    var anyPointer *any
    var anotherValue []any
    isNil := helper.IsNil(anyPointer, anotherValue)
    log.Println("is nil?", isNil)
    anyPointer = helper.ConvertToPointer(any("value string"))
    anotherValue = []any{12, "test"}
    isNotNil := helper.IsNotNil(anyPointer, anotherValue)
    log.Println("is not nil?", isNotNil)
    
    //return B value if A value is nil
    var a1 *string
    var b1 string
    b1 = "b value is not nil"
    result1 := helper.IfNilReturns(a1, b1)
    log.Println("result not nil:", result1)
    
    //return value not nil
    var a2 *string
    var b2 *string
    v2 := "a value is not nil"
    a2 = &v2
    result2 := helper.ReturnNonNilValue(a2, b2)
    log.Println("result not nil:", result2)
}

Outputs:

is nil? true
is not nil? true
result not nil: 0x14000223150
result not nil: 0x1400025d7f0

See other types of values as examples by accessing the link.

Equals validate

Checking equal is very simple, and works for any type and number of parameters entered, if it is Pointer, go-helper will obtain the real value for comparison, see one of the examples:

package main

import (
    "github.com/GabrielHCataldo/go-helper/helper"
    "log"
)

func main() {
    s1 := "value"
    s2 := "value"
    s3 := "value"
    s4 := "value"
    
    equals := helper.Equals(s1, s2, s3, s4)
    log.Println("equals?", equals)
    
    s1 = "value1"
    
    notEquals := helper.IsNotEqualTo(s1, s2, s3, s4)
    log.Println("not equals?", notEquals)

    s1 = "VaLuE"
    s2 = "VaLuE"
    s3 = "VaLuE"
    s4 = "VaLuE"

    equals = helper.EqualsIgnoreCase(s1, s2, s3, s4)
    log.Println("equals ignore case?", equals)

    s1 = "value1"

    notEquals = helper.IsNotEqualToIgnoreCase(s1, s2, s3, s4)
    log.Println("not equals ignore case?", notEquals)
}

Outputs:

equals? true
not equals? true
equals ignore case? true
not equals ignore case? true

See other types of values as examples by accessing the link.

Type validate

With go-helper it is very simple to know the type of your variable, see the example:

package main

import (
    "github.com/GabrielHCataldo/go-helper/helper"
    "log"
    "time"
)

func main() {
    var a any = map[string]any{}
    
    // for negative use IsNotMap
    isMap := helper.IsMapType(a)
    log.Println("is map?", isMap)
    
    a = "value1"

    // for negative use IsNotString
    isString := helper.IsStringType(a)
    log.Println("is string?", isString)
    
    a = 12
	
    // for negative use IsNotIntType
    isInt := helper.IsIntType(a)
    log.Println("is int?", isInt)
    
    a = true

    // for negative use IsNotBoolType
    isBool := helper.IsBoolType(a)
    log.Println("is bool?", isBool)
    
    a = time.Now()

    // for negative use IsNotTimeType
    isTime := helper.IsTimeType(a)
    log.Println("is time?", isTime)
}

Outputs:

is map? true
is string? true
is int? true
is bool? true
is time? true

See other types of values as examples by accessing the link.

Convert

With go-helper you don't need to worry about laborious and repetitive conversions to implement, see a powerful example of conversion from any type A to any type B:

package main

import (
    "github.com/GabrielHCataldo/go-helper/helper"
    "log"
    "time"
)

type exampleStruct struct {
    Name      string
    BirthDate time.Time
    Map       map[string]any
}

func main() {
    var destStruct exampleStruct
    // convert to struct to string base64, it's funny and sample
    s64 := helper.SimpleConvertToBase64(initExampleStruct())
    // convert string base64 to struct
    err := helper.ConvertToDest(s64, &destStruct)
    if helper.IsNotNil(err) {
        log.Println("error convert base64 to struct:", err)
        return
    }
    log.Println("converted base64 to struct:", destStruct)
    var destMap map[string]any
    // convert struct to simple map
    err = helper.ConvertToDest(destStruct, &destMap)
    if helper.IsNotNil(err) {
        log.Println("error convert struct to map:", err)
        return
    }
    log.Println("converted struct to map:", destMap)
}

func initExampleStruct() exampleStruct {
    return exampleStruct{
        Name:      "Foo Bar",
        BirthDate: time.Now(),
        Map:       map[string]any{"example": 1, "test": 2},
    }
}

Output:

[INFO 2024/01/17 09:09:00] main.go:26: converted base64 to struct: {"Name":"Foo Bar","BirthDate":"2024-01-17T09:08:49-03:00","Map":{"example":1,"test":2}}
[INFO 2024/01/17 09:09:00] main.go:34: converted struct to map: {"Name":"Foo Bar","BirthDate":"2024-01-17T09:08:49.038335-03:00","Map":{"example":1,"test":2}}

See other types of values as examples by accessing the link.

For more examples

Thanks

How to contribute

Make a pull request, or if you find a bug, open it an Issues.

License

Distributed under MIT license, see the license file within the code for more details.