pterm

package module
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 28, 2020 License: MIT Imports: 8 Imported by: 2,510

README

:computer: PTerm | Pretty Terminal

A golang module to print pretty text

Latest Release Stars Forks Issues
Downloads
PTerm Documentation Dops

Examples

demo

Animation

package main

import (
	"time"

	"github.com/pterm/pterm"
)

func main() {

	pterm.PrintHeader("You can do many things with PTerm")

	time.Sleep(time.Second * 3)

	pterm.Println(pterm.Cyan("Like this header above!"))

	time.Sleep(time.Second * 2)

	clear()

	pterm.PrintSuccess("You can print success messages!")

	time.Sleep(time.Second * 2)

	pterm.PrintInfo("Or infos!")

	time.Sleep(time.Second)

	pterm.PrintError("Or errors!")

	time.Sleep(time.Second)

	pterm.PrintWarning("Or warnings!")

	time.Sleep(time.Second)

	pterm.PrintDescription("Even descriptions can be printed...")

	time.Sleep(time.Second * 2)

	customPrefixPrinter := pterm.PrefixPrinter{
		Prefix: pterm.Prefix{
			Text:  "CUSTOM",
			Style: []pterm.Color{pterm.FgLightRed, pterm.BgBlue},
		},
	}

	customPrefixPrinter.Println("Or a custom PrefixPrinter can be crafted :)")

	time.Sleep(time.Second * 2)

	pterm.Warning.WithScope("custom-scope").Println("PrefixPrinters also support scopes!")

	time.Sleep(time.Second * 4)

	clear()

	pterm.PrintHeader("Everything can be customized!")

	time.Sleep(time.Second * 2)

	headerStyles := []pterm.Style{
		{pterm.BgGreen},
		{pterm.BgWhite},
		{pterm.BgRed},
		{pterm.BgBlue},
		{pterm.BgYellow},
		{pterm.BgLightMagenta},
	}

	for _, style := range headerStyles {
		clear()
		pterm.HeaderPrinter{
			BackgroundStyle: style,
			TextStyle:       pterm.Style{pterm.FgLightWhite},
			Margin:          5,
		}.Println("Everything can be customized")
		time.Sleep(time.Second / 2)
	}

	for i := 0; i < 10; i++ {
		clear()
		style := headerStyles[len(headerStyles)-1]
		pterm.HeaderPrinter{
			BackgroundStyle: style,
			TextStyle:       pterm.Style{pterm.FgLightWhite},
			Margin:          5 + i,
		}.Println("Everything can be customized")
		time.Sleep(time.Millisecond * 100)
	}

	for i := 0; i < 15; i++ {
		clear()
		style := headerStyles[len(headerStyles)-1]
		pterm.HeaderPrinter{
			BackgroundStyle: style,
			TextStyle:       pterm.Style{pterm.FgLightWhite},
			Margin:          15 - i,
		}.Println("Everything can be customized")
		time.Sleep(time.Millisecond * 100)
	}

}

func clear() {
	print("\033[H\033[2J")
}

override-default-printer

Animation

package main

import "github.com/pterm/pterm"

func main() {

	pterm.Error.Println("This is the default Error")

	pterm.Error.Prefix = pterm.Prefix{
		Text:  "OVERRIDE",
		Style: pterm.Style{pterm.BgCyan, pterm.FgRed},
	}

	pterm.Error.Println("This is the default Error after the prefix was overridden")
}

print-header

Animation

package main

import (
	"time"

	"github.com/pterm/pterm"
)

func main() {
	tick := time.Tick(time.Second * 2)

	// Print with the default HeaderPrinter
	pterm.PrintHeader("This is the default header style")

	<-tick // Wait

	// Print a custom header
	pterm.Header.WithFullWidth().WithTextStyle(pterm.FgDarkGray).WithBackgroundStyle(pterm.BgLightMagenta).Println("Hello, World!")

	<-tick // Wait

	// Create a custom HeaderPrinter
	customHeaderPrinter := pterm.HeaderPrinter{
		TextStyle:       pterm.Style{pterm.FgLightRed},
		BackgroundStyle: pterm.Style{pterm.BgGreen},
		Margin:          15,
	}
	// Use custom Header printer
	customHeaderPrinter.Println("This is a custom header.")
}

print-with-color

Animation

package main

import "github.com/pterm/pterm"

func main() {
	// Simple Println with different colored words.
	pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
}

spinner

Animation

package main

import (
	"time"

	"github.com/pterm/pterm"
)

