121 lines
3.1 KiB
Go
121 lines
3.1 KiB
Go
package stringutil
|
|
|
|
import (
|
|
"strings"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
func EquateStringCaseInsensitive(a, b string) bool {
|
|
// !!!
|
|
// return a == b || strings.ToUpper(a) == strings.ToUpper(b)
|
|
return strings.EqualFold(a, b)
|
|
}
|
|
|
|
func EquateStringCaseSensitive(a, b string) bool {
|
|
return a == b
|
|
}
|
|
|
|
func GetStringEqualityComparer(ignoreCase bool) func(a, b string) bool {
|
|
if ignoreCase {
|
|
return EquateStringCaseInsensitive
|
|
}
|
|
return EquateStringCaseSensitive
|
|
}
|
|
|
|
type Comparison = int
|
|
|
|
const (
|
|
ComparisonLessThan Comparison = -1
|
|
ComparisonEqual Comparison = 0
|
|
ComparisonGreaterThan Comparison = 1
|
|
)
|
|
|
|
func CompareStringsCaseInsensitive(a string, b string) Comparison {
|
|
if a == b {
|
|
return ComparisonEqual
|
|
}
|
|
for {
|
|
ca, sa := utf8.DecodeRuneInString(a)
|
|
cb, sb := utf8.DecodeRuneInString(b)
|
|
if sa == 0 {
|
|
if sb == 0 {
|
|
return ComparisonEqual
|
|
}
|
|
return ComparisonLessThan
|
|
}
|
|
if sb == 0 {
|
|
return ComparisonGreaterThan
|
|
}
|
|
lca := unicode.ToLower(ca)
|
|
lcb := unicode.ToLower(cb)
|
|
if lca != lcb {
|
|
if lca < lcb {
|
|
return ComparisonLessThan
|
|
}
|
|
return ComparisonGreaterThan
|
|
}
|
|
a = a[sa:]
|
|
b = b[sb:]
|
|
}
|
|
}
|
|
|
|
func CompareStringsCaseSensitive(a string, b string) Comparison {
|
|
return strings.Compare(a, b)
|
|
}
|
|
|
|
func GetStringComparer(ignoreCase bool) func(a, b string) Comparison {
|
|
if ignoreCase {
|
|
return CompareStringsCaseInsensitive
|
|
}
|
|
return CompareStringsCaseSensitive
|
|
}
|
|
|
|
func HasPrefix(s string, prefix string, caseSensitive bool) bool {
|
|
if caseSensitive {
|
|
return strings.HasPrefix(s, prefix)
|
|
}
|
|
if len(prefix) > len(s) {
|
|
return false
|
|
}
|
|
return strings.EqualFold(s[0:len(prefix)], prefix)
|
|
}
|
|
|
|
func HasSuffix(s string, suffix string, caseSensitive bool) bool {
|
|
if caseSensitive {
|
|
return strings.HasSuffix(s, suffix)
|
|
}
|
|
if len(suffix) > len(s) {
|
|
return false
|
|
}
|
|
return strings.EqualFold(s[len(s)-len(suffix):], suffix)
|
|
}
|
|
|
|
func CompareStringsCaseInsensitiveThenSensitive(a, b string) Comparison {
|
|
cmp := CompareStringsCaseInsensitive(a, b)
|
|
if cmp != ComparisonEqual {
|
|
return cmp
|
|
}
|
|
return CompareStringsCaseSensitive(a, b)
|
|
}
|
|
|
|
// CompareStringsCaseInsensitiveEslintCompatible performs a case-insensitive comparison
|
|
// using toLowerCase() instead of toUpperCase() for ESLint compatibility.
|
|
//
|
|
// `CompareStringsCaseInsensitive` transforms letters to uppercase for unicode reasons,
|
|
// while eslint's `sort-imports` rule transforms letters to lowercase. Which one you choose
|
|
// affects the relative order of letters and ASCII characters 91-96, of which `_` is a
|
|
// valid character in an identifier. So if we used `CompareStringsCaseInsensitive` for
|
|
// import sorting, TypeScript and eslint would disagree about the correct case-insensitive
|
|
// sort order for `__String` and `Foo`. Since eslint's whole job is to create consistency
|
|
// by enforcing nitpicky details like this, it makes way more sense for us to just adopt
|
|
// their convention so users can have auto-imports without making eslint angry.
|
|
func CompareStringsCaseInsensitiveEslintCompatible(a, b string) Comparison {
|
|
if a == b {
|
|
return ComparisonEqual
|
|
}
|
|
a = strings.ToLower(a)
|
|
b = strings.ToLower(b)
|
|
return strings.Compare(a, b)
|
|
}
|