stringcase

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Aug 12, 2026 License: MIT Imports: 1 Imported by: 1

README

stringcase Release Go Reference CI Status MIT License

This library provides some functions that convert string cases between Ada_Case, camelCase, COBOL-CASE, kebab-case, MACRO_CASE, PascalCase, snake_case, Title Case, and Train-Case. In addition, the functions Capitalize, Lowerize, and Upperize are provided to convert string cases with a custom joiner character.

Essentially, these functions only target ASCII uppercase and lowercase letters for capitalization. All characters other than ASCII uppercase and lowercase letters and ASCII numbers are removed as word separators.

If you want to use some symbols as separators, specify those symbols in the Separators field of Options struct and use the 〜CaseWithOptions function for the desired case. If you want to retain certain symbols and use everything else as separators, specify those symbols in Keep field of Options struct and use the 〜CaseWithOptions function for the desired case.

Additionally, you can specify whether to place word boundaries before and/or after non-alphabetic characters with conversion options. This can be set using the SeparateBeforeNonAlphabets and SeparateAfterNonAlphabets fields in the Options struct.

The 〜Case functions that do not take Options as an argument only place word boundaries after non-alphabetic characters. In other words, they behave as if SeparateBeforeNonAlphabets = false and SeparateAfterNonAlphabets = true.

Install

To get the latest version of this package, run the following command:

go get github.com/sttk/stringcase

To get a specific version of this package, run the following command:

go get github.com/sttk/stringcase@v1.0.0

Usage

The functions contained in this library are executed as follows:

func main() {
    input := "fooBar123Bar"
    snake := stringcase.SnakeCase(input)
    fmt.Printf("%s\n", snake)
    // => "foo_bar123_baz"
}

If you want the conversion to behave differently, use 〜CaseWithOptions.

func main() {
    opts := stringcase.Options{
        SeparateBeforeNonAlphabets: true,
        SeparateAfterNonAlphabets:  true,
    }
    input := "fooBar123Bar"
    snake := stringcase.SnakeCaseWithOptions(input, opts)
    fmt.Printf("%s\n", snake)
    // => "foo_bar_123_baz"
}

You can also use the functions Capitalize, Lowerize, and Upperize to convert strings into capitalized, lowercased, or uppercased words joined by a custom joiner character:

func main() {
    opts := stringcase.Options{
        SeparateBeforeNonAlphabets: true,
        SeparateAfterNonAlphabets:  true,
    }
    input := "fooBar123Bar"
    output := stringcase.Capitalize(input, '.', opts)
    fmt.Printf("%s\n", output)
    // => "Foo.Bar.123.Baz"
}

Supporting Go versions

This library supports Go 1.18 or later.

Actual test results for each Go version:
% go-fav -tags=github.sttk.errs.notify 1.26.2 1.25.9 1.24.13 1.23.12 1.20.14 \
         -ldflags="-linkmode=external" 1.22.12 1.21.13 1.19.13 1.18.10
go version go1.26.2 darwin/amd64
ok  	github.com/sttk/stringcase	0.585s	coverage: 100.0% of statements

go version go1.25.9 darwin/amd64
ok  	github.com/sttk/stringcase	0.540s	coverage: 100.0% of statements

go version go1.24.13 darwin/amd64
ok  	github.com/sttk/stringcase	0.535s	coverage: 100.0% of statements

go version go1.23.12 darwin/amd64
ok  	github.com/sttk/stringcase	0.349s	coverage: 100.0% of statements

go version go1.20.14 darwin/amd64
ok  	github.com/sttk/stringcase	0.345s	coverage: 100.0% of statements

go version go1.22.12 darwin/amd64
ok  	github.com/sttk/stringcase	0.534s	coverage: 100.0% of statements

go version go1.21.13 darwin/amd64
ok  	github.com/sttk/stringcase	0.534s	coverage: 100.0% of statements

go version go1.19.13 darwin/amd64
# github.com/sttk/stringcase.test
ld: warning: '***/go.o' has malformed LC_DYSYMTAB, expected 62 undefined symbols to start at index 8649, found 72 undefined symbols starting at index 64
ok  	github.com/sttk/stringcase	0.509s	coverage: 100.0% of statements

