README
¶
Package pretty provides pretty-printing for Go values.
This is a fork of github.com/kr/pretty that makes the printing
even more pretty. By default, String() is called if possible
on values, and unexported fields are not printed.
Documentation
¶
Overview ¶
Package pretty provides pretty-printing for Go values. This is useful during debugging, to avoid wrapping long output lines in the terminal.
It provides a function, Formatter, that can be used with any function that accepts a format string. It also provides convenience wrappers for functions in packages fmt and log.
Example ¶
package main
import (
"fmt"
"github.com/kr/pretty"
)
func main() {
type myType struct {
a, b int
}
var x = []myType{{1, 2}, {3, 4}, {5, 6}}
fmt.Printf("%# v", pretty.Formatter(x))
}
Output: []pretty_test.myType{ {a:1, b:2}, {a:3, b:4}, {a:5, b:6}, }
Index ¶
- func Diff(a, b interface{}) (desc []string)
- func Errorf(format string, a ...interface{}) error
- func Fdiff(w io.Writer, a, b interface{})
- func Formatter(x interface{}) (f fmt.Formatter)
- func Fprintf(w io.Writer, format string, a ...interface{}) (n int, error error)
- func Ldiff(l Logfer, a, b interface{})
- func Log(a ...interface{})
- func Logf(format string, a ...interface{})
- func Logln(a ...interface{})
- func Pdiff(p Printfer, a, b interface{})
- func Print(a ...interface{}) (n int, errno error)
- func Printf(format string, a ...interface{}) (n int, errno error)
- func Println(a ...interface{}) (n int, errno error)
- func SetDebugMode(mode bool)
- func Sprint(a ...interface{}) string
- func Sprintf(format string, a ...interface{}) string
- type Logfer
- type Printfer
- type Stringer
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Diff ¶
func Diff(a, b interface{}) (desc []string)
Diff returns a slice where each element describes a difference between a and b.
func Errorf ¶
Errorf is a convenience wrapper for fmt.Errorf.
Calling Errorf(f, x, y) is equivalent to fmt.Errorf(f, Formatter(x), Formatter(y)).
func Formatter ¶
Formatter makes a wrapper, f, that will format x as go source with line breaks and tabs. Object f responds to the "%v" formatting verb when both the "#" and " " (space) flags are set, for example:
fmt.Sprintf("%# v", Formatter(x))
If one of these two flags is not set, or any other verb is used, f will format x according to the usual rules of package fmt. In particular, if x satisfies fmt.Formatter, then x.Format will be called.
func Fprintf ¶
Fprintf is a convenience wrapper for fmt.Fprintf.
Calling Fprintf(w, f, x, y) is equivalent to fmt.Fprintf(w, f, Formatter(x), Formatter(y)).
func Ldiff ¶
func Ldiff(l Logfer, a, b interface{})
Ldiff prints to l a description of the differences between a and b. It calls Logf once for each difference, with no trailing newline. The standard library testing.T and testing.B are Logfers.
func Log ¶
func Log(a ...interface{})
Log is a convenience wrapper for log.Printf.
Calling Log(x, y) is equivalent to log.Print(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".
func Logf ¶
func Logf(format string, a ...interface{})
Logf is a convenience wrapper for log.Printf.
Calling Logf(f, x, y) is equivalent to log.Printf(f, Formatter(x), Formatter(y)).
func Logln ¶
func Logln(a ...interface{})
Logln is a convenience wrapper for log.Printf.
Calling Logln(x, y) is equivalent to log.Println(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".
func Pdiff ¶
func Pdiff(p Printfer, a, b interface{})
Pdiff prints to p a description of the differences between a and b. It calls Printf once for each difference, with no trailing newline. The standard library log.Logger is a Printfer.
func Print ¶
Print pretty-prints its operands and writes to standard output.
Calling Print(x, y) is equivalent to fmt.Print(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".
func Printf ¶
Printf is a convenience wrapper for fmt.Printf.
Calling Printf(f, x, y) is equivalent to fmt.Printf(f, Formatter(x), Formatter(y)).
func Println ¶
Println pretty-prints its operands and writes to standard output.
Calling Println(x, y) is equivalent to fmt.Println(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".
func SetDebugMode ¶
func SetDebugMode(mode bool)
SetDebugMode sets the debug mode of the global printer. If debug mode is true, the String method will not be called on any type, and unexported fields will be printed.
Source Files