fmt

Package fmt implements formatted I/O with functions analogous to C's printf and scanf.

printing

The verbs:

General:

%v    the value in a default format
    when printing structs, the plus flag (%+v) adds field names
%#v    a Go-syntax representation of the value
%T    a Go-syntax representation of the type of the value
%%    a literal percent sign; consumes no value

Boolean:

%t    the word true or false

Integer:

%b    base 2
%c    the character represented by the corresponding Unicode code point
%d    base 10
%o    base 8
%q    a single-quoted character literal safely escaped with Go syntax.
%x    base 16, with lower-case letters for a-f
%X    base 16, with upper-case letters for A-F
%U    Unicode format: U+1234; same as "U+%04X"

Floating-point and complex constituents:

%b    decimalless scientific notation with exponent a power of two,
    in the manner of strconv.FormatFloat with the 'b' format,
    e.g. -123456p-78
%e    scientific notation, e.g. -1.234456e+78
%E    scientific notation, e.g. -1.234456E+78
%f    decimal point but no exponent, e.g. 123.456
%F    synonym for %f
%g    %e for large exponents, %f otherwise. Precision is discussed below.
%G    %E for large exponents, %F otherwise

String and slice of bytes (treated equivalently with these verbs):

%s    the uninterpreted bytes of the string or slice
%q    a double-quoted string safely escaped with Go syntax
%x    base 16, lower-case, two characters per byte
%X    base 16, upper-case, two characters per byte

Slice:

%p    address of 0th element in base 16 notation, with leading 0x

Pointer:

%p    base 16 notation, with leading 0x
The %b, %d, %o, %x and %X verbs also work with pointers,
formatting the value exactly as if it were an integer.

The default format for %v is:

bool:                    %t
int, int8 etc.:          %d
uint, uint8 etc.:        %d, %#x if printed with %#v
float32, complex64, etc: %g
string:                  %s
chan:                    %p
pointer:                 %p

For compound objects, the elements are printed using these rules, recursively, laid out like this:

struct:             {field0 field1 ...}
array, slice:       [elem0 elem1 ...]
maps:               map[key1:value1 key2:value2 ...]
pointer to above:   &{}, &[], &map[]

API

• func Errorf(format string, a ...interface{}) error
• func Fprint(w io.Writer, a ...interface{}) (n int, err error)
• func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
• func Fprintln(w io.Writer, a ...interface{}) (n int, err error)
• func Fscan(r io.Reader, a ...interface{}) (n int, err error)
• func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)
• func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
• func Print(a ...interface{}) (n int, err error)
• func Printf(format string, a ...interface{}) (n int, err error)
• func Println(a ...interface{}) (n int, err error)
• func Scan(a ...interface{}) (n int, err error)
• func Scanf(format string, a ...interface{}) (n int, err error)
• func Scanln(a ...interface{}) (n int, err error)
• func Sprint(a ...interface{}) string
• func Sprintf(format string, a ...interface{}) string
• func Sprintln(a ...interface{}) string
• func Sscan(str string, a ...interface{}) (n int, err error)
• func Sscanf(str string, format string, a ...interface{}) (n int, err error)
• func Sscanln(str string, a ...interface{}) (n int, err error)
• type Formatter
• type GoStringer
• type ScanState
• type Scanner
• type State
• type Stringer