scs

func CamelToKebab ¶

func CamelToKebab(camel string) (string, error)

CamelToKebab converts a camelCase-style string to kebab-case.

This function checks if the input string is in camelCase. If it's not, it returns an error.

If the input string is in camelCase, it performs the conversion by inserting hyphens before each capital letter (except the first one) and then converts the string to lowercase.

Note that this conversion could fail if the input string is not in camelCase style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := CamelToKebab("helloWorld")
// result: "hello-world", err: nil

result, err := CamelToKebab("HelloWorld")
// result: "", err: error (not camelCase)

func CamelToPascal ¶

func CamelToPascal(camel string) (string, error)

CamelToPascal converts a camelCase-style string to PascalCase.

This function checks if the input string is in camelCase. If it's not, it returns an error.

If the input string is in camelCase, it performs the conversion by inserting spaces before each capital letter (except the first one) and then converts the string to PascalCase.

Note that this conversion could fail if the input string is not in camelCase style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := CamelToPascal("helloWorld")
// result: "HelloWorld", err: nil

result, err := CamelToPascal("HelloWorld")
// result: "HelloWorld", err: nil

func CamelToSnake ¶

func CamelToSnake(camel string) (string, error)

CamelToSnake converts a camelCase-style string to snake_case.

This function checks if the input string is in camelCase. If it's not, it returns an error.

If the input string is in camelCase, it performs the conversion by inserting underscores before each capital letter (except the first one) and then converts the string to snake_case.

Note that this conversion could fail if the input string is not in camelCase style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := CamelToSnake("helloWorld")
// result: "hello_world", err: nil

result, err := CamelToSnake("HelloWorld")
// result: "hello_world", err: nil

func KebabToCamel ¶

func KebabToCamel(kebab string) (string, error)

KebabToCamel converts a kebab-case-style string to camelCase.

This function checks if the input string is in kebab-case. If it's not, it returns an error.

If the input string is in kebab-case, it replaces all hyphens with spaces and converts the resulting string to camelCase. CamelCase is a naming convention in which the first letter of each word (including the first word) is capitalized, and there are no spaces or underscores between words.

Note that this conversion could fail if the input string is not in kebab-case style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := KebabToCamel("hello-world")
// result: "helloWorld", err: nil

result, err := KebabToCamel("Hello-World")
// result: "", err: error (not kebab-case)

func KebabToPascal ¶

func KebabToPascal(kebab string) (string, error)

KebabToPascal converts a kebab-case-style string to PascalCase.

This function checks if the input string is in kebab-case. If it's not, it returns an error.

If the input string is in kebab-case, it replaces all hyphens with spaces, performs title casing on each word, and joins the words together to form a PascalCase string. PascalCase is a naming convention in which the first letter of each word (including the first word) is capitalized, and there are no underscores or spaces between words.

Note that this conversion could fail if the input string is not in kebab-case style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := KebabToPascal("hello-world")
// result: "HelloWorld", err: nil

result, err := KebabToPascal("Hello-World")
// result: "", err: error (not kebab-case)

func KebabToSnake ¶

func KebabToSnake(kebab string) (string, error)

KebabToSnake converts a kebab-case-style string to snake_case.

This function checks if the input string is in kebab-case. If it's not, it returns an error.

If the input string is in kebab-case, it replaces all hyphens with underscores, effectively converting the string from kebab-case to snake_case. Snake_case is a naming convention in which words are separated by underscores and there are no capital letters.

Note that this conversion could fail if the input string is not in kebab-case style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := KebabToSnake("hello-world")
// result: "hello_world", err: nil

result, err := KebabToSnake("Hello-World")
// result: "", err: error (not kebab-case)

func PascalToCamel ¶

func PascalToCamel(pascal string) (string, error)

PascalToCamel converts a PascalCase-style string to camelCase.

This function checks if the input string is in PascalCase. If it's not, it returns an error.

If the input string is in PascalCase, it performs the conversion by inserting a space before each capital letter (except the first one), and then converts the string to camelCase.

Note that this conversion could fail if the input string is not in PascalCase style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := PascalToCamel("HelloWorld")
// result: "helloWorld", err: nil

result, err := PascalToCamel("helloWorld")
// result: "", err: error (not PascalCase)

func PascalToKebab ¶

func PascalToKebab(pascal string) (string, error)

PascalToKebab converts a PascalCase-style string to kebab-case.

This function checks if the input string is in PascalCase. If it's not, it returns an error.

If the input string is in PascalCase, it performs the conversion by inserting hyphens before each capital letter (except the first one) and then converts the string to lowercase.

Note that this conversion could fail if the input string is not in PascalCase style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := PascalToKebab("HelloWorld")
// result: "hello-world", err: nil

result, err := PascalToKebab("helloWorld")
// result: "", err: error (not PascalCase)

func PascalToSnake ¶

func PascalToSnake(pascal string) (string, error)

PascalToSnake converts a PascalCase-style string to snake_case.

