fmt, Strings and Text Processing

package main

import (
	"bytes"
	"fmt"
	"os"
	"strings"
)

func main() {
	// Print adds spaces between operands when neither is a string.
	fmt.Print("shelf", 3, 4, "books", "\n")
	fmt.Print(3, 4, "\n")
	// Println always separates operands with a space and appends a newline.
	fmt.Println("shelf", 3, 4, "books")

	// Sprint* return a string, Fprint* write to an io.Writer,
	// Append* append to a []byte and return the extended slice.
	s := fmt.Sprintf("%s has %d copies", "Dune", 3)
	fmt.Println(s)

	n, err := fmt.Fprintf(os.Stdout, "%-6s|\n", "Dune")
	fmt.Println("wrote", n, "bytes, err =", err)

	var sb strings.Builder
	fmt.Fprintf(&sb, "%03d-%s", 7, "x")
	fmt.Println(sb.String())

	var buf bytes.Buffer
	fmt.Fprintln(&buf, "line one")
	fmt.Fprint(&buf, "line", " ", "two")
	fmt.Printf("%q\n", buf.String())

	b := make([]byte, 0, 32)
	b = fmt.Append(b, "id=", 42)
	b = fmt.Appendf(b, " ok=%t", true)
	b = fmt.Appendln(b, " done")
	fmt.Printf("%q\n", b)

	// Fprintln to os.Stderr is the usual way to report problems.
	fmt.Fprintln(os.Stderr, "shelf: this goes to standard error")
}

shelf3 4books
3 4
shelf 3 4 books
Dune has 3 copies
Dune  |
wrote 8 bytes, err = <nil>
007-x
"line one\nline two"
"id=42 ok=true done\n"
shelf: this goes to standard error

package main

import (
	"fmt"
	"time"
)

type ISBN string

type Author struct{ Name string }

type Book struct {
	ISBN    ISBN
	Title   string
	Authors []Author
	Pages   int
	Rating  *float64
	Tags    map[string]bool
}

func main() {
	rating := 4.5
	b := Book{
		ISBN:    "9780441172719",
		Title:   "Dune",
		Authors: []Author{{"Frank Herbert"}},
		Pages:   412,
		Rating:  &rating,
		Tags:    map[string]bool{"scifi": true, "classic": true},
	}
	b2 := b
	b2.Rating = nil

	fmt.Printf("%%v   %v\n", b2)
	fmt.Printf("%%+v  %+v\n", b2)
	fmt.Printf("%%#v  %#v\n", b2)
	fmt.Printf("%%T   %T\n", b2)
	fmt.Printf("%%T   %T %T %T %T\n", 1, "s", 2.5, []any{nil})
	fmt.Printf("%%v of a pointer to struct: %v\n", &Author{"Ursula K. Le Guin"})
	fmt.Printf("%%+v of a pointer to struct: %+v\n", &Author{"Ursula K. Le Guin"})
	fmt.Printf("%%v of nil pointer, error, map, slice: %v %v %v %v\n", (*int)(nil), error(nil), map[string]int(nil), []int(nil))
	fmt.Printf("%%#v of those: %#v %#v %#v %#v\n", (*int)(nil), error(nil), map[string]int(nil), []int(nil))
	fmt.Printf("%%v of a duration and a time: %v | %v\n", 90*time.Minute, time.Date(2026, 10, 18, 9, 30, 0, 0, time.UTC))
	fmt.Printf("%%v of a byte slice and a string slice: %v %v\n", []byte("hi"), []string{"a", "b c"})
	fmt.Printf("%%q of the string slice: %q\n", []string{"a", "b c"})
	fmt.Printf("%%d %%x of the byte slice: %d %x\n", []byte("hi"), []byte("hi"))
}

