go-humanize: github.com/dustin/go-humanize Index | Files | Directories

package humanize

import "github.com/dustin/go-humanize"

Package humanize converts boring ugly numbers to human-friendly strings and back.

Durations can be turned into strings such as "3 days ago", numbers representing sizes like 82854982 into useful strings like, "83 MB" or "79 MiB" (whichever you prefer).

Index

Package Files

big.go bigbytes.go bytes.go comma.go commaf.go ftoa.go humanize.go number.go ordinals.go si.go times.go

Constants

const (
    Byte = 1 << (iota * 10)
    KiByte
    MiByte
    GiByte
    TiByte
    PiByte
    EiByte
)

IEC Sizes. kibis of bits

const (
    IByte = 1
    KByte = IByte * 1000
    MByte = KByte * 1000
    GByte = MByte * 1000
    TByte = GByte * 1000
    PByte = TByte * 1000
    EByte = PByte * 1000
)

SI Sizes.

const (
    Day      = 24 * time.Hour
    Week     = 7 * Day
    Month    = 30 * Day
    Year     = 12 * Month
    LongTime = 37 * Year
)

Seconds-based time units

Variables

var (

    // BigByte is one byte in bit.Ints
    BigByte = big.NewInt(1)
    // BigKiByte is 1,024 bytes in bit.Ints
    BigKiByte = (&big.Int{}).Mul(BigByte, bigIECExp)
    // BigMiByte is 1,024 k bytes in bit.Ints
    BigMiByte = (&big.Int{}).Mul(BigKiByte, bigIECExp)
    // BigGiByte is 1,024 m bytes in bit.Ints
    BigGiByte = (&big.Int{}).Mul(BigMiByte, bigIECExp)
    // BigTiByte is 1,024 g bytes in bit.Ints
    BigTiByte = (&big.Int{}).Mul(BigGiByte, bigIECExp)
    // BigPiByte is 1,024 t bytes in bit.Ints
    BigPiByte = (&big.Int{}).Mul(BigTiByte, bigIECExp)
    // BigEiByte is 1,024 p bytes in bit.Ints
    BigEiByte = (&big.Int{}).Mul(BigPiByte, bigIECExp)
    // BigZiByte is 1,024 e bytes in bit.Ints
    BigZiByte = (&big.Int{}).Mul(BigEiByte, bigIECExp)
    // BigYiByte is 1,024 z bytes in bit.Ints
    BigYiByte = (&big.Int{}).Mul(BigZiByte, bigIECExp)
)
var (

    // BigSIByte is one SI byte in big.Ints
    BigSIByte = big.NewInt(1)
    // BigKByte is 1,000 SI bytes in big.Ints
    BigKByte = (&big.Int{}).Mul(BigSIByte, bigSIExp)
    // BigMByte is 1,000 SI k bytes in big.Ints
    BigMByte = (&big.Int{}).Mul(BigKByte, bigSIExp)
    // BigGByte is 1,000 SI m bytes in big.Ints
    BigGByte = (&big.Int{}).Mul(BigMByte, bigSIExp)
    // BigTByte is 1,000 SI g bytes in big.Ints
    BigTByte = (&big.Int{}).Mul(BigGByte, bigSIExp)
    // BigPByte is 1,000 SI t bytes in big.Ints
    BigPByte = (&big.Int{}).Mul(BigTByte, bigSIExp)
    // BigEByte is 1,000 SI p bytes in big.Ints
    BigEByte = (&big.Int{}).Mul(BigPByte, bigSIExp)
    // BigZByte is 1,000 SI e bytes in big.Ints
    BigZByte = (&big.Int{}).Mul(BigEByte, bigSIExp)
    // BigYByte is 1,000 SI z bytes in big.Ints
    BigYByte = (&big.Int{}).Mul(BigZByte, bigSIExp)
)

func BigBytes Uses

func BigBytes(s *big.Int) string

BigBytes produces a human readable representation of an SI size.

See also: ParseBigBytes.

BigBytes(82854982) -> 83 MB

func BigComma Uses

func BigComma(b *big.Int) string

BigComma produces a string form of the given big.Int in base 10 with commas after every three orders of magnitude.

func BigCommaf Uses

func BigCommaf(v *big.Float) string

BigCommaf produces a string form of the given big.Float in base 10 with commas after every three orders of magnitude.

func BigIBytes Uses

func BigIBytes(s *big.Int) string

BigIBytes produces a human readable representation of an IEC size.

See also: ParseBigBytes.

BigIBytes(82854982) -> 79 MiB

func Bytes Uses

func Bytes(s uint64) string

Bytes produces a human readable representation of an SI size.

See also: ParseBytes.

Bytes(82854982) -> 83 MB

func Comma Uses

func Comma(v int64) string

Comma produces a string form of the given number in base 10 with commas after every three orders of magnitude.

e.g. Comma(834142) -> 834,142

func Commaf Uses

func Commaf(v float64) string

Commaf produces a string form of the given number in base 10 with commas after every three orders of magnitude.

e.g. Commaf(834142.32) -> 834,142.32

func CommafWithDigits Uses

func CommafWithDigits(f float64, decimals int) string

CommafWithDigits works like the Commaf but limits the resulting string to the given number of decimal places.