go version go1.18.10 darwin/amd64
# github.com/sttk/stringcase.test
ld: warning: '***/go.o' has malformed LC_DYSYMTAB, expected 59 undefined symbols to start at index 8513, found 69 undefined symbols starting at index 65
ok  	github.com/sttk/stringcase	0.513s	coverage: 100.0% of statements

License

Copyright (C) 2024-2026 Takayuki Sato

This program is free software under MIT License.
See the file LICENSE in this distribution for more details.

Documentation

Overview

This library provides some functions that convert string cases between Ada_Case, camelCase, COBOL-CASE, kebab-case, MACRO_CASE, PascalCase, snake_case, Title Case, and Train-Case. In addition, the functions Capitalize, Lowerize, and Upperize are provided to convert string cases with a custom joiner character.

Essentially, these functions only target ASCII uppercase and lowercase letters for capitalization. All characters other than ASCII uppercase and lowercase letters and ASCII numbers are removed as word separators.

If you want to use some symbols as separators, specify those symbols in the Separators field of Options struct and use the 〜CaseWithOptions function for the desired case. If you want to retain certain symbols and use everything else as separators, specify those symbols in Keep field of Options struct and use the 〜CaseWithOptions function for the desired case.

Additionally, you can specify whether to place word boundaries before and/or after non-alphabetic characters with conversion options. This can be set using the SeparateBeforeNonAlphabets and SeparateAfterNonAlphabets fields in the Options struct.

The 〜Case functions that do not take Options as an argument only place word boundaries after non-alphabetic characters. In other words, they behave as if SeparateBeforeNonAlphabets = false and SeparateAfterNonAlphabets = true.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AdaCase added in v1.0.0 

func AdaCase(input string) string

AdaCase converts the input string to ada case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	ada := stringcase.AdaCase("fooBarBaz")
	fmt.Printf("(1) ada = %s\n", ada)

	ada = stringcase.AdaCase("foo-Bar100baz")
	fmt.Printf("(2) ada = %s\n", ada)
}

Output:
(1) ada = Foo_Bar_Baz
(2) ada = Foo_Bar100_Baz

func AdaCaseWithOptions added in v1.0.0 

func AdaCaseWithOptions(input string, opts Options) string

AdaCaseWithOptions converts the input string to Ada case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	ada := stringcase.AdaCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) ada = %s\n\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) ada = %s\n\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) ada = %s\n", ada)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	ada = stringcase.AdaCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) ada = %s\n", ada)
}

Output:
(1) ada = Foo_Bar100_Baz
(2) ada = Foo_Bar_100_Baz
(3) ada = Foo_Bar_100baz
(4) ada = Foo_Bar100baz

(5) ada = Foo_Bar100%_Baz
(6) ada = Foo_Bar_100%_Baz
(7) ada = Foo_Bar_100%baz
(8) ada = Foo_Bar100%baz

(9) ada = Foo_Bar100%_Baz
(a) ada = Foo_Bar_100%_Baz
(b) ada = Foo_Bar_100%baz
(c) ada = Foo_Bar100%baz

func CamelCase 

func CamelCase(input string) string

CamelCase converts the input string to camel case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	camel := stringcase.CamelCase("foo_bar_baz")
	fmt.Printf("(1) camel = %s\n", camel)

	camel = stringcase.CamelCase("foo-Bar100baz")
	fmt.Printf("(2) camel = %s\n", camel)
}

Output:
(1) camel = fooBarBaz
(2) camel = fooBar100Baz

func CamelCaseWithOptions added in v0.3.0 

func CamelCaseWithOptions(input string, opts Options) string

CamelCaseWithOptions converts the input string to camel case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	camel := stringcase.CamelCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) camel = %s\n\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) camel = %s\n\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) camel = %s\n", camel)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	camel = stringcase.CamelCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) camel = %s\n", camel)
}

Output:
(1) camel = fooBar100Baz
(2) camel = fooBar100Baz
(3) camel = fooBar100baz
(4) camel = fooBar100baz

(5) camel = fooBar100%Baz
(6) camel = fooBar100%Baz
(7) camel = fooBar100%baz
(8) camel = fooBar100%baz