%v   {9780441172719 Dune [{Frank Herbert}] 412 <nil> map[classic:true scifi:true]}
%+v  {ISBN:9780441172719 Title:Dune Authors:[{Name:Frank Herbert}] Pages:412 Rating:<nil> Tags:map[classic:true scifi:true]}
%#v  main.Book{ISBN:"9780441172719", Title:"Dune", Authors:[]main.Author{main.Author{Name:"Frank Herbert"}}, Pages:412, Rating:(*float64)(nil), Tags:map[string]bool{"classic":true, "scifi":true}}
%T   main.Book
%T   int string float64 []interface {}
%v of a pointer to struct: &{Ursula K. Le Guin}
%+v of a pointer to struct: &{Name:Ursula K. Le Guin}
%v of nil pointer, error, map, slice: <nil> <nil> map[] []
%#v of those: (*int)(nil) <nil> map[string]int(nil) []int(nil)
%v of a duration and a time: 1h30m0s | 2026-10-18 09:30:00 +0000 UTC
%v of a byte slice and a string slice: [104 105] [a b c]
%q of the string slice: ["a" "b c"]
%d %x of the byte slice: [104 105] 6869

package main

import "fmt"

func main() {
	// integers
	n := 255
	fmt.Printf("[%d] [%5d] [%-5d] [%05d] [%+d] [% d]\n", n, n, n, n, n, n)
	fmt.Printf("[%b] [%o] [%O] [%x] [%X] [%#x] [%#o] [%#b]\n", n, n, n, n, n, n, n, n)
	fmt.Printf("[%c] [%U] [%#U] [%q]\n", 'é', 'é', 'é', 'é')
	fmt.Printf("[%08.3f] [%+.2e] [%g] [%G]\n", 3.14159, 12345.678, 1e21, 1e-7)
	fmt.Printf("[%6.2f] [%-8.1f] [%.0f] [%.3g]\n", 3.14159, 2.5, 2.5, 1234.5678)
	fmt.Printf("[%v] [%v] [%v]\n", 1e6, 1e21, float32(0.1))

	// strings
	s := "Dune"
	fmt.Printf("[%s] [%10s] [%-10s] [%.2s] [%10.2s] [%q] [%x] [% x] [%X]\n", s, s, s, s, s, s, s, s, s)
	fmt.Printf("[%5t] [%-7t]\n", true, false)

	// width and precision from arguments
	fmt.Printf("[%*d] [%-*d] [%.*f]\n", 6, 42, 6, 42, 2, 3.14159)

	// explicit argument indexes
	fmt.Printf("%[2]s %[1]s %[2]s\n", "world", "hello")
	fmt.Printf("%[1]d in binary is %[1]b and in hex is %#[1]x\n", 42)
	fmt.Printf("%[3]*.[2]*[1]f|\n", 12.0, 2, 8)

	// a table, the usual use of width
	rows := []struct {
		Title string
		Pages int
		Price float64
	}{{"Dune", 412, 9.99}, {"Solaris", 204, 7.5}, {"Neuromancer", 271, 8.25}}
	fmt.Printf("%-12s %5s %8s\n", "Title", "Pages", "Price")
	for _, r := range rows {
		fmt.Printf("%-12s %5d %8.2f\n", r.Title, r.Pages, r.Price)
	}

	// width counts runes, not bytes, for strings
	fmt.Printf("[%-6s] [%-6s]\n", "日本", "ab")
}

[255] [  255] [255  ] [00255] [+255] [ 255]
[11111111] [377] [0o377] [ff] [FF] [0xff] [0377] [0b11111111]
[é] [U+00E9] [U+00E9 'é'] ['é']
[0003.142] [+1.23e+04] [1e+21] [1E-07]
[  3.14] [2.5     ] [2] [1.23e+03]
[1e+06] [1e+21] [0.1]
[Dune] [      Dune] [Dune      ] [Du] [        Du] ["Dune"] [44756e65] [44 75 6e 65] [44756E65]
[ true] [false  ]
[    42] [42    ] [3.14]
hello world hello
42 in binary is 101010 and in hex is 0x2a
   12.00|
Title        Pages    Price
Dune           412     9.99
Solaris        204     7.50
Neuromancer    271     8.25
[日本    ] [ab    ]

package main

import "fmt"

func main() {
	fmt.Println(fmt.Sprintf("%d", "Dune"))
	fmt.Println(fmt.Sprintf("%s", 42))
	fmt.Println(fmt.Sprintf("%d %d", 1))
	fmt.Println(fmt.Sprintf("%d", 1, 2))
	fmt.Println(fmt.Sprintf("%z", 1))
	fmt.Println(fmt.Sprintf("%*d", "w", 1))
	fmt.Println(fmt.Sprintf("%[3]d", 1, 2))
	fmt.Println(fmt.Sprintf("%s %d", nil, nil))
}

