GitHub - goforj/str: A fluent, Laravel-inspired string toolkit for Go with explicit, rune-safe helpers and predictable behavior.

A fluent, Laravel-inspired string toolkit for Go, focused on rune-safe helpers, expressive transformations, and predictable behavior beyond the standard library.

Installation

go get github.com/goforj/str

Runnable examples

Every function has a corresponding runnable example under ./examples.

These examples are generated directly from the documentation blocks of each function, ensuring the docs and code never drift. These are the same examples you see here in the README and GoDoc.

An automated test executes every example to verify it builds and runs successfully.

This guarantees all examples are valid, up-to-date, and remain functional as the API evolves.

API Index

Group	Functions
Affixes	ChopEnd ChopStart EnsurePrefix EnsureSuffix Unwrap Wrap
Case	Camel Headline Kebab LcFirst Pascal Snake Title ToLower ToTitle ToUpper UcFirst UcWords
Checks	IsASCII IsBlank IsEmpty
Cleanup	Deduplicate Squish Trim TrimLeft TrimRight
Comparison	Equals EqualsFold
Compose	Append NewLine Prepend
Encoding	FromBase64 ToBase64
Fluent	GoString Of String
Length	Len RuneCount
Masking	Mask
Match	Is IsMatch
Padding	PadBoth PadLeft PadRight
Replace	Remove ReplaceAll ReplaceArray ReplaceFirst ReplaceLast ReplaceMatches Swap
Search	Contains ContainsAll ContainsAllFold ContainsFold Count DoesntContain DoesntContainFold DoesntEndWith DoesntEndWithFold DoesntStartWith DoesntStartWithFold EndsWith EndsWithFold Index LastIndex StartsWith StartsWithFold
Slug	Slug
Snippet	Excerpt
Split	Split UcSplit
Substrings	After AfterLast Before BeforeLast Between BetweenFirst CharAt Limit Slice Take TakeLast
Transform	Repeat Reverse
Words	FirstWord Join LastWord SplitWords WordCount Words WrapWords

Affixes

ChopEnd

ChopEnd removes the first matching suffix if present.

v := str.Of("file.txt").ChopEnd(".txt", ".md").String()
godump.Dump(v)
// #string file

ChopStart

ChopStart removes the first matching prefix if present.

v := str.Of("https://goforj.dev").ChopStart("https://", "http://").String()
godump.Dump(v)
// #string goforj.dev

EnsurePrefix

EnsurePrefix ensures the string starts with prefix, adding it if missing.

v := str.Of("path/to").EnsurePrefix("/").String()
godump.Dump(v)
// #string /path/to

EnsureSuffix

EnsureSuffix ensures the string ends with suffix, adding it if missing.

v := str.Of("path/to").EnsureSuffix("/").String()
godump.Dump(v)
// #string path/to/

Unwrap

Unwrap removes matching before and after strings if present.

v := str.Of("\"GoForj\"").Unwrap("\"", "\"").String()
godump.Dump(v)
// #string GoForj

Wrap

Wrap surrounds the string with before and after (after defaults to before).

v := str.Of("GoForj").Wrap("\"", "").String()
godump.Dump(v)
// #string "GoForj"

Case

Camel

Camel converts the string to camelCase.

v := str.Of("foo_bar baz").Camel().String()
godump.Dump(v)
// #string fooBarBaz

Headline

Headline converts the string into a human-friendly headline: splits on case/underscores/dashes/whitespace, title-cases words, and lowercases small words (except the first).

v := str.Of("emailNotification_sent").Headline().String()
godump.Dump(v)
// #string Email Notification Sent

Kebab

Kebab converts the string to kebab-case.

v := str.Of("fooBar baz").Kebab().String()
godump.Dump(v)
// #string foo-bar-baz

LcFirst

LcFirst returns the string with the first rune lower-cased.

v := str.Of("Gopher")
godump.Dump(v)
// #string gopher

Pascal

Pascal converts the string to PascalCase.

v := str.Of("foo_bar baz")
godump.Dump(v)
// #string FooBarBaz