func main() {

	spinnerSuccess := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")

	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something

	spinnerSuccess.Success()

	spinnerWarning := pterm.DefaultSpinner.Start("Doing something important... (will warn)")

	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something

	spinnerWarning.Warning()

	spinnerFail := pterm.DefaultSpinner.Start("Doing something important... (will fail)")

	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something

	spinnerFail.Fail()

}

Documentation

Index

Constants

View Source 
const Version = "v0.1.0" // <---VERSION---> | This comment is for our CI System. Do not edit it.

Version returns the current version of PTerm in SemVer format.

Variables

View Source 
var (
	// Sprint formats using the default formats for its operands and returns the resulting string.
	// Spaces are added between operands when neither is a string.
	Sprint = color.Sprint

	// Sprintf formats according to a format specifier and returns the resulting string.
	Sprintf = color.Sprintf

	// Println formats using the default formats for its operands and writes to standard output.
	// Spaces are always added between operands and a newline is appended.
	// It returns the number of bytes written and any write error encountered.
	Println = color.Println

	// Printf formats according to a format specifier and writes to standard output.
	// It returns the number of bytes written and any write error encountered.
	Printf = color.Printf

	// Print formats using the default formats for its operands and writes to standard output.
	// Spaces are added between operands when neither is a string.
	// It returns the number of bytes written and any write error encountered.
	Print = color.Print

	// Fprint formats using the default formats for its operands and writes to w.
	// Spaces are added between operands when neither is a string.
	// It returns the number of bytes written and any write error encountered.
	Fprint = color.Fprint

	// Fprintln formats using the default formats for its operands and writes to w.
	// Spaces are always added between operands and a newline is appended.
	// It returns the number of bytes written and any write error encountered.
	Fprintln = color.Fprintln
)
View Source 
var (
	// Red is an alias for FgRed.Sprint
	Red = FgRed.Sprint
	// Cyan is an alias for FgCyan.Sprint
	Cyan = FgCyan.Sprint
	// Gray is an alias for FgGray.Sprint
	Gray = FgGray.Sprint
	// Blue is an alias for FgBlue.Sprint
	Blue = FgBlue.Sprint
	// Black is an alias for FgBlack.Sprint
	Black = FgBlack.Sprint
	// Green is an alias for FgGreen.Sprint
	Green = FgGreen.Sprint
	// White is an alias for FgWhite.Sprint
	White = FgWhite.Sprint
	// Yellow is an alias for FgYellow.Sprint
	Yellow = FgYellow.Sprint
	// Magenta is an alias for FgMagenta.Sprint
	Magenta = FgMagenta.Sprint

	// Normal is an alias for FgDefault.Sprint
	Normal = FgDefault.Sprint

	// LightRed is a shortcut for FgLightRed.Sprint
	LightRed = FgLightRed.Sprint
	// LightCyan is a shortcut for FgLightCyan.Sprint
	LightCyan = FgLightCyan.Sprint
	// LightBlue is a shortcut for FgLightBlue.Sprint
	LightBlue = FgLightBlue.Sprint
	// LightGreen is a shortcut for FgLightGreen.Sprint
	LightGreen = FgLightGreen.Sprint
	// LightWhite is a shortcut for FgLightWhite.Sprint
	LightWhite = FgLightWhite.Sprint
	// LightYellow is a shortcut for FgLightYellow.Sprint
	LightYellow = FgLightYellow.Sprint
	// LightMagenta is a shortcut for FgLightMagenta.Sprint
	LightMagenta = FgLightMagenta.Sprint
)
View Source 
var (
	// Header returns the printer for a default header text.
	// Defaults to LightWhite, Bold Text and a Gray Header background.
	Header = HeaderPrinter{
		TextStyle:       Style{FgLightWhite, Bold},
		BackgroundStyle: Style{BgGray},
		Margin:          5,
	}

	// PrintHeader is the short form of DefaultHeaderPrinter.Println
	PrintHeader = Header.Println
)
View Source 
var (
	// Info returns a PrefixPrinter, which can be used to print text with an "info" Prefix
	Info = PrefixPrinter{
		Prefix: Prefix{
			Text:  "INFO",
			Style: NewStyle(FgBlack, BgCyan),
		},
		MessageStyle: NewStyle(FgLightCyan),
	}
	// PrintInfo is a shortcut to Info.Println
	PrintInfo = Info.Println

	// Warning returns a PrefixPrinter, which can be used to print text with a "warning" Prefix
	Warning = PrefixPrinter{
		Prefix: Prefix{
			Text:  "WARNING",
			Style: NewStyle(FgBlack, BgYellow),
		},
		MessageStyle: NewStyle(FgYellow),
	}
	// PrintWarning is a shortcut to Warning.Println
	PrintWarning = Warning.Println

	// Success returns a PrefixPrinter, which can be used to print text with a "success" Prefix
	Success = PrefixPrinter{
		Prefix: Prefix{
			Text:  "SUCCESS",
			Style: NewStyle(FgBlack, BgGreen),
		},
		MessageStyle: NewStyle(FgGreen),
	}
	// PrintSuccess is a shortcut to Success.Println
	PrintSuccess = Success.Println

	// Error returns a PrefixPrinter, which can be used to print text with an "error" Prefix
	Error = PrefixPrinter{
		Prefix: Prefix{
			Text:  "ERROR",
			Style: NewStyle(FgBlack, BgLightRed),
		},
		MessageStyle: NewStyle(FgLightRed),
	}
	// PrintError is a shortcut to Error.Println
	PrintError = Error.Println

	// Description returns a PrefixPrinter, which can be used to print text with a "description" Prefix
	Description = PrefixPrinter{
		Prefix: Prefix{
			Text:  "Description",
			Style: Style{BgDarkGray, FgLightWhite},
		},
		MessageStyle: Style{BgDarkGray, FgLightWhite},
	}
	// PrintDescription is a shortcut to Description.Println
	PrintDescription = Description.Println
)
View Source 
var DefaultSpinner = Spinner{
	Sequence:       []string{"▀ ", " ▀", " ▄", "▄ "},
	Style:          Style{FgLightCyan},
	Delay:          time.Millisecond * 200,
	MessageStyle:   Style{FgLightWhite},
	SuccessPrinter: Success,
	FailPrinter:    Error,
	WarningPrinter: Warning,
}

