README
¶
package pretty
import "github.com/kr/pretty"
Package pretty provides pretty-printing for Go values.
Documentation
http://godoc.org/github.com/kr/pretty
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/mickael-menu/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 Sprint(a ...interface{}) string
- func Sprintf(format string, a ...interface{}) string
- type Logfer
- type Printfer
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".
Source Files