Snake

Snake converts the string to snake_case using the provided separator (default "_").

v := str.Of("fooBar baz").Snake("_").String()
godump.Dump(v)
// #string foo_bar_baz

Title

Title converts the string to title case (first letter of each word upper, rest lower) using Unicode rules.

v := str.Of("a nice title uses the correct case").Title().String()
godump.Dump(v)
// #string A Nice Title Uses The Correct Case

ToLower

ToLower returns a lowercase copy of the string using Unicode rules.

v := str.Of("GoLang").ToLower().String()
godump.Dump(v)
// #string golang

ToTitle

ToTitle returns a title-cased copy where all letters are mapped using Unicode title case.

v := str.Of("ß").ToTitle().String()
godump.Dump(v)
// #string SS

ToUpper

ToUpper returns an uppercase copy of the string using Unicode rules.

v := str.Of("GoLang").ToUpper().String()
godump.Dump(v)
// #string GOLANG

UcFirst

UcFirst returns the string with the first rune upper-cased.

v := str.Of("gopher").UcFirst().String()
godump.Dump(v)
// #string Gopher

UcWords

UcWords uppercases the first rune of each word, leaving the rest unchanged. Words are sequences of letters/digits.

v := str.Of("hello WORLD").UcWords().String()
godump.Dump(v)
// #string Hello WORLD

Checks

IsASCII

IsASCII reports whether the string consists solely of 7-bit ASCII runes.

v := str.Of("gopher").IsASCII()
godump.Dump(v)
// #bool true

IsBlank

IsBlank reports whether the string contains only Unicode whitespace.

v := str.Of("  \\t\\n")
godump.Dump(v.IsBlank())
// #bool true

IsEmpty

IsEmpty reports whether the string has zero length.

v := str.Of("").IsEmpty()
godump.Dump(v)
// #bool true

Cleanup

Deduplicate

Deduplicate collapses consecutive instances of char into a single instance. If char is zero, space is used.

v := str.Of("The   Go   Playground").Deduplicate(' ').String()
godump.Dump(v)
// #string The Go Playground

Squish

Squish trims leading/trailing whitespace and collapses internal whitespace to single spaces.

v := str.Of("   go   forj  ").Squish().String()
godump.Dump(v)
// #string go forj

Trim

Trim trims leading and trailing characters. If cutset is empty, trims Unicode whitespace.

v := str.Of("  GoForj  ").Trim("").String()
godump.Dump(v)
// #string GoForj

TrimLeft

TrimLeft trims leading characters. If cutset is empty, trims Unicode whitespace.

v := str.Of("  GoForj  ").TrimLeft("").String()
godump.Dump(v)
// #string GoForj

TrimRight

TrimRight trims trailing characters. If cutset is empty, trims Unicode whitespace.

v := str.Of("  GoForj  ").TrimRight("").String()
godump.Dump(v)
// #string   GoForj

Comparison

Equals

Equals reports whether the string exactly matches other (case-sensitive).

v := str.Of("gopher").Equals("gopher")
godump.Dump(v)
// #bool true

EqualsFold

EqualsFold reports whether the string matches other using Unicode case folding.

v := str.Of("gopher").EqualsFold("GOPHER")
godump.Dump(v)
// #bool true

Compose

Append

Append concatenates the provided parts to the end of the string.

v := str.Of("Go").Append("Forj", "!").String()
godump.Dump(v)
// #string GoForj!

NewLine

NewLine appends a newline character to the string.

v := str.Of("hello").NewLine().Append("world").String()
godump.Dump(v)
// #string hello\nworld

Prepend

Prepend concatenates the provided parts to the beginning of the string.

v := str.Of("World").Prepend("Hello ", "Go ").String()
godump.Dump(v)
// #string Hello Go World

Encoding

FromBase64

FromBase64 decodes a standard Base64 string.

v, err := str.Of("Z29waGVy").FromBase64()
godump.Dump(v.String(), err)
// #string gopher
// #error <nil>