%!d(string=Dune)
%!s(int=42)
1 %!d(MISSING)
1%!(EXTRA int=2)
%!z(int=1)
%!(BADWIDTH)1
%!d(BADINDEX)
%!s(<nil>) %!d(<nil>)

e/badverbs/main.go:6:27: fmt.Sprintf format %d has arg "Dune" of wrong type string
e/badverbs/main.go:7:27: fmt.Sprintf format %s has arg 42 of wrong type int
e/badverbs/main.go:8:30: fmt.Sprintf format %d reads arg #2, but call has 1 arg
e/badverbs/main.go:9:14: fmt.Sprintf call needs 1 arg but has 2 args
e/badverbs/main.go:10:27: fmt.Sprintf format %z has unknown verb z
e/badverbs/main.go:11:27: fmt.Sprintf format %*d uses non-int "w" as argument of *
e/badverbs/main.go:12:27: fmt.Sprintf format %[3]d reads arg #3, but call has 2 args
e/badverbs/main.go:13:27: fmt.Sprintf format %s has arg nil of wrong type untyped nil

package main

import (
	"fmt"
	"os"
)

type Node struct {
	Name string
	Next *Node
}

func main() {
	n := &Node{"a", nil}
	fmt.Printf("%v %+v\n", n, n) // only the top-level pointer is dereferenced
	m := &Node{"b", n}
	fmt.Println(m.Next == n, fmt.Sprintf("%v", m) == fmt.Sprintf("&{b %p}", n))
	fmt.Printf("%#v\n", *n)

	x := 42
	p := &x
	fmt.Println(p == &x, fmt.Sprintf("%p", p) == fmt.Sprint(p), fmt.Sprintf("%v", p)[:2])

	// Verbs on collections apply element by element.
	fmt.Printf("%v %03d %x %q\n", []int{1, 2}, []int{1, 2}, []string{"hi", "yo"}, []string{"hi", "yo"})
	fmt.Printf("%v %+v\n", map[string][]int{"b": {2}, "a": {1}}, struct {
		A int
		B *int
	}{1, nil})

	// Floating point verbs.
	f := 1234.5678
	fmt.Printf("%v %g %e %.1f %8.3f|%-8.1f|%x\n", f, f, f, f, f, f, 1.0)

	// Runes are integers: %d shows the number, %c the character.
	r := 'é'
	fmt.Printf("%d %c %q %U %x\n", r, r, r, r, r)
	fmt.Println(r, string(r))

	// Print vs Println spacing differences.
	fmt.Print("a", "b", 1, 2, true, "c", "\n")
	fmt.Print(1, 2, "\n")

	fmt.Fprintf(os.Stdout, "%6.2f%%\n", 45.678)
	var e error
	fmt.Printf("%v\n", e)
	var ip *int
	fmt.Printf("%v %d\n", ip, ip)
	var a any = 3
	fmt.Printf("%v %T %5v|%-5v|\n", a, a, a, a)
	type pair struct{ a, b any }
	fmt.Printf("%v %+v\n", pair{1, "x"}, pair{nil, []byte("y")})
}

&{a <nil>} &{Name:a Next:<nil>}
true true
main.Node{Name:"a", Next:(*main.Node)(nil)}
true true 0x
[1 2] [001 002] [6869 796f] ["hi" "yo"]
map[a:[1] b:[2]] {A:1 B:<nil>}
1234.5678 1234.5678 1.234568e+03 1234.6 1234.568|1234.6  |0x1p+00
233 é 'é' U+00E9 e9
233 é
ab1 2 truec
1 2
 45.68%
<nil>
<nil> 0
3 int     3|3    |
{1 x} {a:<nil> b:[121]}

package main

import "fmt"

type LoanState int

// String is wrong: Sprintf with %s on the receiver calls String again.
func (s LoanState) String() string { return fmt.Sprintf("state %s", s) }