(9) camel = fooBar100%Baz
(a) camel = fooBar100%Baz
(b) camel = fooBar100%baz
(c) camel = fooBar100%baz

func Capitalize added in v1.0.0 

func Capitalize(input string, joiner rune, opts Options) string

Capitalize converts the input string by capitalizing the first ASCII letter of each word and lowercasing subsequent letters, inserting the specified joiner rune between word boundaries according to the given options. It serves as a core engine for transforming input strings into capitalized casing styles, such as Train-Case or PascalCase, using custom joiner runes and customizable word separation rules defined in Options.

During conversion, the initial ASCII letter of each word is converted to ASCII uppercase, while subsequent ASCII letters in that word are converted to ASCII lowercase. Word boundaries are automatically recognized at casing transitions, such as between lowercase and uppercase letters or before the final uppercase letter of an acronym preceding a lowercase sequence. When non-alphanumeric characters are encountered, ASCII digits are kept by default, while other characters are evaluated against Options. If opts.Separators is non-empty, characters matching opts.Separators are removed as separators while other non-alphanumeric characters are kept; otherwise, if opts.Keep is non-empty, specified characters are kept and all other non-alphanumeric characters are removed. If neither is specified, all non-alphanumeric characters are treated as separators and removed. The fields opts.SeparateBeforeNonAlphabets and opts.SeparateAfterNonAlphabets further determine whether word boundaries are inserted before or after non-alphabetic sequences.

This function never returns an error or panics on any input, returning an empty string when the input is empty. Casing transformations and word boundary detections apply strictly to ASCII letters, treating non-ASCII characters as non-alphanumeric. If both opts.Separators and opts.Keep are specified, opts.Separators takes precedence and opts.Keep is ignored, while any alphanumeric characters listed in either field are disregarded. Additionally, leading and trailing separator characters are trimmed from the result without producing leading or trailing joiners.

func CobolCase 

func CobolCase(input string) string

CobolCase converts the input string to cobol case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	cobol := stringcase.CobolCase("fooBarBaz")
	fmt.Printf("(1) cobol = %s\n", cobol)

	cobol = stringcase.CobolCase("foo-Bar100baz")
	fmt.Printf("(2) cobol = %s\n", cobol)
}

Output:
(1) cobol = FOO-BAR-BAZ
(2) cobol = FOO-BAR100-BAZ

func CobolCaseWithOptions added in v0.3.0 

func CobolCaseWithOptions(input string, opts Options) string

CobolCaseWithOptions converts the input string to cobol case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	cobol := stringcase.CobolCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) cobol = %s\n\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) cobol = %s\n\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) cobol = %s\n", cobol)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	cobol = stringcase.CobolCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) cobol = %s\n", cobol)
}

Output:
(1) cobol = FOO-BAR100-BAZ
(2) cobol = FOO-BAR-100-BAZ
(3) cobol = FOO-BAR-100BAZ
(4) cobol = FOO-BAR100BAZ

(5) cobol = FOO-BAR100%-BAZ
(6) cobol = FOO-BAR-100%-BAZ
(7) cobol = FOO-BAR-100%BAZ
(8) cobol = FOO-BAR100%BAZ

(9) cobol = FOO-BAR100%-BAZ
(a) cobol = FOO-BAR-100%-BAZ
(b) cobol = FOO-BAR-100%BAZ
(c) cobol = FOO-BAR100%BAZ

func KebabCase 

func KebabCase(input string) string

KebabCase converts the input string to kebab case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	kebab := stringcase.KebabCase("fooBarBaz")
	fmt.Printf("(1) kebab = %s\n", kebab)

	kebab = stringcase.KebabCase("foo-Bar100baz")
	fmt.Printf("(2) kebab = %s\n", kebab)
}

Output:
(1) kebab = foo-bar-baz
(2) kebab = foo-bar100-baz

func KebabCaseWithOptions added in v0.3.0 

func KebabCaseWithOptions(input string, opts Options) string