ToBase64

ToBase64 encodes the string using standard Base64.

v := str.Of("gopher").ToBase64().String()
godump.Dump(v)
// #string Z29waGVy

Fluent

GoString

GoString allows %#v formatting to print the raw string.

v := str.Of("go")
godump.Dump(fmt.Sprintf("%#v", v))
// #string go

Of

Of wraps a raw string with fluent helpers.

v := str.Of("gopher")
godump.Dump(v.String())
// #string gopher

String

String returns the underlying raw string value.

v := str.Of("go").String()
godump.Dump(v)
// #string go

Length

Len

Len returns the number of runes in the string.

v := str.Of("gophers 🦫").Len()
godump.Dump(v)
// #int 9

RuneCount

RuneCount is an alias for Len to make intent explicit in mixed codebases.

v := str.Of("naïve").RuneCount()
godump.Dump(v)
// #int 5

Masking

Mask

Mask replaces the middle of the string with the given rune, revealing revealLeft runes at the start and revealRight runes at the end. Negative reveal values count from the end. If the reveal counts cover the whole string, the original string is returned.

v := str.Of("[email protected]").Mask('*', 3, 4).String()
godump.Dump(v)
// #string gop***********.com

Match

Is

Is reports whether the string matches any of the provided wildcard patterns. Patterns use '*' as a wildcard. Case-sensitive.

v := str.Of("foo/bar").Is("foo/*")
godump.Dump(v)
// #bool true

IsMatch

IsMatch reports whether the string matches the provided regular expression.

v := str.Of("abc123").IsMatch(regexp.MustCompile(`\d+`))
godump.Dump(v)
// #bool true

Padding

PadBoth

PadBoth pads the string on both sides to reach length runes using pad (defaults to space).

v := str.Of("go").PadBoth(6, "-").String()
godump.Dump(v)
// #string --go--

PadLeft

PadLeft pads the string on the left to reach length runes using pad (defaults to space).

v := str.Of("go").PadLeft(5, " ").String()
godump.Dump(v)
// #string \u00a0\u00a0\u00a0go

PadRight

PadRight pads the string on the right to reach length runes using pad (defaults to space).

v := str.Of("go").PadRight(5, ".").String()
godump.Dump(v)
// #string go...

Replace

Remove

Remove deletes all occurrences of provided substrings.

v := str.Of("The Go Toolkit").Remove("Go ").String()
godump.Dump(v)
// #string The Toolkit

ReplaceAll

ReplaceAll replaces all occurrences of old with new in the string. If old is empty, the original string is returned unchanged.

v := str.Of("go gopher go").ReplaceAll("go", "Go").String()
godump.Dump(v)
// #string Go Gopher Go

ReplaceArray

ReplaceArray replaces all occurrences of each old in olds with repl.

v := str.Of("The---Go---Toolkit")
godump.Dump(v.ReplaceArray([]string{"---"}, "-").String())
// #string The-Go-Toolkit

ReplaceFirst

ReplaceFirst replaces the first occurrence of old with repl.

v := str.Of("gopher gopher").ReplaceFirst("gopher", "go").String()
godump.Dump(v)
// #string go gopher

ReplaceLast

ReplaceLast replaces the last occurrence of old with repl.

v := str.Of("gopher gopher").ReplaceLast("gopher", "go").String()
godump.Dump(v)
// #string gopher go

ReplaceMatches

ReplaceMatches applies repl to each regex match and returns the result.

re := regexp.MustCompile(`\d+`)
v := str.Of("Hello 123 World").ReplaceMatches(re, func(m string) string { return "[" + m + "]" }).String()
godump.Dump(v)
// #string Hello [123] World

Swap

Swap replaces multiple values using strings.Replacer built from a map.

pairs := map[string]string{"Gophers": "GoForj", "are": "is", "great": "fantastic"}
v := str.Of("Gophers are great!").Swap(pairs).String()
godump.Dump(v)
// #string GoForj is fantastic!

Search

Contains