// Fixed converts to the underlying type first, so fmt sees a plain int.
type Fixed int

func (f Fixed) String() string { return fmt.Sprintf("fixed %d", int(f)) }

func main() {
	fmt.Println(Fixed(3))
	_ = LoanState(1) // calling LoanState.String would overflow the stack
}

e/recurse/main.go:8:64: fmt.Sprintf format %s with arg s causes recursive (example.com/shelf/e/recurse.LoanState).String method call

package main

import (
	"fmt"
	"strings"
)

type Money struct {
	Cents int64
	Cur   string
}

// Format implements fmt.Formatter. It honours width, the '-' and '+' flags
// and the verbs v and s, hands the integer verbs to the cents, and reports
// any other verb the way fmt does.
func (m Money) Format(f fmt.State, verb rune) {
	switch verb {
	case 'v', 's':
		sign := ""
		c := m.Cents
		if c < 0 {
			sign, c = "-", -c
		} else if f.Flag('+') {
			sign = "+"
		}
		out := fmt.Sprintf("%s%d.%02d %s", sign, c/100, c%100, m.Cur)
		if f.Flag('#') && verb == 'v' {
			out = fmt.Sprintf("Money{%d, %q}", m.Cents, m.Cur)
		}
		if w, ok := f.Width(); ok && len(out) < w {
			pad := strings.Repeat(" ", w-len(out))
			if f.Flag('-') {
				out += pad
			} else {
				out = pad + out
			}
		}
		fmt.Fprint(f, out)
	case 'd', 'x', 'X', 'o', 'b':
		// Reconstruct the directive (flags, width, precision, verb) and apply it to the cents.
		fmt.Fprintf(f, fmt.FormatString(f, verb), m.Cents)
	default:
		fmt.Fprintf(f, "%%!%c(Money=%d)", verb, m.Cents)
	}
}

func main() {
	m := Money{1999, "EUR"}
	fmt.Printf("[%v] [%+v] [%14v] [%-14s] [%d] [%#v] [%x] [%08d] [%q]\n", m, m, m, m, m, m, m, m, m)
	fmt.Println(Money{-250, "EUR"})
}

[19.99 EUR] [+19.99 EUR] [     19.99 EUR] [19.99 EUR     ] [1999] [Money{1999, "EUR"}] [7cf] [00001999] [%!q(Money=1999)]
-2.50 EUR

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Cut splits around the first occurrence of a separator.
	key, value, found := strings.Cut("isbn=9780441172719", "=")
	fmt.Printf("%q %q %v\n", key, value, found)
	before, after, found := strings.Cut("no separator here", "=")
	fmt.Printf("%q %q %v\n", before, after, found)

	// CutLast (Go 1.27) splits around the last occurrence.
	dir, file, ok := strings.CutLast("data/shelf/books.json", "/")
	fmt.Printf("%q %q %v\n", dir, file, ok)
	name, ext, ok := strings.CutLast("archive.tar.gz", ".")
	fmt.Printf("%q %q %v\n", name, ext, ok)
	// The first-occurrence version gives a different answer.
	name, ext, _ = strings.Cut("archive.tar.gz", ".")
	fmt.Printf("%q %q\n", name, ext)

	// CutPrefix and CutSuffix report whether the affix was present.
	rest, ok := strings.CutPrefix("Bearer fake-token-123", "Bearer ")
	fmt.Printf("%q %v\n", rest, ok)
	rest, ok = strings.CutPrefix("Basic fake", "Bearer ")
	fmt.Printf("%q %v\n", rest, ok)
	base, ok := strings.CutSuffix("report.csv", ".csv")
	fmt.Printf("%q %v\n", base, ok)

	// TrimPrefix cannot tell you whether it trimmed anything, and Trim takes a cutset.
	fmt.Println(strings.TrimPrefix("xxfoo", "x"), strings.Trim("xxfooxx", "x"), strings.TrimLeft("xyxfoo", "xy"))
	fmt.Println(strings.TrimSpace("\t shelf \n"), strings.TrimFunc("123abc456", func(r rune) bool { return r >= '0' && r <= '9' }))
}