DefaultSpinner is the default spinner

View Source 
var (
	// ErrTerminalSizeNotDetectable - the terminal size can not be detected and the fallback values are used
	ErrTerminalSizeNotDetectable = errors.New("terminal size could not be detected - using fallback value")
)
View Source 
var FallbackTerminalHeight = 10

FallbackTerminalHeight is the value used for GetTerminalHeight, if the actual height can not be detected You can override that value if necessary.

View Source 
var FallbackTerminalWidth = 80

FallbackTerminalWidth is the value used for GetTerminalWidth, if the actual width can not be detected You can override that value if necessary.

View Source 
var (
	// GrayBoxStyle wraps text in a gray box
	GrayBoxStyle = NewStyle(BgGray, FgLightWhite)
)

Functions

func Fprinto added in v0.1.0 

func Fprinto(w io.Writer, a ...interface{})

Fprinto prints Printo to a custom writer.

func GetTerminalHeight added in v0.1.0 

func GetTerminalHeight() int

GetTerminalHeight returns the terminal height of the active terminal

func GetTerminalSize added in v0.1.0 

func GetTerminalSize() (width int, height int, err error)

GetTerminalSize returns the width and the height of the active terminal

func GetTerminalWidth added in v0.1.0 

func GetTerminalWidth() int

GetTerminalWidth returns the terminal width of the active terminal

func Printo added in v0.1.0 

func Printo(a ...interface{})

Printo overrides the current line in a terminal. If the current line is empty, the text will be printed like with pterm.Print. To create a new line, which Example: pterm.Printo("Hello, World") time.Sleep(time.Second) pterm.Oprint("Hello, Earth!")

Types

type Color 

type Color uint8

Color is a number which will be used to color strings in the terminal 

const (
	FgBlack Color = iota + 30
	FgRed
	FgGreen
	FgYellow
	FgBlue
	FgMagenta
	FgCyan
	FgWhite
	// FgDefault revert default FG
	FgDefault Color = 39
)

Foreground colors. basic foreground colors 30 - 37 

const (
	FgDarkGray Color = iota + 90 // 亮黑（灰）
	FgLightRed
	FgLightGreen
	FgLightYellow
	FgLightBlue
	FgLightMagenta
	FgLightCyan
	FgLightWhite
	// FgGray is an alias of FgDarkGray
	FgGray Color = 90
)

Extra foreground color 90 - 97(非标准) 

const (
	BgBlack Color = iota + 40
	BgRed
	BgGreen
	BgYellow // BgBrown like yellow
	BgBlue
	BgMagenta
	BgCyan
	BgWhite
	// BgDefault reverts to the default background
	BgDefault Color = 49
)