Contains reports whether the string contains any of the provided substrings (case-sensitive). Empty substrings return true to match strings.Contains semantics.

v := str.Of("Go means gophers").Contains("rust", "gopher")
godump.Dump(v)
// #bool true

ContainsAll

ContainsAll reports whether the string contains all provided substrings (case-sensitive). Empty substrings are ignored.

v := str.Of("Go means gophers").ContainsAll("Go", "gopher")
godump.Dump(v)
// #bool true

ContainsAllFold

ContainsAllFold reports whether the string contains all provided substrings, using Unicode case folding for comparisons. Empty substrings are ignored.

v := str.Of("Go means gophers").ContainsAllFold("go", "GOPHER")
godump.Dump(v)
// #bool true

ContainsFold

ContainsFold reports whether the string contains any of the provided substrings, using Unicode case folding for comparisons. Empty substrings return true.

v := str.Of("Go means gophers").ContainsFold("GOPHER", "rust")
godump.Dump(v)
// #bool true

Count

Count returns the number of non-overlapping occurrences of sub.

v := str.Of("gogophergo").Count("go")
godump.Dump(v)
// #int 3

DoesntContain

DoesntContain reports true if none of the substrings are found (case-sensitive). Empty substrings are ignored.

v := str.Of("gophers are great")
godump.Dump(v.DoesntContain("rust", "beam"))
// #bool true

DoesntContainFold

DoesntContainFold reports true if none of the substrings are found using Unicode case folding. Empty substrings are ignored.

v := str.Of("gophers are great")
godump.Dump(v.DoesntContainFold("GOPHER"))
// #bool false

DoesntEndWith

DoesntEndWith reports true if the string ends with none of the provided suffixes (case-sensitive).

v := str.Of("gopher")
godump.Dump(v.DoesntEndWith("her", "cat"))
// #bool false

DoesntEndWithFold

DoesntEndWithFold reports true if the string ends with none of the provided suffixes using Unicode case folding.

v := str.Of("gopher")
godump.Dump(v.DoesntEndWithFold("HER"))
// #bool false

DoesntStartWith

DoesntStartWith reports true if the string starts with none of the provided prefixes (case-sensitive).

v := str.Of("gopher")
godump.Dump(v.DoesntStartWith("go", "rust"))
// #bool false

DoesntStartWithFold

DoesntStartWithFold reports true if the string starts with none of the provided prefixes using Unicode case folding.

v := str.Of("gopher")
godump.Dump(v.DoesntStartWithFold("GO"))
// #bool false

EndsWith

EndsWith reports whether the string ends with any of the provided suffixes (case-sensitive).

v := str.Of("gopher").EndsWith("her", "cat")
godump.Dump(v)
// #bool true

EndsWithFold

EndsWithFold reports whether the string ends with any of the provided suffixes using Unicode case folding.

v := str.Of("gopher").EndsWithFold("HER")
godump.Dump(v)
// #bool true

Index

Index returns the rune index of the first occurrence of sub, or -1 if not found.

v := str.Of("héllo").Index("llo")
godump.Dump(v)
// #int 2

LastIndex

LastIndex returns the rune index of the last occurrence of sub, or -1 if not found.

v := str.Of("go gophers go").LastIndex("go")
godump.Dump(v)
// #int 10

StartsWith

StartsWith reports whether the string starts with any of the provided prefixes (case-sensitive).

v := str.Of("gopher").StartsWith("go", "rust")
godump.Dump(v)
// #bool true

StartsWithFold

StartsWithFold reports whether the string starts with any of the provided prefixes using Unicode case folding.

v := str.Of("gopher").StartsWithFold("GO")
godump.Dump(v)
// #bool true

Slug

Slug produces an ASCII slug using the provided separator (default "-"), stripping accents where possible. Not locale-aware; intended for identifiers/URLs.

v := str.Of("Go Forj Toolkit").Slug("-").String()
godump.Dump(v)
// #string go-forj-toolkit

Snippet

Excerpt

