gonumbers

package module
v0.0.0-...-228d2d3 Latest Latest
Warning

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

 Go to latest Published: Apr 22, 2021 License: MIT Imports: 7 Imported by: 0

README

GoNumbers Build Status GoDoc

GoNumbers is an implementation of number helpers for Go-lang. This project is inspired by the ruby library ActiveSupport::NumberHelper.

##Intalling:

$ go get github.com/hgsigner/gonumbers

##Usage:

###- Number to Currency:

package main

import (
	"fmt"
	"github.com/hgsigner/gonumbers"
)

func main(){
	ntc := gonumbers.ToCurrency()
	ntc.Options(gonumbers.Precision(2))
	ntc_final := ntc.Perform(1234567890.506)
	ftm.Println(ntc_final) // "$1,234,567,890.51"
}

Options:

gonumbers.Unit(string) 

gonumbers.Precision(int) 

gonumbers.Separator(string) 

gonumbers.Delimiter(string)

###- Number to Delimiter:

package main

import (
	"fmt"
	"github.com/hgsigner/gonumbers"
)

func main(){
	ntd := gonumbers.ToDelimiter()
	ntd.Options(gonumbers.Separator("."), gonumbers.Delimiter(","))
	ntd_final := ntd.Perform(1234567890.506)
	ftm.Println(ntd_final) // "1,234,567,890.506"
}

Options:

gonumbers.Delimiter(string)

gonumbers.Separator(string)

###- Number to Human:

package main

import (
	"fmt"
	"github.com/hgsigner/gonumbers"
)

func main(){
	nth := gonumbers.ToHuman()
	nth.Options(gonumbers.Separator(","), gonumbers.Precision(2))
	nth_final := nth.Perform(489939)
	ftm.Println(nth_final) // "489,9 Thousand"
}

Options:

gonumbers.Precision(int) 

gonumbers.Separator(string)

###- Number to Human Size:

package main

import (
	"fmt"
	"github.com/hgsigner/gonumbers"
)

func main(){
	nths := gonumbers.ToHumanSize()
	nths_final, err := nths.Perform(1235551234)
	if err != nil{
		fmt.Println(err)
	}
	ftm.Println(nths_final) // "1.15 GB"
}

Options:

gonumbers.Delimiter(string) //Defines the delimiter for the number (default => ".")

gonumbers.Precision(int) // Sets precision of the number (default => 3).

gonumbers.Prefix(string) // Defines if it is binary or si (default => binary)

###- Number to Percentage:

package main

import (
	"fmt"
	"github.com/hgsigner/gonumbers"
)

func main(){
	ntp := gonumbers.ToPercentage()
	ntp.Options(gonumbers.Separator(","), gonumbers.Delimiter("."))
	ntp_final := ntp.Perform(1000)
	ftm.Println(ntp_final) // "1.000,000%"
}

Options:

gonumbers.Precision(int):

gonumbers.Separator(string):
 
gonumbers.Delimiter(string):

###- Number to Phone:

package main

import (
	"fmt"
	"github.com/hgsigner/gonumbers"
)

func main(){
	ntph := gonumbers.ToPhone()
	ntph.Options(gonumbers.CountryCode("1"))
	ntph_final, err := ntph.Perform(1235551234)
	if err != nil{
		fmt.Println(err)
	}
	ftm.Println(ntph_final) // "+1-123-555-1234"
}

Options:

gonumbers.Delimiter(string) // Defines the delimiter for the number. Default is "-"

gonumbers.AreaCode(bool) // Prints the area code in parenthesis.

gonumbers.Extension(string) // Appends extension to phone number. Ex. +1(123) 555-6789 x 4545

gonumbers.CountryCode(string) // Prepends country code to phone number (ex. +1)

gonumbers.DigitsSize(int) // Sets the number of digits of the second part of the phone (digits_count:5). Ex. 1234555556789 => 1234-55555-6789

For more information, please refer to the docs.

##Licensing: This package is available as open source under the terms of the MIT License.

Documentation

Overview

GoNumbers is an implementation of number helpers for Go-lang. This project is inspired by the ruby library ActiveSupport::NumberHelper.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AreaCode 

func AreaCode(ac bool) areaCodeOption

It wraps the area code parenthesis. E.g. (123) 444-5678

func CountryCode 

func CountryCode(cc string) countryCodeOption

It adds the country code to phone numbers. E.g +1(123)...

func Delimiter 

func Delimiter(d string) delimiterOption

Defines the delimiter for the number.

func DigitsSize 

func DigitsSize(ds int) digitsSizeOption

It sets the number of digits for the second part of a phone number. e.g 1233334567 => gonumbers.DigitsSize(4) / 12-3333-4567 / gonumbers.DigitsSize(2) -> 1233-33-4567