"isbn" "9780441172719" true
"no separator here" "" false
"data/shelf" "books.json" true
"archive.tar" "gz" true
"archive" "tar.gz"
"fake-token-123" true
"Basic fake" false
"report" true
xfoo foo foo
shelf abc

main.go:9:27: strings.CutLast requires go1.27 or later (module is go1.26)

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "Dune,Herbert,,1965"
	fmt.Printf("%q\n", strings.Split(csv, ","))
	fmt.Printf("%q\n", strings.SplitN(csv, ",", 2))
	fmt.Printf("%q\n", strings.SplitAfter(csv, ","))
	fmt.Printf("%q\n", strings.Split("abc", ""))
	fmt.Printf("%q\n", strings.Split("", ","))

	// Fields splits around runs of white space and never returns empty strings.
	ws := "  Dune \t Solaris\n\nNeuromancer  "
	fmt.Printf("%q\n", strings.Fields(ws))
	fmt.Printf("%q\n", strings.Split(ws, " "))
	fmt.Printf("%q\n", strings.FieldsFunc("a1b22c333", func(r rune) bool { return r >= '0' && r <= '9' }))

	// Join is the inverse of Split; Repeat and Map round off the basics.
	fmt.Println(strings.Join([]string{"a", "b", "c"}, " > "))
	fmt.Println(strings.Repeat("=-", 5))
	fmt.Println(strings.Map(func(r rune) rune {
		if r == '-' {
			return -1 // drop the rune
		}
		return r
	}, "978-0-441-17271-9"))

	// Searching.
	s := "the shelf holds the books"
	fmt.Println(strings.Contains(s, "shelf"), strings.ContainsAny(s, "xyz"), strings.ContainsRune(s, 'h'))
	fmt.Println(strings.Index(s, "the"), strings.LastIndex(s, "the"), strings.IndexByte(s, 'h'), strings.IndexAny(s, "ob"), strings.Index(s, "zzz"))
	fmt.Println(strings.Count(s, "the"), strings.Count("five", ""), strings.HasPrefix(s, "the"), strings.HasSuffix(s, "books"))
	fmt.Println(strings.EqualFold("Straße", "STRASSE"), strings.EqualFold("Go", "GO"), strings.Compare("a", "b"))
	fmt.Println(strings.ToUpper("shelf é"), strings.ToLower("SHELF É"), strings.ToTitle("shelf"))
	fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2), strings.ReplaceAll("oink oink", "oink", "moo"))
}

["Dune" "Herbert" "" "1965"]
["Dune" "Herbert,,1965"]
["Dune," "Herbert," "," "1965"]
["a" "b" "c"]
[""]
["Dune" "Solaris" "Neuromancer"]
["" "" "Dune" "\t" "Solaris\n\nNeuromancer" "" ""]
["a" "b" "c"]
a > b > c
=-=-=-=-=-
9780441172719
true false true
0 16 1 11 -1
2 5 true true
false true -1
SHELF É shelf é SHELF
oinky oinky oink moo moo

package main

import (
	"fmt"
	"strings"
	"testing"
)

var titles = []string{"Dune", "Solaris", "Neuromancer", "Hyperion", "Foundation", "Ubik", "Kindred", "Dawn"}

func concat(n int) string {
	s := ""
	for i := range n {
		s += titles[i%len(titles)] + ", "
	}
	return s
}

func builder(n int) string {
	var sb strings.Builder
	for i := range n {
		sb.WriteString(titles[i%len(titles)])
		sb.WriteString(", ")
	}
	return sb.String()
}

func presized(n int) string {
	var sb strings.Builder
	sb.Grow(n * 14) // a good estimate avoids every reallocation
	for i := range n {
		sb.WriteString(titles[i%len(titles)])
		sb.WriteString(", ")
	}
	return sb.String()
}

func main() {
	const n = 1000
	for _, f := range []struct {
		name string
		fn   func(int) string
	}{{"s += ...", concat}, {"Builder", builder}, {"Builder+Grow", presized}} {
		allocs := testing.AllocsPerRun(20, func() { _ = f.fn(n) })
		fmt.Printf("%-13s %7.0f allocations for %d appends\n", f.name, allocs, n)
	}

	var sb strings.Builder
	sb.WriteByte('[')
	sb.WriteRune('é')
	fmt.Fprintf(&sb, "%03d", 7)
	sb.WriteByte(']')
	fmt.Println(sb.String(), sb.Len())
	sb.Reset()
	fmt.Println(sb.Len())

	// strings.Join does the sizing for you when you already have a slice.
	fmt.Println(strings.Join(titles[:3], ", "))
}