Excerpt returns a snippet around the first occurrence of needle with the given radius. If needle is not found, an empty string is returned. If radius <= 0, a default of 100 is used. Omission is used at the start/end when text is trimmed (default "...").

v := str.Of("This is my name").Excerpt("my", 3, "...")
godump.Dump(v.String())
// #string ...is my na...

Split

Split splits the string by the given separator.

v := str.Of("a,b,c").Split(",")
godump.Dump(v)
// #[]string [a b c]

UcSplit

UcSplit splits the string on uppercase boundaries and delimiters, returning segments.

v := str.Of("HTTPRequestID").UcSplit()
godump.Dump(v)
// #[]string [HTTP Request ID]

Substrings

After

After returns the substring after the first occurrence of sep. If sep is empty or not found, the original string is returned.

v := str.Of("gopher::go").After("::").String()
godump.Dump(v)
// #string go

AfterLast

AfterLast returns the substring after the last occurrence of sep. If sep is empty or not found, the original string is returned.

v := str.Of("pkg/path/file.txt").AfterLast("/").String()
godump.Dump(v)
// #string file.txt

Before

Before returns the substring before the first occurrence of sep. If sep is empty or not found, the original string is returned.

v := str.Of("gopher::go").Before("::").String()
godump.Dump(v)
// #string gopher

BeforeLast

BeforeLast returns the substring before the last occurrence of sep. If sep is empty or not found, the original string is returned.

v := str.Of("pkg/path/file.txt").BeforeLast("/").String()
godump.Dump(v)
// #string pkg/path

Between

Between returns the substring between the first occurrence of start and the last occurrence of end. Returns an empty string if either marker is missing or overlapping.

v := str.Of("This is my name").Between("This", "name").String()
godump.Dump(v)
// #string  is my

BetweenFirst

BetweenFirst returns the substring between the first occurrence of start and the first occurrence of end after it. Returns an empty string if markers are missing.

v := str.Of("[a] bc [d]").BetweenFirst("[", "]").String()
godump.Dump(v)
// #string a

CharAt

CharAt returns the rune at the given index and true if within bounds.

v, ok := str.Of("gopher").CharAt(2)
godump.Dump(string(v), ok)
// #string p
// #bool true

Limit

Limit truncates the string to length runes, appending suffix if truncation occurs.

v := str.Of("Perfectly balanced, as all things should be.").Limit(10, "...").String()
godump.Dump(v)
// #string Perfectly...

Slice

Slice returns the substring between rune offsets [start:end). Indices are clamped; if start >= end the result is empty.

v := str.Of("naïve café").Slice(3, 7).String()
godump.Dump(v)
// #string e ca

Take

Take returns the first length runes of the string (clamped).

v := str.Of("gophers").Take(3).String()
godump.Dump(v)
// #string gop

TakeLast

TakeLast returns the last length runes of the string (clamped).

v := str.Of("gophers").TakeLast(4).String()
godump.Dump(v)
// #string hers

Transform

Repeat

Repeat repeats the string count times (non-negative).

v := str.Of("go").Repeat(3).String()
godump.Dump(v)
// #string gogogo

Reverse

Reverse returns a rune-safe reversed string.

v := str.Of("naïve").Reverse().String()
godump.Dump(v)
// #string evïan

Words

FirstWord

FirstWord returns the first word token or empty string.

v := str.Of("Hello world")
godump.Dump(v.FirstWord().String())
// #string Hello

Join

Join joins the provided words with sep.

v := str.Of("unused").Join([]string{"foo", "bar"}, "-").String()
godump.Dump(v)
// #string foo-bar

LastWord

LastWord returns the last word token or empty string.

v := str.Of("Hello world").LastWord().String()
godump.Dump(v)
// #string world

SplitWords

SplitWords splits the string into words (Unicode letters/digits runs).

v := str.Of("one, two, three").SplitWords()
godump.Dump(v)
// #[]string [one two three]

WordCount

WordCount returns the number of word tokens (letters/digits runs).

v := str.Of("Hello, world!").WordCount()
godump.Dump(v)
// #int 2