Background colors. basic background colors 40 - 47 

const (
	BgDarkGray Color = iota + 100
	BgLightRed
	BgLightGreen
	BgLightYellow
	BgLightBlue
	BgLightMagenta
	BgLightCyan
	BgLightWhite
	// BgGray is an alias of BgDarkGray
	BgGray Color = 100
)

Extra background color 100 - 107(非标准) 

const (
	Reset Color = iota
	Bold
	Fuzzy
	Italic
	Underscore
	Blink
	FastBlink
	Reverse
	Concealed
	Strikethrough
)

Option settings

func (Color) Print 

func (c Color) Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color

func (Color) Printf 

func (c Color) Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color

func (Color) Println 

func (c Color) Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color

func (Color) Sprint 

func (c Color) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Color

func (Color) Sprintf 

func (c Color) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Color

func (Color) Sprintln 

func (c Color) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Color

func (Color) String 

func (c Color) String() string

String converts the color to a string. eg "35"

type GenericPrinter 

type GenericPrinter interface {
	// Sprint formats using the default formats for its operands and returns the resulting string.
	// Spaces are added between operands when neither is a string.
	Sprint(a ...interface{}) string

	// Sprintln formats using the default formats for its operands and returns the resulting string.
	// Spaces are always added between operands and a newline is appended.
	Sprintln(a ...interface{}) string

	// Sprintf formats according to a format specifier and returns the resulting string.
	Sprintf(format string, a ...interface{}) string

	// Print formats using the default formats for its operands and writes to standard output.
	// Spaces are added between operands when neither is a string.
	// It returns the number of bytes written and any write error encountered.
	Print(a ...interface{}) GenericPrinter

	// Println formats using the default formats for its operands and writes to standard output.
	// Spaces are always added between operands and a newline is appended.
	// It returns the number of bytes written and any write error encountered.
	Println(a ...interface{}) GenericPrinter

	// Printf formats according to a format specifier and writes to standard output.
	// It returns the number of bytes written and any write error encountered.
	Printf(format string, a ...interface{}) GenericPrinter
}

GenericPrinter contains methods to print formatted text to the console or return it as a string

type HeaderPrinter added in v0.0.1 

type HeaderPrinter struct {
	TextStyle       Style
	BackgroundStyle Style
	Margin          int
	FullWidth       bool
}

HeaderPrinter contains the data used to craft a header. A header is printed as a big box with text in it. Can be used as title screens or section separator.

func (HeaderPrinter) Print added in v0.0.1 

func (p HeaderPrinter) Print(a ...interface{}) GenericPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Printf added in v0.0.1 

func (p HeaderPrinter) Printf(format string, a ...interface{}) GenericPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Println added in v0.0.1 

func (p HeaderPrinter) Println(a ...interface{}) GenericPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Sprint added in v0.0.1 