func Extension 

func Extension(ex string) extensionOption

It appends the extension to phone numbers. E.g. ...-6789 x 4545

func Precision 

func Precision(p int) precisionOption

Sets precision of the number.

func Prefix 

func Prefix(p string) prefixOption

Defines if it prefix for converting numbers to human size. It could be either binary or si (default => binary).

func Separator 

func Separator(s string) separatorOption

Defines the separator for the number.

func Unit 

func Unit(u string) unitOption

It sets the unit for NumberToCurrency function

Types

type NumberToCurrency 

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

func ToCurrency 

func ToCurrency() *NumberToCurrency

It initializes a new NumberToCurrency to permorf on.

Example 
package main

import (
	"fmt"

	"github.com/hgsigner/gonumbers"
)

func main() {
	ntc1 := gonumbers.ToCurrency()
	res1 := ntc1.Perform(1234567890.50)
	fmt.Println(res1)

	ntc2 := gonumbers.ToCurrency()
	ntc2.Options(gonumbers.Precision(2))
	res2 := ntc2.Perform(1234567890.506)
	fmt.Println(res2)

	ntc3 := gonumbers.ToCurrency()
	ntc3.Options(gonumbers.Precision(2), gonumbers.Unit("$"), gonumbers.Separator("."))
	res3 := ntc3.Perform(1234567890)
	fmt.Println(res3)

	ntc4 := gonumbers.ToCurrency()
	ntc4.Options(gonumbers.Precision(3), gonumbers.Unit("CAD$"), gonumbers.Separator("."), gonumbers.Delimiter(","))
	res4 := ntc4.Perform(1234567890.506)
	fmt.Println(res4)

	ntc5 := gonumbers.ToCurrency()
	ntc5.Options(gonumbers.Precision(2), gonumbers.Separator("."), gonumbers.Delimiter(""))
	res5 := ntc5.Perform(1234567890.50)
	fmt.Println(res5)

	ntc6 := gonumbers.ToCurrency()
	ntc6.Options(gonumbers.Precision(2), gonumbers.Separator(","), gonumbers.Delimiter("."))
	res6 := ntc6.Perform(1234567890.506)
	fmt.Println(res6)

}

Output:
$1,234,567,890.50
$1,234,567,890.51
$1,234,567,890.00
CAD$1,234,567,890.506
$1234567890.50
$1.234.567.890,51

func (*NumberToCurrency) Options 

func (ntc *NumberToCurrency) Options(options ...interface{})

It sets up options for NumberToCurrency. It receives: gonumbers.Precision(int), gonumbers.Unit(string), gonumbers.Separator(string) and gonumbers.Delimiter(string)

func (*NumberToCurrency) Perform 

func (ntc *NumberToCurrency) Perform(n float64) string

type NumberToDelimiter 

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

func ToDelimiter 

func ToDelimiter() *NumberToDelimiter

It initializes a new NumberToDelimiter to permorf on.

Example 
package main

import (
	"fmt"

	"github.com/hgsigner/gonumbers"
)

func main() {
	ntd1 := gonumbers.ToDelimiter()
	fmt.Println(ntd1.Perform(1234567890))

	ntd2 := gonumbers.ToDelimiter()
	ntd2.Options(gonumbers.Separator("."), gonumbers.Delimiter(","))
	fmt.Println(ntd2.Perform(1234567890.506))

	ntd3 := gonumbers.ToDelimiter()
	ntd3.Options(gonumbers.Separator("-"), gonumbers.Delimiter(":"))
	fmt.Println(ntd3.Perform(1234567890.34))

	ntd4 := gonumbers.ToDelimiter()
	ntd4.Options(gonumbers.Separator("."), gonumbers.Delimiter(""))
	fmt.Println(ntd4.Perform(1234567890.34))

	ntd5 := gonumbers.ToDelimiter()
	ntd5.Options(gonumbers.Separator(""), gonumbers.Delimiter(""))
	fmt.Println(ntd5.Perform(1234567890.34))

}

Output:
1,234,567,890
1,234,567,890.506
1:234:567:890-34
1234567890.34
123456789034

func (*NumberToDelimiter) Options 

func (ntd *NumberToDelimiter) Options(options ...interface{})

It sets up options for NumberToDelimiter. It receives: gonumbers.Separator(string) and gonumbers.Delimiter(string)

func (*NumberToDelimiter) Perform 

func (ntd *NumberToDelimiter) Perform(n float64) string

It performs the formating of a float64 number.

type NumberToHuman 

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

func ToHuman 

func ToHuman() *NumberToHuman

It initializes a new NumberToHuman to permorf on.

Example 
package main

import (
	"fmt"

	"github.com/hgsigner/gonumbers"
)