This function checks if the input string is in PascalCase. If it's not, it returns an error.

If the input string is in PascalCase, it performs the conversion by inserting underscores before each capital letter (except the first one), and then converts the string to snake_case.

Note that this conversion could fail if the input string is not in PascalCase style. In that case, an error will be returned along with an empty string.

Example usage:

result, err := PascalToSnake("HelloWorld")
// result: "hello_world", err: nil

result, err := PascalToSnake("helloWorld")
// result: "", err: error (not PascalCase)

func SnakeToCamel ¶

func SnakeToCamel(snake string) (string, error)

SnakeToCamel converts a snake_case-style string to camelCase.

This function checks if the input string is in snake_case. If not, it returns an error.

If the input string is in snake_case, it replaces all underscores with spaces and converts the resulting string to camelCase.

Note that the first word in the output string will be in lower case, and the first letter of each subsequent word will be in upper case. All other letters will be lower case.

This conversion could fail if the input string is not in snake_case style. In that case, an error will be returned along with an empty string.

Example usage:

scs.SnakeToCamel("hello_world") // returns "helloWorld", nil
scs.SnakeToCamel("HelloWorld")  // returns "", error
scs.SnakeToCamel("hello-world") // returns "", error

func SnakeToKebab ¶

func SnakeToKebab(snake string) (string, error)

SnakeToKebab converts a snake_case-style string to kebab-case.

This function checks if the input string is in snake_case. If it's not, it returns an error.

If the input string is in snake_case, it replaces all underscores with hyphens, effectively converting the string from snake_case to kebab-case.

Note that this conversion could fail if the input string is not in snake_case style. In that case, an error will be returned along with an empty string.

Example usage:

scs.SnakeToKebab("hello_world") // returns "hello-world", nil
scs.SnakeToKebab("HelloWorld")  // returns "", error
scs.SnakeToKebab("helloWorld")  // returns "", error

func SnakeToPascal ¶

func SnakeToPascal(snake string) (string, error)

SnakeToPascal converts a snake_case-style string to PascalCase.

This function checks if the input string is in snake_case. If it's not, it returns an error.

If the input string is in snake_case, it replaces all underscores with spaces and converts the resulting string to PascalCase. The PascalCase format starts with an uppercase letter, and includes an uppercase letter at the beginning of each new word.

Note that this conversion could fail if the input string is not in snake_case style. In that case, an error will be returned along with an empty string.

Example usage:

scs.SnakeToPascal("hello_world") // returns "HelloWorld", nil
scs.SnakeToPascal("HelloWorld")  // returns "", error
scs.SnakeToPascal("hello-world") // returns "", error

func StrIsCamel ¶

func StrIsCamel(s string) bool

StrIsCamel returns true if the string is in camelCase.

CamelCase is a naming convention in which the first letter of the first word is lowercase, and the first letter of each subsequent word is capitalized. There are no spaces or underscores between words.

Example usage:

scs.StrIsCamel("helloWorld")  // returns true
scs.StrIsCamel("HelloWorld")  // returns true
scs.StrIsCamel("hello_world") // returns false
scs.StrIsCamel("hello-World") // returns false

func StrIsKebab ¶

func StrIsKebab(s string) bool

StrIsKebab returns true if the string is in kebab-case.

Kebab-case is a naming convention in which words are separated by hyphens, and all letters are lowercase.

Example usage:

scs.StrIsKebab("hello-world")  // returns true
scs.StrIsKebab("HelloWorld")   // returns false
scs.StrIsKebab("hello_world")  // returns false
scs.StrIsKebab("Hello-World")  // returns false

func StrIsPascal ¶

func StrIsPascal(s string) bool

StrIsPascal returns true if the string is in PascalCase.

PascalCase is a naming convention in which the first letter of each word (including the first word) is capitalized, and there are no underscores between words.

Example usage:

scs.StrIsPascal("HelloWorld")    // returns true
scs.StrIsPascal("helloWorld")    // returns false
scs.StrIsPascal("hello_world")   // returns false
scs.StrIsPascal("Hello_World")   // returns false

func StrIsSnake ¶

func StrIsSnake(s string) bool

StrIsSnake returns true if the string is in snake_case.

Snake case represents words separated by underscores and does not have any capital letters.

Example usage:

scs.StrIsSnake("hello_world") // returns true
scs.StrIsSnake("HelloWorld")  // returns false
scs.StrIsSnake("hello-world") // returns false

func StrToCamel ¶

func StrToCamel(s string) string

StrToCamel converts a string to camelCase.

This function converts the input string to camelCase format. CamelCase is a naming convention in which the first letter of the first word is lowercase, and the first letter of each subsequent word is capitalized. There are no spaces or underscores between words.

Note that this function will convert all characters to lowercase, except for the first letter of the first word, which will be lowercase.

Example usage:

scs.StrToCamel("hello_world")  // returns "helloWorld"
scs.StrToCamel("hello-world")  // returns "helloWorld"
scs.StrToCamel("HelloWorld")   // returns "helloWorld"

