package humanize

Import Path
	github.com/dustin/go-humanize (on go.dev)

Dependency Relation
	imports 11 packages, and imported by one package

Involved Source Files

	    big.go
	    bigbytes.go
	    bytes.go
	    comma.go
	    commaf.go
	    ftoa.go
	  d humanize.go
		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).

	    number.go
	    ordinals.go
	    si.go
	    times.go
Package-Level Type Names (only one)

	/* sort by: alphabet | popularity */
	 type RelTimeMagnitude (struct)
		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.

		Fields (total 3)
			D time.Duration
			DivBy time.Duration
			Format string
		As Inputs Of (at least one exported)
			func CustomRelTime(a, b time.Time, albl, blbl string, magnitudes []RelTimeMagnitude) string


Package-Level Functions (total 23)

	 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(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(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(s *big.Int) string
		BigIBytes produces a human readable representation of an IEC size.
		
		See also: ParseBigBytes.
		
		BigIBytes(82854982) -> 79 MiB

	 func Bytes(s uint64) string
		Bytes produces a human readable representation of an SI size.
		
		See also: ParseBytes.
		
		Bytes(82854982) -> 83 MB

	 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(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(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(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(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(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(format string, n int) string
		FormatInteger produces a formatted number as string.
		See FormatFloat.

	 func Ftoa(num float64) string
		Ftoa converts a float to a string with no trailing zeros.

	 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(s uint64) string
		IBytes produces a human readable representation of an IEC size.
		
		See also: ParseBytes.
		
		IBytes(82854982) -> 79 MiB

	 func Ordinal(x int) string
		Ordinal gives you the input number in a rank/ordinal format.
		
		Ordinal(3) -> 3rd

	 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(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(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(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(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(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(then time.Time) string
		Time formats a time into a relative string.
		
		Time(someT) -> "3 weeks ago"


Package-Level Variables (total 22)

	  var BigByte *big.Int
		BigByte is one byte in bit.Ints

	  var BigEByte *big.Int
		BigEByte is 1,000 SI p bytes in big.Ints

	  var BigEiByte *big.Int
		BigEiByte is 1,024 p bytes in bit.Ints

	  var BigGByte *big.Int
		BigGByte is 1,000 SI m bytes in big.Ints

	  var BigGiByte *big.Int
		BigGiByte is 1,024 m bytes in bit.Ints

	  var BigKByte *big.Int
		BigKByte is 1,000 SI bytes in big.Ints

	  var BigKiByte *big.Int
		BigKiByte is 1,024 bytes in bit.Ints

	  var BigMByte *big.Int
		BigMByte is 1,000 SI k bytes in big.Ints

	  var BigMiByte *big.Int
		BigMiByte is 1,024 k bytes in bit.Ints

	  var BigPByte *big.Int
		BigPByte is 1,000 SI t bytes in big.Ints

	  var BigPiByte *big.Int
		BigPiByte is 1,024 t bytes in bit.Ints

	  var BigQByte *big.Int
		BigQByte is 1,000 SI r bytes in big.Ints

	  var BigQiByte *big.Int
		BigQiByte is 1,024 r bytes in bit.Ints

	  var BigRByte *big.Int
		BigRByte is 1,000 SI y bytes in big.Ints

	  var BigRiByte *big.Int
		BigRiByte is 1,024 y bytes in bit.Ints

	  var BigSIByte *big.Int
		BigSIByte is one SI byte in big.Ints

	  var BigTByte *big.Int
		BigTByte is 1,000 SI g bytes in big.Ints

	  var BigTiByte *big.Int
		BigTiByte is 1,024 g bytes in bit.Ints

	  var BigYByte *big.Int
		BigYByte is 1,000 SI z bytes in big.Ints

	  var BigYiByte *big.Int
		BigYiByte is 1,024 z bytes in bit.Ints

	  var BigZByte *big.Int
		BigZByte is 1,000 SI e bytes in big.Ints

	  var BigZiByte *big.Int
		BigZiByte is 1,024 e bytes in bit.Ints


Package-Level Constants (total 19)

	const Byte = 1
		IEC Sizes.
		kibis of bits

	const Day time.Duration = 86400000000000
		Seconds-based time units

	const EByte = 1000000000000000000
		SI Sizes.

	const EiByte = 1152921504606846976
		IEC Sizes.
		kibis of bits

	const GByte = 1000000000
		SI Sizes.

	const GiByte = 1073741824
		IEC Sizes.
		kibis of bits

	const IByte = 1
		SI Sizes.

	const KByte = 1000
		SI Sizes.

	const KiByte = 1024
		IEC Sizes.
		kibis of bits

	const LongTime time.Duration = 1150848000000000000
		Seconds-based time units

	const MByte = 1000000
		SI Sizes.

	const MiByte = 1048576
		IEC Sizes.
		kibis of bits

	const Month time.Duration = 2592000000000000
		Seconds-based time units

	const PByte = 1000000000000000
		SI Sizes.

	const PiByte = 1125899906842624
		IEC Sizes.
		kibis of bits

	const TByte = 1000000000000
		SI Sizes.

	const TiByte = 1099511627776
		IEC Sizes.
		kibis of bits

	const Week time.Duration = 604800000000000
		Seconds-based time units

	const Year time.Duration = 31104000000000000
		Seconds-based time units

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.