KebabCaseWithOptions converts the input string to kebab case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	kebab := stringcase.KebabCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) kebab = %s\n\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) kebab = %s\n\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) kebab = %s\n", kebab)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	kebab = stringcase.KebabCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) kebab = %s\n", kebab)
}

Output:
(1) kebab = foo-bar100-baz
(2) kebab = foo-bar-100-baz
(3) kebab = foo-bar-100baz
(4) kebab = foo-bar100baz

(5) kebab = foo-bar100%-baz
(6) kebab = foo-bar-100%-baz
(7) kebab = foo-bar-100%baz
(8) kebab = foo-bar100%baz

(9) kebab = foo-bar100%-baz
(a) kebab = foo-bar-100%-baz
(b) kebab = foo-bar-100%baz
(c) kebab = foo-bar100%baz

func Lowerize added in v1.0.0 

func Lowerize(input string, joiner rune, opts Options) string

Lowerize converts all ASCII alphabetic characters in the input string to lowercase, inserting the specified joiner rune between word boundaries according to the given options. It serves as a core engine for transforming input strings into lowercase-based casing styles, such as snake_case or kebab-case, using custom joiner runes and customizable word separation rules defined in Options.

During conversion, all ASCII uppercase letters are converted to ASCII lowercase letters, and word boundaries are automatically recognized between casing transitions, such as between lowercase and uppercase letters or before the final uppercase letter of an acronym preceding a lowercase sequence. When non-alphanumeric characters are encountered, ASCII digits are kept by default, while other characters are evaluated against Options. If opts.Separators is non-empty, characters matching opts.Separators are removed as separators while other non-alphanumeric characters are kept; otherwise, if opts.Keep is non-empty, specified characters are kept and all other non-alphanumeric characters are removed. If neither is specified, all non-alphanumeric characters are treated as separators and removed. The fields opts.SeparateBeforeNonAlphabets and opts.SeparateAfterNonAlphabets further determine whether word boundaries are inserted before or after non-alphabetic sequences.

This function never returns an error or panics on any input, returning an empty string when the input is empty. Casing transformations and word boundary detections apply strictly to ASCII letters, treating non-ASCII characters as non-alphanumeric. If both opts.Separators and opts.Keep are specified, opts.Separators takes precedence and opts.Keep is ignored, while any alphanumeric characters listed in either field are disregarded. Additionally, leading and trailing separator characters are trimmed from the result without producing leading or trailing joiners.

func MacroCase 

func MacroCase(input string) string

MacroCase converts the input string to macro case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	macro := stringcase.MacroCase("fooBarBaz")
	fmt.Printf("(1) macro = %s\n", macro)

	macro = stringcase.MacroCase("foo-Bar100baz")
	fmt.Printf("(2) macro = %s\n", macro)
}

Output:
(1) macro = FOO_BAR_BAZ
(2) macro = FOO_BAR100_BAZ

func MacroCaseWithOptions added in v0.3.0 

func MacroCaseWithOptions(input string, opts Options) string

MacroCaseWithOptions converts the input string to macro case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	macro := stringcase.MacroCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) macro = %s\n\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) macro = %s\n\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) macro = %s\n", macro)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	macro = stringcase.MacroCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) macro = %s\n", macro)
}

Output:
(1) macro = FOO_BAR100_BAZ
(2) macro = FOO_BAR_100_BAZ
(3) macro = FOO_BAR_100BAZ
(4) macro = FOO_BAR100BAZ

(5) macro = FOO_BAR100%_BAZ
(6) macro = FOO_BAR_100%_BAZ
(7) macro = FOO_BAR_100%BAZ
(8) macro = FOO_BAR100%BAZ

(9) macro = FOO_BAR100%_BAZ
(a) macro = FOO_BAR_100%_BAZ
(b) macro = FOO_BAR_100%BAZ
(c) macro = FOO_BAR100%BAZ

func PascalCase 

func PascalCase(input string) string

PascalCase converts the input string to pascal case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	pascal := stringcase.PascalCase("foo_bar_baz")
	fmt.Printf("(1) pascal = %s\n", pascal)

	pascal = stringcase.PascalCase("foo-Bar100baz")
	fmt.Printf("(2) pascal = %s\n", pascal)
}