s += ...         1000 allocations for 1000 appends
Builder            15 allocations for 1000 appends
Builder+Grow        1 allocations for 1000 appends
[é007] 7
0
Dune, Solaris, Neuromancer

package main

import (
	"fmt"
	"html"
	"os"
	"strings"
	"unicode/utf8"
)

func main() {
	// A Replacer makes all replacements in a single pass over the input.
	r := strings.NewReplacer("<", "&lt;", ">", "&gt;", "&", "&amp;")
	fmt.Println(r.Replace("if a < b && c > d"))
	fmt.Println(html.EscapeString("if a < b && c > d"))

	// Replacements do not rescan their own output, unlike chained ReplaceAll calls.
	swap := strings.NewReplacer("a", "b", "b", "a")
	fmt.Println(swap.Replace("abba"), strings.ReplaceAll(strings.ReplaceAll("abba", "a", "b"), "b", "a"))

	// WriteString writes straight to a Writer.
	r.WriteString(os.Stdout, "<done>\n")

	// Clone detaches a substring from a large backing string.
	big := strings.Repeat("x", 1<<20) + "needle"
	small := big[len(big)-6:]
	owned := strings.Clone(small)
	fmt.Println(small == owned, len(owned), utf8.RuneCountInString(owned))
}

if a < b && c > d
if a < b && c > d
baab aaaa
<done>
true 6 6

package main

import (
	"fmt"
	"slices"
	"strings"
)

func main() {
	csv := "Dune,Herbert,1965"
	for part := range strings.SplitSeq(csv, ",") {
		fmt.Printf("%q ", part)
	}
	fmt.Println()

	// Lines yields each line including its terminator.
	text := "first\nsecond\r\nthird"
	for line := range strings.Lines(text) {
		fmt.Printf("%q ", line)
	}
	fmt.Println()

	for f := range strings.FieldsSeq("  Dune  Solaris \t Ubik ") {
		fmt.Print("<", f, "> ")
	}
	fmt.Println()

	for part := range strings.SplitAfterSeq("a.b.c", ".") {
		fmt.Printf("%q ", part)
	}
	fmt.Println()

	for f := range strings.FieldsFuncSeq("a1b22c", func(r rune) bool { return r >= '0' && r <= '9' }) {
		fmt.Printf("%q ", f)
	}
	fmt.Println()

	// Iterators compose with the slices package and stop early without building a slice.
	words := slices.Collect(strings.FieldsSeq("one two three four"))
	fmt.Println(words, len(words))
	for w := range strings.FieldsSeq("one two three four") {
		if w == "two" {
			fmt.Println("stopped at", w)
			break
		}
	}
	longest := slices.MaxFunc(words, func(a, b string) int { return len(a) - len(b) })
	fmt.Println(longest)
}

"Dune" "Herbert" "1965"
"first\n" "second\r\n" "third"
<Dune> <Solaris> <Ubik>
"a." "b." "c"
"a" "b" "c"
[one two three four] 4
stopped at two
three

package main

import (
	"fmt"
	"strconv"
)

func main() {
	s := "tab\there \"quoted\" é 日本 \x00 \xff"
	fmt.Println(strconv.Quote(s))
	fmt.Println(strconv.QuoteToASCII(s))
	fmt.Println(strconv.QuoteToGraphic("a\tb"))
	fmt.Println(strconv.QuoteRune('☺'), strconv.QuoteRuneToASCII('☺'))
	fmt.Println(strconv.CanBackquote("plain text"), strconv.CanBackquote("has `tick"))

	// Unquote accepts Go string literals: interpreted, raw and rune forms.
	for _, lit := range []string{`"a\tb"`, "`raw\\n`", `'x'`, `"unterminated`, `noquotes`} {
		u, err := strconv.Unquote(lit)
		fmt.Printf("%-16s -> %q %v\n", lit, u, err)
	}

	// QuotedPrefix (Go 1.17) returns the leading quoted string of its argument.
	p, err := strconv.QuotedPrefix(`"title" rest of the line`)
	fmt.Printf("%s %v\n", p, err)

	// %q uses the same rules as Quote.
	fmt.Printf("%q %+q %#q\n", "é\n", "é\n", "plain")
}

