stringcase

package module

v0.3.0 Latest Latest Go to latest Published: Feb 11, 2025 License: MIT Imports: 1 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/sttk/stringcase

Links

Open Source Insights

README ¶

stringcase

This library provides functions that convert strings into the following cases:

camelCase
COBOL-CASE
kebab-case
MACRO_CASE
PascalCase
snake_case
Train-Case

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.

When converting cases, there are several possible ways to handle numbers and symbols that remain in the converted string. This library supports the following four types of behavior:

Insert a word separator before a string of consecutive numbers or symbols
(Specify SeparateBeforeNonAlphabets = true, SeparateAfterNonAlphabets = false of Options)
Insert a word separator after a string of consecutive numbers or symbols
(Specify SeparateBeforeNonAlphabets = false, SeparateAfterNonAlphabets = true of Options)
Insert word separators both before and after a string of consecutive numbers or symbols
(Specify SeparateBeforeNonAlphabets = true, SeparateAfterNonAlphabets = true of Options)
Do not insert before and after numbers or symbols as word separators
(Specify SeparateBeforeNonAlphabets = false, SeparateAfterNonAlphabets = false of Options)

〜Case functions that do not take Options as an argument will behave as described in type 2. above.

Install

Write the following import declaration, then run go mod tidy.

import "github.com/sttk/stringcase"

Usage

This functions contained in this library are excuted as follows:

func main() {
    input := "foo-bar-baz"
    camel := stringcase.CamelCase(input)
    fmt.Printf("%s\n", camel)
    // => "fooBarBaz"
}

Supporting Go versions

This library supports Go 1.18 or later.

Actual test results for each Go version:

% gvm-fav                   
Now using version go1.18.10
go version go1.18.10 darwin/amd64
ok  	github.com/sttk/stringcase	0.748s	coverage: 100.0% of statements

Now using version go1.19.13
go version go1.19.13 darwin/amd64
ok  	github.com/sttk/stringcase	0.366s	coverage: 100.0% of statements

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

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

Now using version go1.22.10
go version go1.22.10 darwin/amd64
ok  	github.com/sttk/stringcase	0.395s	coverage: 100.0% of statements

Now using version go1.23.6
go version go1.23.6 darwin/amd64
ok  	github.com/sttk/stringcase	0.379s	coverage: 100.0% of statements

Back to go1.23.6
Now using version go1.23.6

License

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 camelCase, COBOL-CASE, kebab-case, MACRO_CASE, PascalCase, snake_case and Train-Case.

Basically, these functions targets the upper and lower cases of only ASCII alphabets for capitalization, and all characters except ASCII alphabets and ASCII numbers are eliminated as word separators.

To limit characters using as separators, the functions named like *_with_sep are provided, and to keep specified characters, the functions named like *_with_keep are provided.

Index ¶

func CamelCase(input string) string
func CamelCaseWithKeep(input string, kept string) stringdeprecated
func CamelCaseWithOptions(input string, opts Options) string
func CamelCaseWithSep(input string, seps string) stringdeprecated
func CobolCase(input string) string
func CobolCaseWithKeep(input string, kept string) stringdeprecated
func CobolCaseWithOptions(input string, opts Options) string
func CobolCaseWithSep(input string, seps string) stringdeprecated
func KebabCase(input string) string
func KebabCaseWithKeep(input string, kept string) stringdeprecated
func KebabCaseWithOptions(input string, opts Options) string
func KebabCaseWithSep(input string, seps string) stringdeprecated
func MacroCase(input string) string
func MacroCaseWithKeep(input string, kept string) stringdeprecated
func MacroCaseWithOptions(input string, opts Options) string
func MacroCaseWithSep(input string, seps string) stringdeprecated
func PascalCase(input string) string
func PascalCaseWithKeep(input string, kept string) stringdeprecated
func PascalCaseWithOptions(input string, opts Options) string
func PascalCaseWithSep(input string, seps string) stringdeprecated
func SnakeCase(input string) string
func SnakeCaseWithKeep(input string, kept string) stringdeprecated
func SnakeCaseWithOptions(input string, opts Options) string
func SnakeCaseWithSep(input string, seps string) stringdeprecated
func TrainCase(input string) string
func TrainCaseWithKeep(input string, kept string) stringdeprecated
func TrainCaseWithOptions(input string, opts Options) string
func TrainCaseWithSep(input string, seps string) stringdeprecated
type Options

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

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 CamelCaseWithKeep deprecated

func CamelCaseWithKeep(input string, kept string) string

CamelCaseWithKeep converts the input string to camel case with the specified characters to be kept.

Deprecated: Should use CamelCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	camel := stringcase.CamelCaseWithKeep("foo-bar100%baz", "%")
	fmt.Printf("camel = %s\n", camel)
}

Output:

camel = fooBar100%Baz

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 CamelCaseWithSep deprecated

func CamelCaseWithSep(input string, seps string) string

CamelCaseWithSep converts the input string to camel case with the specified separator characters.

Deprecated: Should use CamelCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	camel := stringcase.CamelCaseWithSep("foo-bar100%baz", "- ")
	fmt.Printf("camel = %s\n", camel)
}

Output:

camel = fooBar100%Baz

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 CobolCaseWithKeep deprecated

func CobolCaseWithKeep(input string, kept string) string

CobolCaseWithKeep converts the input string to cobol case with the specified characters to be kept.

Deprecated: Should use CobolCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	cobol := stringcase.CobolCaseWithKeep("foo-bar100%baz", "%")
	fmt.Printf("cobol = %s\n", cobol)
}

Output:

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 CobolCaseWithSep deprecated