Output:
(1) pascal = FooBarBaz
(2) pascal = FooBar100Baz

func PascalCaseWithOptions added in v0.3.0 

func PascalCaseWithOptions(input string, opts Options) string

PascalCaseWithOptions converts the input string to pascal case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	pascal := stringcase.PascalCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) pascal = %s\n\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) pascal = %s\n\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) pascal = %s\n", pascal)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	pascal = stringcase.PascalCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) pascal = %s\n", pascal)
}

Output:
(1) pascal = FooBar100Baz
(2) pascal = FooBar100Baz
(3) pascal = FooBar100baz
(4) pascal = FooBar100baz

(5) pascal = FooBar100%Baz
(6) pascal = FooBar100%Baz
(7) pascal = FooBar100%baz
(8) pascal = FooBar100%baz

(9) pascal = FooBar100%Baz
(a) pascal = FooBar100%Baz
(b) pascal = FooBar100%baz
(c) pascal = FooBar100%baz

func SnakeCase 

func SnakeCase(input string) string

SnakeCase converts the input string to snake case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	snake := stringcase.SnakeCase("fooBarBaz")
	fmt.Printf("(1) snake = %s\n", snake)

	snake = stringcase.SnakeCase("foo-Bar100baz")
	fmt.Printf("(2) snake = %s\n", snake)
}

Output:
(1) snake = foo_bar_baz
(2) snake = foo_bar100_baz

func SnakeCaseWithOptions added in v0.3.0 

func SnakeCaseWithOptions(input string, opts Options) string

SnakeCaseWithOptions converts the input string to snake case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	snake := stringcase.SnakeCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) snake = %s\n\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) snake = %s\n\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) snake = %s\n", snake)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	snake = stringcase.SnakeCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) snake = %s\n", snake)
}

Output:
(1) snake = foo_bar100_baz
(2) snake = foo_bar_100_baz
(3) snake = foo_bar_100baz
(4) snake = foo_bar100baz

(5) snake = foo_bar100%_baz
(6) snake = foo_bar_100%_baz
(7) snake = foo_bar_100%baz
(8) snake = foo_bar100%baz

(9) snake = foo_bar100%_baz
(a) snake = foo_bar_100%_baz
(b) snake = foo_bar_100%baz
(c) snake = foo_bar100%baz

func TitleCase added in v1.0.0 

func TitleCase(input string) string

TitleCase converts the input string to title case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	title := stringcase.TitleCase("fooBarBaz")
	fmt.Printf("(1) title = %s\n", title)

	title = stringcase.TitleCase("foo-Bar100baz")
	fmt.Printf("(2) title = %s\n", title)
}

Output:
(1) title = Foo Bar Baz
(2) title = Foo Bar100 Baz

func TitleCaseWithOptions added in v1.0.0 

func TitleCaseWithOptions(input string, opts Options) string

TitleCaseWithOptions converts the input string to title case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	title := stringcase.TitleCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	title = stringcase.TitleCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	title = stringcase.TitleCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	title = stringcase.TitleCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) title = %s\n\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) title = %s\n\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) title = %s\n", title)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	title = stringcase.TitleCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) title = %s\n", title)
}

Output:
(1) title = Foo Bar100 Baz
(2) title = Foo Bar 100 Baz
(3) title = Foo Bar 100baz
(4) title = Foo Bar100baz

(5) title = Foo Bar100% Baz
(6) title = Foo Bar 100% Baz
(7) title = Foo Bar 100%baz
(8) title = Foo Bar100%baz

(9) title = Foo Bar100% Baz
(a) title = Foo Bar 100% Baz
(b) title = Foo Bar 100%baz
(c) title = Foo Bar100%baz

func TrainCase 

func TrainCase(input string) string

TrainCase converts the input string to train case.

It treats the end of a sequence of non-alphabetical characters as a word boundary, but not the beginning.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	train := stringcase.TrainCase("fooBarBaz")
	fmt.Printf("(1) train = %s\n", train)

	train = stringcase.TrainCase("foo-Bar100baz")
	fmt.Printf("(2) train = %s\n", train)
}

Output:
(1) train = Foo-Bar-Baz
(2) train = Foo-Bar100-Baz