func (p HeaderPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (HeaderPrinter) Sprintf added in v0.0.1 

func (p HeaderPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (HeaderPrinter) Sprintln added in v0.0.1 

func (p HeaderPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (HeaderPrinter) WithBackgroundStyle added in v0.1.0 

func (p HeaderPrinter) WithBackgroundStyle(colors ...Color) *HeaderPrinter

WithBackgroundStyle changes the background styling of the header.

func (HeaderPrinter) WithFullWidth added in v0.1.0 

func (p HeaderPrinter) WithFullWidth() *HeaderPrinter

WithFullWidth enables full width on a HeaderPrinter

func (HeaderPrinter) WithMargin added in v0.1.0 

func (p HeaderPrinter) WithMargin(margin int) *HeaderPrinter

WithMargin changes the background styling of the header.

func (HeaderPrinter) WithTextStyle added in v0.1.0 

func (p HeaderPrinter) WithTextStyle(colors ...Color) *HeaderPrinter

WithTextStyle changes the text styling of the header.

type Prefix 

type Prefix struct {
	Text  string
	Style Style
}

Prefix contains the data used as the beginning of a printed text via a PrefixPrinter

type PrefixPrinter 

type PrefixPrinter struct {
	Prefix       Prefix
	Scope        Scope
	MessageStyle Style
}

PrefixPrinter is the printer used to print a Prefix

func (PrefixPrinter) GetFormattedMessage 

func (p PrefixPrinter) GetFormattedMessage(a ...interface{}) string

GetFormattedMessage returns the message as a styled text string

func (PrefixPrinter) GetFormattedPrefix 

func (p PrefixPrinter) GetFormattedPrefix() string

GetFormattedPrefix returns the Prefix as a styled text string

func (PrefixPrinter) Print 

func (p PrefixPrinter) Print(a ...interface{}) GenericPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (PrefixPrinter) Printf 

func (p PrefixPrinter) Printf(format string, a ...interface{}) GenericPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (PrefixPrinter) Println 

func (p PrefixPrinter) Println(a ...interface{}) GenericPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (PrefixPrinter) Sprint 

func (p PrefixPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (PrefixPrinter) Sprintf 

func (p PrefixPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (PrefixPrinter) Sprintln 

func (p PrefixPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (PrefixPrinter) WithMessageStyle added in v0.1.0 

func (p PrefixPrinter) WithMessageStyle(prefix Prefix) *PrefixPrinter

WithMessageStyle adds a custom prefix to the printer

func (PrefixPrinter) WithPrefix added in v0.1.0 

func (p PrefixPrinter) WithPrefix(prefix Prefix) *PrefixPrinter

WithPrefix adds a custom prefix to the printer

func (PrefixPrinter) WithScope 

func (p PrefixPrinter) WithScope(scope string, colors ...Color) *PrefixPrinter

WithScope adds a scope to the Prefix

type Scope 

type Scope struct {
	Text  string
	Style Style
}

Scope contains the data of the optional scope of a prefix. If it has a text, it will be printed after the Prefix in brackets.

type Spinner added in v0.1.0 

type Spinner struct {
	Text           string
	Sequence       []string
	Style          Style
	Delay          time.Duration
	MessageStyle   Style
	SuccessPrinter GenericPrinter
	FailPrinter    GenericPrinter
	WarningPrinter GenericPrinter

	IsActive bool
}

Spinner is a loading animation, which can be used if the progress is unknown. It's an animation loop, which can have a text and supports throwing errors or warnings. A GenericPrinter is used to display all outputs, after the spinner is done.

func (*Spinner) Fail added in v0.1.0 

func (s *Spinner) Fail(message ...interface{})

Fail displays the fail printer. If no message is given, the text of the spinner will be reused as the default message.

func (*Spinner) Start added in v0.1.0 

func (s *Spinner) Start(text ...interface{}) *Spinner

Start starts the spinner

func (*Spinner) Stop added in v0.1.0 

func (s *Spinner) Stop()

Stop terminates the Spinner immediately. The Spinner will not resolve into anything.

func (*Spinner) Success added in v0.1.0 

func (s *Spinner) Success(message ...interface{})

Success displays the success printer. If no message is given, the text of the spinner will be reused as the default message.

func (*Spinner) Warning added in v0.1.0 

func (s *Spinner) Warning(message ...interface{})

Warning displays the warning printer. If no message is given, the text of the spinner will be reused as the default message.

func (Spinner) WithDelay added in v0.1.0 

func (s Spinner) WithDelay(delay time.Duration) *Spinner

WithDelay adds a delay to the spinner

func (Spinner) WithMessageStyle added in v0.1.0 

func (s Spinner) WithMessageStyle(colors ...Color) *Spinner

WithMessageStyle adds a style to the spinner message

func (Spinner) WithSequence added in v0.1.0 

func (s Spinner) WithSequence(sequence ...string) *Spinner

WithSequence adds a sequence to the spinner

func (Spinner) WithStyle added in v0.1.0 

func (s Spinner) WithStyle(colors ...Color) *Spinner

WithStyle adds a style to the spinner

func (Spinner) WithText added in v0.1.0 

func (s Spinner) WithText(text string) *Spinner

WithText adds a text to the spinner

type Style 

type Style []Color

Style is a collection of colors. Can include foreground, background and styling (eg. Bold, Underscore, etc.) colors.

func NewStyle added in v0.0.1 

func NewStyle(colors ...Color) Style

NewStyle returns a new Style. Accepts multiple colors.

func (Style) Code 

func (s Style) Code() string

Code convert to code string. returns like "32;45;3"

func (Style) Print 

func (s Style) Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style

func (Style) Printf 

func (s Style) Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style

func (Style) Println 

func (s Style) Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style

func (Style) Sprint 

func (s Style) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Style

func (Style) Sprintf 

func (s Style) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Style

func (Style) Sprintln 

func (s Style) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Style

func (Style) String 

func (s Style) String() string

String convert to code string. returns like "32;45;3"

Source Files

View all Source files

Directories

Path Synopsis
_examples
demo command
override-default-printer command
print-header command
print-with-color command
spinner command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.