func StrToKebab ¶

func StrToKebab(s string) string

StrToKebab converts a string to kebab-case.

This function transforms the input string to kebab-case format. Kebab-case is a naming convention in which words are separated by hyphens, and all letters are lowercase.

Example usage:

scs.StrToKebab("helloWorld")   // returns "hello-world"
scs.StrToKebab("HelloWorld")   // returns "hello-world"
scs.StrToKebab("hello_world")  // returns "hello-world"
scs.StrToKebab("Hello-World")  // returns "hello-world"

func StrToPascal ¶

func StrToPascal(s string) string

StrToPascal converts a string to PascalCase.

This function transforms the input string to PascalCase format. PascalCase is a naming convention in which the first letter of each word, including the first word, is capitalized, and there are no underscores or spaces between words.

Note that this function will convert all characters to lowercase, except for the first letter of each word, which will be capitalized.

Example usage:

scs.StrToPascal("hello_world") // returns "HelloWorld"
scs.StrToPascal("hello world") // returns "HelloWorld"
scs.StrToPascal("helloWorld")  // returns "Helloworld"

func StrToSnake ¶

func StrToSnake(s string) string

StrToSnake converts a string to snake_case.

This function first transforms the input string by replacing all non-alphanumeric characters with spaces.

It then splits the string into chunks at the spaces, converts each chunk to lower case, and finally joins the chunks back together with underscores.

Note that this function will convert upper case letters to lower case, so the output string will be all lower case even if the input string contains upper case letters.

Example usage:

scs.StrToSnake("Hello World") // returns "hello_world"
scs.StrToSnake("hello world") // returns "hello_world"
scs.StrToSnake("hello-world") // returns "hello_world"

func ToCamel ¶

func ToCamel(s string) string

ToCamel converts a string to camelCase.

This function converts the input string to camelCase format. CamelCase is a naming convention in which the first letter of the first word is lowercase, and the first letter of each subsequent word is capitalized. There are no spaces or underscores between words.

Unlike the StrToCamel function, if the source string already has a certain format such as camelCase, kebab-case, PascalCase, or snake_case, it will be correctly converted to camelCase.

Example usage:

scs.ToCamel("hello_world")  // returns "helloWorld"
scs.ToCamel("hello-world")  // returns "helloWorld"
scs.ToCamel("HelloWorld")   // returns "helloWorld"
scs.ToCamel("snake_case")   // returns "snakeCase"
scs.ToCamel("kebab-case")   // returns "kebabCase"
scs.ToCamel("PascalCase")   // returns "pascalCase"
scs.ToCamel("camelCase")    // returns "camelCase"

func ToKebab ¶

func ToKebab(s string) string

ToKebab converts a string to kebab-case.

This function converts the input string to kebab-case format. Kebab-case is a naming convention in which words are separated by hyphens, and all letters are lowercase.

If the source string already has a certain format, such as camelCase, kebab-case, PascalCase, or snake_case, it will be correctly converted to kebab-case.

Example usage:

scs.ToKebab("helloWorld")   // returns "hello-world"
scs.ToKebab("HelloWorld")   // returns "hello-world"
scs.ToKebab("hello_world")  // returns "hello-world"
scs.ToKebab("Hello-World")  // returns "hello-world"

func ToPascal ¶

func ToPascal(s string) string

ToPascal converts a string to PascalCase.

This function converts the input string to PascalCase format. PascalCase is a naming convention in which the first letter of each word (including the first word) is capitalized, and there are no underscores, spaces, or hyphens between words.

If the source string already has a certain format, such as camelCase, kebab-case, or snake_case, it will be correctly converted to PascalCase.

Example usage:

scs.ToPascal("hello_world")   // returns "HelloWorld"
scs.ToPascal("hello-world")   // returns "HelloWorld"
scs.ToPascal("helloWorld")    // returns "HelloWorld"
scs.ToPascal("helloWorld123") // returns "HelloWorld123"

func ToSnake ¶

func ToSnake(s string) string

ToSnake converts a string to snake_case.

Unlike the StrToSnake function, this function attempts to correctly handle strings that are already in a certain format (such as CamelCase, KebabCase, or PascalCase) and convert them into snake_case.

The function first checks if the string is in CamelCase, KebabCase, PascalCase, or SnakeCase format. If it is, it uses the corresponding conversion function to convert the string into snake_case.

If the string is not in any recognized format, it defaults to using the StrToSnake function to attempt a conversion.

Example usage:

scs.ToSnake("helloWorld")   // returns "hello_world"
scs.ToSnake("HelloWorld")   // returns "hello_world"
scs.ToSnake("hello-world")  // returns "hello_world"
scs.ToSnake("hello_world")  // returns "hello_world"
scs.ToSnake("Hello World")  // returns "hello_world"

func Version ¶ added in v1.0.0

func Version() string

Version returns the version of the module.