func CobolCaseWithSep(input string, seps string) string

CobolCaseWithSep converts the input string to cobol case with the specified separator characters.

Deprecated: Should use CobolCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	cobol := stringcase.CobolCaseWithSep("foo-bar100%baz", "- ")
	fmt.Printf("cobol = %s\n", cobol)
}

Output:

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 KebabCaseWithKeep deprecated

func KebabCaseWithKeep(input string, kept string) string

KebabCaseWithSep converts the input string to kebab case with the specified separator characters.

Deprecated: Should use KebabCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	kebab := stringcase.KebabCaseWithKeep("foo-bar100%baz", "%")
	fmt.Printf("kebab = %s\n", kebab)
}

Output:

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 KebabCaseWithSep deprecated

func KebabCaseWithSep(input string, seps string) string

KebabCaseWithSep converts the input string to kebab case with the specified separator characters.

Deprecated: Should use KebabCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	kebab := stringcase.KebabCaseWithSep("foo-Bar100%Baz", "- ")
	fmt.Printf("kebab = %s\n", kebab)
}

Output:

kebab = foo-bar100%-baz

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 MacroCaseWithKeep deprecated

func MacroCaseWithKeep(input string, kept string) string

MacroCaseWithKeep converts the input string to macro case with the specified characters to be kept.

Deprecated: Should use MacroCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	macro := stringcase.MacroCaseWithKeep("foo-bar100%baz", "%")
	fmt.Printf("macro = %s\n", macro)
}

Output:

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 MacroCaseWithSep deprecated

func MacroCaseWithSep(input string, seps string) string

MacroCaseWithSep converts the input string to macro case with the specified separator characters.

Deprecated: Should use MacroCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	macro := stringcase.MacroCaseWithSep("foo-bar100%baz", "- ")
	fmt.Printf("macro = %s\n", macro)
}

Output:

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 PascalCaseWithKeep deprecated

func PascalCaseWithKeep(input string, kept string) string

PascalCaseWithKeep converts the input string to pascal case with the specified characters to be kept.

Deprecated: Should use PascalCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	pascal := stringcase.PascalCaseWithKeep("foo-bar100%baz", "%")
	fmt.Printf("pascal = %s\n", pascal)
}

Output:

pascal = FooBar100%Baz

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 PascalCaseWithSep deprecated

func PascalCaseWithSep(input string, seps string) string

PascalCaseWithSep converts the input string to pascal case with the specified separator characters.

Deprecated: Should use PascalCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	pascal := stringcase.PascalCaseWithSep("foo-bar100%baz", "- ")
	fmt.Printf("pascal = %s\n", pascal)
}

Output:

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 SnakeCaseWithKeep deprecated

func SnakeCaseWithKeep(input string, kept string) string

SnakeCaseWithKeep converts the input string to snake case with the specified characters to be kept.

Deprecated: Should use SnakeCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	snake := stringcase.SnakeCaseWithKeep("foo-bar100%baz", "%")
	fmt.Printf("snake = %s\n", snake)
}

Output:

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 SnakeCaseWithSep deprecated

func SnakeCaseWithSep(input string, seps string) string

SnakeCaseWithSep converts the input string to snake case with the specified separator characters.

Deprecated: Should use SnakeCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	snake := stringcase.SnakeCaseWithSep("foo-Bar100%Baz", "- ")
	fmt.Printf("snake = %s\n", snake)
}

Output:

snake = 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 TrainCaseWithKeep deprecated

func TrainCaseWithKeep(input string, kept string) string

TrainCaseWithKeep converts the input string to train case with the specified characters to be kept.

Deprecated: Should use TrainCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	train := stringcase.TrainCaseWithKeep("foo-bar100%baz", "%")
	fmt.Printf("train = %s\n", train)
}

Output:

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 TrainCaseWithSep deprecated

func TrainCaseWithSep(input string, seps string) string

TrainCaseWithSep converts the input string to train case with the specified separator characters.

Deprecated: Should use TrainCaseWithOptions instead

Example ¶

package main

import (
	"fmt"

	"github.com/sttk/stringcase"
)

func main() {
	train := stringcase.TrainCaseWithSep("foo-bar100%baz", "- ")
	fmt.Printf("train = %s\n", train)
}

Output:

train = Foo-Bar100%-Baz

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 wnd 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

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

stringcase

Install

Usage

Supporting Go versions

Actual test results for each Go version:

License

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func CamelCase ¶

func CamelCaseWithKeep deprecated

func CamelCaseWithOptions ¶ added in v0.3.0

func CamelCaseWithSep deprecated

func CobolCase ¶

func CobolCaseWithKeep deprecated

func CobolCaseWithOptions ¶ added in v0.3.0

func CobolCaseWithSep deprecated

func KebabCase ¶

func KebabCaseWithKeep deprecated

func KebabCaseWithOptions ¶ added in v0.3.0

func KebabCaseWithSep deprecated

func MacroCase ¶

func MacroCaseWithKeep deprecated

func MacroCaseWithOptions ¶ added in v0.3.0

func MacroCaseWithSep deprecated

func PascalCase ¶

func PascalCaseWithKeep deprecated

func PascalCaseWithOptions ¶ added in v0.3.0

func PascalCaseWithSep deprecated

func SnakeCase ¶

func SnakeCaseWithKeep deprecated

func SnakeCaseWithOptions ¶ added in v0.3.0

func SnakeCaseWithSep deprecated

func TrainCase ¶

func TrainCaseWithKeep deprecated

func TrainCaseWithOptions ¶ added in v0.3.0

func TrainCaseWithSep deprecated

Types ¶

type Options ¶ added in v0.3.0

Source Files ¶