"tab\there \"quoted\" é 日本 \x00 \xff"
"tab\there \"quoted\" \u00e9 \u65e5\u672c \x00 \xff"
"a\tb"
'☺' '\u263a'
true false
"a\tb"           -> "a\tb" <nil>
`raw\n`          -> "raw\\n" <nil>
'x'              -> "x" <nil>
"unterminated    -> "" invalid syntax
noquotes         -> "" invalid syntax
"title" <nil>
"é\n" "\u00e9\n" `plain`

package main

import (
	"fmt"
	"regexp"
)

// Compile once, at package level; a *Regexp is safe for concurrent use.
var isbnRE = regexp.MustCompile(`^(?:97[89])-?\d{1,5}-?\d+-?\d+-?\d$`)

var loanRE = regexp.MustCompile(`(?P<isbn>\d{13}) lent to (?P<member>\w+) on (?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)`)

func main() {
	fmt.Println(isbnRE.MatchString("978-0-441-17271-9"), isbnRE.MatchString("12345"))

	const log = "9780441172719 lent to ana on 2026-10-18; 9780553283686 lent to bob on 2026-10-19"

	// Find* functions: String/[]byte, All, Index, Submatch variants.
	fmt.Println(loanRE.FindString(log))
	fmt.Println(loanRE.FindStringIndex(log))
	fmt.Printf("%q\n", loanRE.FindStringSubmatch(log))
	fmt.Println(loanRE.FindAllStringSubmatchIndex(log, -1))
	for _, m := range loanRE.FindAllStringSubmatch(log, -1) {
		fmt.Println(m[loanRE.SubexpIndex("member")], m[loanRE.SubexpIndex("year")])
	}
	fmt.Println(loanRE.NumSubexp(), loanRE.SubexpNames())

	// Replace*: $1, ${name} expand submatches; a literal $ needs $$; ReplaceAllLiteral does no expansion.
	fmt.Println(loanRE.ReplaceAllString(log, "${member}: ${day}/${month}/${year}"))
	fmt.Println(loanRE.ReplaceAllString(log, "$member_x"), "<- $member_x is the (empty) group named member_x")
	fmt.Println(loanRE.ReplaceAllLiteralString(log, "[$1]"))
	fmt.Println(loanRE.ReplaceAllStringFunc(log, func(m string) string { return fmt.Sprint(len(m), " bytes") }))

	// Expand builds output from a template and one match.
	var out []byte
	m := loanRE.FindStringSubmatchIndex(log)
	out = loanRE.ExpandString(out, "$member borrowed $isbn\n", log, m)
	fmt.Print(string(out))

	// Split with a regular expression.
	sep := regexp.MustCompile(`\s*[,;]\s*`)
	fmt.Printf("%q\n", sep.Split("a , b;c ;  d", -1))

	// Flags: (?i) case-insensitive, (?s) dot matches newline, (?m) multi-line, (?U) ungreedy.
	fmt.Println(regexp.MustCompile(`(?i)dune`).FindString("DUNE and dune"))
	fmt.Printf("%q %q\n", regexp.MustCompile(`a.+b`).FindString("aXbXb"), regexp.MustCompile(`a.+?b`).FindString("aXbXb"))
	fmt.Printf("%q\n", regexp.MustCompile(`(?m)^\w+`).FindAllString("one two\nthree four", -1))

	// QuoteMeta escapes user input so it can be embedded in a pattern.
	user := "a.b*c"
	fmt.Println(regexp.QuoteMeta(user), regexp.MustCompile(regexp.QuoteMeta(user)).MatchString("aXbbc"))

	// Compile returns an error instead of panicking.
	_, err := regexp.Compile(`(unclosed`)
	fmt.Println(err)
	_, err = regexp.Compile(`(?<=a)b`)
	fmt.Println(err)
	_, err = regexp.Compile(`(a)\1`)
	fmt.Println(err)
	prefix, complete := regexp.MustCompile(`shelf-\d+`).LiteralPrefix()
	fmt.Println(isbnRE.String(), prefix, complete)
}