func main() {
	nth1 := gonumbers.ToHuman()
	fmt.Println(nth1.Perform(123))

	nth2 := gonumbers.ToHuman()
	fmt.Println(nth2.Perform(1234))

	nth3 := gonumbers.ToHuman()
	fmt.Println(nth3.Perform(12345))

	nth4 := gonumbers.ToHuman()
	fmt.Println(nth4.Perform(1234567))

	nth5 := gonumbers.ToHuman()
	fmt.Println(nth5.Perform(1234567890))

	nth6 := gonumbers.ToHuman()
	fmt.Println(nth6.Perform(1234567890123))

	nth7 := gonumbers.ToHuman()
	fmt.Println(nth7.Perform(1234567890123456))

	nth8 := gonumbers.ToHuman()
	nth8.Options(gonumbers.Precision(2))
	fmt.Println(nth8.Perform(489939))

	nth9 := gonumbers.ToHuman()
	nth9.Options(gonumbers.Precision(4))
	fmt.Println(nth9.Perform(489939))

	nth10 := gonumbers.ToHuman()
	nth10.Options(gonumbers.Precision(4), gonumbers.Separator(","))
	fmt.Println(nth10.Perform(489939))

}

Output:
123
1.23 Thousand
12.3 Thousand
1.23 Million
1.23 Billion
1.23 Trillion
1.23 Quadrillion
490 Thousand
489.9 Thousand
489,9 Thousand

func (*NumberToHuman) Options 

func (nth *NumberToHuman) Options(options ...interface{})

It sets up options for NumberToHuman. It receives: gonumbers.Precision(int) and gonumbers.Separator(string)

func (*NumberToHuman) Perform 

func (nth *NumberToHuman) Perform(n float64) string

It performs the formating of a float64 number.

type NumberToHumanSize 

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

func ToHumanSize 

func ToHumanSize() *NumberToHumanSize

It initializes a new NumberToHumanSize to permorf on.

Example 
package main

import (
	"fmt"

	"github.com/hgsigner/gonumbers"
)

func main() {
	nths1 := gonumbers.ToHumanSize()
	res1, err1 := nths1.Perform(333)
	if err1 != nil {
		fmt.Println(err1)
	}
	fmt.Println(res1)

	nths2 := gonumbers.ToHumanSize()
	res2, err2 := nths2.Perform(1234)
	if err2 != nil {
		fmt.Println(err2)
	}
	fmt.Println(res2)

	nths3 := gonumbers.ToHumanSize()
	res3, err3 := nths3.Perform(1234567890)
	if err3 != nil {
		fmt.Println(err3)
	}
	fmt.Println(res3)

	nths4 := gonumbers.ToHumanSize()
	nths4.Options(gonumbers.Precision(2))
	res4, err4 := nths4.Perform(1234567)
	if err4 != nil {
		fmt.Println(err4)
	}
	fmt.Println(res4)

	nths5 := gonumbers.ToHumanSize()
	nths5.Options(gonumbers.Precision(2), gonumbers.Separator(","))
	res5, err5 := nths5.Perform(1234567)
	if err5 != nil {
		fmt.Println(err5)
	}
	fmt.Println(res5)

	nths6 := gonumbers.ToHumanSize()
	nths6.Options(gonumbers.Precision(5))
	res6, err6 := nths6.Perform(524288000)
	if err6 != nil {
		fmt.Println(err6)
	}
	fmt.Println(res6)

}

Output:
333 Bytes
1.21 KB
1.15 GB
1.2 MB
1,2 MB
500 MB

func (*NumberToHumanSize) Options 

func (nths *NumberToHumanSize) Options(options ...interface{})

It sets up options for NumberToHumanSize. It receives: gonumbers.Precision(int), gonumbers.Separator(string) and gonumbers.Delimiter(string) and gonumbers.Prefix(string)

func (*NumberToHumanSize) Perform 

func (nths *NumberToHumanSize) Perform(n float64) (string, error)

Performs the formating of a float64 number. If the prefix is not binary or si, it returns an error.

type NumberToPercentage 

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

func ToPercentage 

func ToPercentage() *NumberToPercentage

It initializes a new NumberToPercentage to permorf on.

Example 
package main

import (
	"fmt"

	"github.com/hgsigner/gonumbers"
)