func TrainCaseWithOptions added in v0.3.0 

func TrainCaseWithOptions(input string, opts Options) string

TrainCaseWithOptions converts the input string to train case with the specified options.

Example 
package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	opts := stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true}
	train := stringcase.TrainCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(1) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true}
	train = stringcase.TrainCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(2) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false}
	train = stringcase.TrainCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(3) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false}
	train = stringcase.TrainCaseWithOptions("foo#Bar100baz", opts)
	fmt.Printf("(4) train = %s\n\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Separators: "#"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(5) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Separators: "#"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(6) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Separators: "#"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(7) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Separators: "#"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(8) train = %s\n\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: true, Keep: "%"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(9) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: true, Keep: "%"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(a) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: true, SeparateAfterNonAlphabets: false, Keep: "%"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(b) train = %s\n", train)

	opts = stringcase.Options{SeparateBeforeNonAlphabets: false, SeparateAfterNonAlphabets: false, Keep: "%"}
	train = stringcase.TrainCaseWithOptions("foo#Bar100%baz", opts)
	fmt.Printf("(c) train = %s\n", train)
}

Output:
(1) train = Foo-Bar100-Baz
(2) train = Foo-Bar-100-Baz
(3) train = Foo-Bar-100baz
(4) train = Foo-Bar100baz

(5) train = Foo-Bar100%-Baz
(6) train = Foo-Bar-100%-Baz
(7) train = Foo-Bar-100%baz
(8) train = Foo-Bar100%baz

(9) train = Foo-Bar100%-Baz
(a) train = Foo-Bar-100%-Baz
(b) train = Foo-Bar-100%baz
(c) train = Foo-Bar100%baz

func Upperize added in v1.0.0 

func Upperize(input string, joiner rune, opts Options) string

Upperize converts all ASCII alphabetic characters in the input string to uppercase, inserting the specified joiner rune between word boundaries according to the given options. It serves as a core engine for transforming input strings into uppercase-based casing styles, such as MACRO_CASE or COBOL-CASE, using custom joiner runes and customizable word separation rules defined in Options.

During conversion, all ASCII lowercase letters are converted to ASCII uppercase letters, and word boundaries are automatically recognized between casing transitions, such as between lowercase and uppercase letters or before the final uppercase letter of an acronym preceding a lowercase sequence. When non-alphanumeric characters are encountered, ASCII digits are kept by default, while other characters are evaluated against Options. If opts.Separators is non-empty, characters matching opts.Separators are removed as separators while other non-alphanumeric characters are kept; otherwise, if opts.Keep is non-empty, specified characters are kept and all other non-alphanumeric characters are removed. If neither is specified, all non-alphanumeric characters are treated as separators and removed. The fields opts.SeparateBeforeNonAlphabets and opts.SeparateAfterNonAlphabets further determine whether word boundaries are inserted before or after non-alphabetic sequences.

This function never returns an error or panics on any input, returning an empty string when the input is empty. Casing transformations and word boundary detections apply strictly to ASCII letters, treating non-ASCII characters as non-alphanumeric. If both opts.Separators and opts.Keep are specified, opts.Separators takes precedence and opts.Keep is ignored, while any alphanumeric characters listed in either field are disregarded. Additionally, leading and trailing separator characters are trimmed from the result without producing leading or trailing joiners.

Types

type Options added in v0.3.0 

type Options struct {
	SeparateBeforeNonAlphabets bool
	SeparateAfterNonAlphabets  bool
	Separators                 string
	Keep                       string
}

Options is a struct that represents options for case conversion of strings.

The SeparateBeforeNonAlphabets field specifies whether to treat the beginning of a sequence of non-alphabetical characters as a word boundary. The SeparateAfterNonAlphabets field specifies whether to treat the end of a sequence of non-alphabetical characters as a word boundary. The Separators field specifies the set of characters to be treated as word separators and removed from the result string. The Keep field specifies the set of characters not to be treated as word separators and kept in the result string.

Alphanumeric characters specified in Separators and Keep are ignored. If both Separators and Keep are specified, Separators takes precedence and Keep is ignored.

Source Files

View all Source files

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.