true false
9780441172719 lent to ana on 2026-10-18
[0 39]
["9780441172719 lent to ana on 2026-10-18" "9780441172719" "ana" "2026" "10" "18"]
[[0 39 0 13 22 25 29 33 34 36 37 39] [41 80 41 54 63 66 70 74 75 77 78 80]]
ana 2026
bob 2026
5 [ isbn member year month day]
ana: 18/10/2026; bob: 19/10/2026
;  <- $member_x is the (empty) group named member_x
[$1]; [$1]
39 bytes; 39 bytes
ana borrowed 9780441172719
["a" "b" "c" "d"]
DUNE
"aXbXb" "aXb"
["one" "three"]
a\.b\*c false
error parsing regexp: missing closing ): `(unclosed`
error parsing regexp: invalid named capture: `(?<=a)b`
error parsing regexp: invalid escape sequence: `\1`
^(?:97[89])-?\d{1,5}-?\d+-?\d+-?\d$ shelf- false

package main

import (
	"fmt"
	"regexp"
)

func main() {
	for _, p := range []string{`a{1001}`, `(?=x)`, `(a)\1`, `*a`, `[z-a]`, `(?i)(?<year>\d{4})`, `\Qa.b\E`, `[[:alpha:]]+`, `a**`} {
		_, err := regexp.Compile(p)
		fmt.Printf("%-18s %v\n", p, err)
	}
}

a{1001}            error parsing regexp: invalid repeat count: `{1001}`
(?=x)              error parsing regexp: invalid or unsupported Perl syntax: `(?=`
(a)\1              error parsing regexp: invalid escape sequence: `\1`
*a                 error parsing regexp: missing argument to repetition operator: `*`
[z-a]              error parsing regexp: invalid character class range: `z-a`
(?i)(?<year>\d{4}) <nil>
\Qa.b\E            <nil>
[[:alpha:]]+       <nil>
a**                error parsing regexp: invalid nested repetition operator: `**`

package main

import (
	"fmt"
	"regexp"
	"strings"
	"time"
)

func main() {
	// The classic catastrophic pattern for a backtracking engine.
	re := regexp.MustCompile(`^(a+)+$`)
	for _, n := range []int{20, 200, 20000} {
		input := strings.Repeat("a", n) + "!"
		start := time.Now()
		ok := re.MatchString(input)
		took := time.Since(start)
		fmt.Printf("n=%-6d matched=%-5v fast=%v\n", n, ok, took < 2*time.Second)
	}

	// Leftmost-first (Perl-like) versus leftmost-longest (POSIX) semantics.
	s := "abcd"
	fmt.Println(regexp.MustCompile(`a|ab|abc`).FindString(s))
	fmt.Println(regexp.MustCompilePOSIX(`a|ab|abc`).FindString(s))
	long := regexp.MustCompile(`a|ab|abc`)
	long.Longest()
	fmt.Println(long.FindString(s))

	// An empty match is possible; All functions skip an empty match adjacent to a previous match.
	fmt.Printf("%q\n", regexp.MustCompile(`a*`).FindAllString("baaab", -1))

	// Unicode classes and word boundaries (ASCII only for \b and \w).
	fmt.Println(regexp.MustCompile(`\p{Greek}+`).FindString("alpha = αβγ"))
	fmt.Println(regexp.MustCompile(`\w+`).FindAllString("café naïve", -1))
	fmt.Println(regexp.MustCompile(`[\p{L}]+`).FindAllString("café naïve", -1))
	fmt.Println(regexp.MustCompile(`\bgo\b`).MatchString("go!"), regexp.MustCompile(`\bgo\b`).MatchString("gopher"))
}

n=20     matched=false fast=true
n=200    matched=false fast=true
n=20000  matched=false fast=true
a
abc
abc
["" "aaa" ""]
αβγ
[caf na ve]
[café naïve]
true false