func main() {
	ntp1 := gonumbers.ToPercentage()
	fmt.Println(ntp1.Perform(100))

	ntp2 := gonumbers.ToPercentage()
	fmt.Println(ntp2.Perform("98"))

	ntp3 := gonumbers.ToPercentage()
	ntp3.Options(gonumbers.Precision(0))
	fmt.Println(ntp3.Perform(100))

	ntp4 := gonumbers.ToPercentage()
	fmt.Println(ntp4.Perform(1000))

	ntp5 := gonumbers.ToPercentage()
	ntp5.Options(gonumbers.Delimiter("."), gonumbers.Separator(","))
	fmt.Println(ntp5.Perform(1000))

	ntp6 := gonumbers.ToPercentage()
	ntp6.Options(gonumbers.Precision(5))
	fmt.Println(ntp6.Perform(302.24398923423))

	ntp7 := gonumbers.ToPercentage()
	fmt.Println(ntp7.Perform("hahahah"))

}

Output:
100.000%
98.000%
100%
1,000.000%
1.000,000%
302.24399%
0.000%

func (*NumberToPercentage) Options 

func (ntp *NumberToPercentage) Options(options ...interface{})

It sets up options for NumberToPercentage. It receives: gonumbers.Precision(int), gonumbers.Separator(string) and gonumbers.Delimiter(string)

func (*NumberToPercentage) Perform 

func (ntp *NumberToPercentage) Perform(val interface{}) string

It performs the convertion of the input into percentage. It accepts an interface, but only values related to numbers (e.g. floats, ints) or a string that could be parsed to float (e.g. "12345"). Inputs that are not related to numbers will be returned in the 0.000% format.

type NumberToPhone 

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

func ToPhone 

func ToPhone() *NumberToPhone

It initializes a new NumberToPhone to permorf on.

Example 
package main

import (
	"fmt"

	"github.com/hgsigner/gonumbers"
)

func main() {
	ntph1 := gonumbers.ToPhone()
	resp1, err1 := ntph1.Perform(5551234)
	if err1 != nil {
		fmt.Println(err1)
	}
	fmt.Println(resp1)

	ntph2 := gonumbers.ToPhone()
	resp2, err2 := ntph2.Perform(1235551234)
	if err2 != nil {
		fmt.Println(err2)
	}
	fmt.Println(resp2)

	ntph3 := gonumbers.ToPhone()
	ntph3.Options(gonumbers.AreaCode(true))
	resp3, err3 := ntph3.Perform(1235551234)
	if err3 != nil {
		fmt.Println(err3)
	}
	fmt.Println(resp3)

	ntph4 := gonumbers.ToPhone()
	ntph4.Options(gonumbers.AreaCode(true), gonumbers.CountryCode("1"))
	resp4, err4 := ntph4.Perform(1235551234)
	if err4 != nil {
		fmt.Println(err4)
	}
	fmt.Println(resp4)

	ntph5 := gonumbers.ToPhone()
	ntph5.Options(gonumbers.CountryCode("1"))
	resp5, err5 := ntph5.Perform(1235551234)
	if err5 != nil {
		fmt.Println(err5)
	}
	fmt.Println(resp5)

	ntph6 := gonumbers.ToPhone()
	ntph6.Options(gonumbers.AreaCode(true), gonumbers.CountryCode("1"), gonumbers.Extension("4545"))
	resp6, err6 := ntph6.Perform(1235551234)
	if err6 != nil {
		fmt.Println(err6)
	}
	fmt.Println(resp6)

	ntph7 := gonumbers.ToPhone()
	ntph7.Options(gonumbers.AreaCode(true), gonumbers.CountryCode("1"), gonumbers.Extension("4545"), gonumbers.DigitsSize(5))
	resp7, err7 := ntph7.Perform(1234555556789)
	if err7 != nil {
		fmt.Println(err7)
	}
	fmt.Println(resp7)

	ntph8 := gonumbers.ToPhone()
	ntph8.Options(gonumbers.AreaCode(true), gonumbers.CountryCode("55"), gonumbers.Delimiter(","), gonumbers.DigitsSize(5))
	resp8, err8 := ntph8.Perform(1234555556789)
	if err8 != nil {
		fmt.Println(err8)
	}
	fmt.Println(resp8)

}

Output:
555-1234
123-555-1234
(123) 555-1234
+1(123) 555-1234
+1-123-555-1234
+1(123) 555-1234 x 4545
+1(1234) 55555-6789 x 4545
+55(1234) 55555,6789

func (*NumberToPhone) Options 

func (ntph *NumberToPhone) Options(options ...interface{})

Sets up options for NumberToPhone. Receives: gonumbers.Delimiter(string), gonumbers.AreaCode(bool), gonumbers.Extension(string), gonumbers.CountryCode(string) and gonumbers.DigitsSize(int)

func (*NumberToPhone) Perform 

func (ntph *NumberToPhone) Perform(val interface{}) (string, error)

It performs the convertion of the input into phone number format. It accepts an interface, but only values related to numbers (e.g. floats, ints) or a string that could be parsed to float (e.g. "12345"). Inputs that are not related to numbers will return an error.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.