e.g. CommafWithDigits(834142.32, 1) -> 834,142.3

func ComputeSI Uses

func ComputeSI(input float64) (float64, string)

ComputeSI finds the most appropriate SI prefix for the given number and returns the prefix along with the value adjusted to be within that prefix.

See also: SI, ParseSI.

e.g. ComputeSI(2.2345e-12) -> (2.2345, "p")

func CustomRelTime Uses

func CustomRelTime(a, b time.Time, albl, blbl string, magnitudes []RelTimeMagnitude) string

CustomRelTime formats a time into a relative string.

It takes two times two labels and a table of relative time formats. In addition to the generic time delta string (e.g. 5 minutes), the labels are used applied so that the label corresponding to the smaller time is applied.

func FormatFloat Uses

func FormatFloat(format string, n float64) string

FormatFloat produces a formatted number as string based on the following user-specified criteria: * thousands separator * decimal separator * decimal precision

Usage: s := RenderFloat(format, n) The format parameter tells how to render the number n.

See examples: http://play.golang.org/p/LXc1Ddm1lJ

Examples of format strings, given n = 12345.6789: "#,###.##" => "12,345.67" "#,###." => "12,345" "#,###" => "12345,678" "#\u202F###,##" => "12 345,68" "#.###,###### => 12.345,678900 "" (aka default format) => 12,345.67

The highest precision allowed is 9 digits after the decimal symbol. There is also a version for integer number, FormatInteger(), which is convenient for calls within template.

func FormatInteger Uses

func FormatInteger(format string, n int) string

FormatInteger produces a formatted number as string. See FormatFloat.

func Ftoa Uses

func Ftoa(num float64) string

Ftoa converts a float to a string with no trailing zeros.

func FtoaWithDigits Uses

func FtoaWithDigits(num float64, digits int) string

FtoaWithDigits converts a float to a string but limits the resulting string to the given number of decimal places, and no trailing zeros.

func IBytes Uses

func IBytes(s uint64) string

IBytes produces a human readable representation of an IEC size.

See also: ParseBytes.

IBytes(82854982) -> 79 MiB

func Ordinal Uses

func Ordinal(x int) string

Ordinal gives you the input number in a rank/ordinal format.

Ordinal(3) -> 3rd

func ParseBigBytes Uses

func ParseBigBytes(s string) (*big.Int, error)

ParseBigBytes parses a string representation of bytes into the number of bytes it represents.

See also: BigBytes, BigIBytes.

ParseBigBytes("42 MB") -> 42000000, nil ParseBigBytes("42 mib") -> 44040192, nil

func ParseBytes Uses

func ParseBytes(s string) (uint64, error)

ParseBytes parses a string representation of bytes into the number of bytes it represents.

See Also: Bytes, IBytes.

ParseBytes("42 MB") -> 42000000, nil ParseBytes("42 mib") -> 44040192, nil

func ParseSI Uses

func ParseSI(input string) (float64, string, error)

ParseSI parses an SI string back into the number and unit.

See also: SI, ComputeSI.

e.g. ParseSI("2.2345 pF") -> (2.2345e-12, "F", nil)

func RelTime Uses

func RelTime(a, b time.Time, albl, blbl string) string

RelTime formats a time into a relative string.

It takes two times and two labels. In addition to the generic time delta string (e.g. 5 minutes), the labels are used applied so that the label corresponding to the smaller time is applied.

RelTime(timeInPast, timeInFuture, "earlier", "later") -> "3 weeks earlier"

func SI Uses

func SI(input float64, unit string) string

SI returns a string with default formatting.

SI uses Ftoa to format float value, removing trailing zeros.

See also: ComputeSI, ParseSI.

e.g. SI(1000000, "B") -> 1 MB e.g. SI(2.2345e-12, "F") -> 2.2345 pF

func SIWithDigits Uses

func SIWithDigits(input float64, decimals int, unit string) string

SIWithDigits works like SI but limits the resulting string to the given number of decimal places.

e.g. SIWithDigits(1000000, 0, "B") -> 1 MB e.g. SIWithDigits(2.2345e-12, 2, "F") -> 2.23 pF

func Time Uses

func Time(then time.Time) string

Time formats a time into a relative string.

Time(someT) -> "3 weeks ago"

type RelTimeMagnitude Uses

type RelTimeMagnitude struct {
    D      time.Duration
    Format string
    DivBy  time.Duration
}

A RelTimeMagnitude struct contains a relative time point at which the relative format of time will switch to a new format string. A slice of these in ascending order by their "D" field is passed to CustomRelTime to format durations.

The Format field is a string that may contain a "%s" which will be replaced with the appropriate signed label (e.g. "ago" or "from now") and a "%d" that will be replaced by the quantity.

The DivBy field is the amount of time the time difference must be divided by in order to display correctly.

e.g. if D is 2*time.Minute and you want to display "%d minutes %s" DivBy should be time.Minute so whatever the duration is will be expressed in minutes.

Directories

PathSynopsis
englishPackage english provides utilities to generate more user-friendly English output.

Package humanize imports 11 packages (graph) and is imported by 2376 packages. Updated 2019-03-06. Refresh now. Tools for package owners.