mirror of
https://gitee.com/johng/gf.git
synced 2024-12-04 13:18:01 +08:00
134 lines
3.3 KiB
Go
134 lines
3.3 KiB
Go
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
// If a copy of the MIT was not distributed with this file,
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
package utils
|
|
|
|
import (
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
// DefaultTrimChars are the characters which are stripped by Trim* functions in default.
|
|
DefaultTrimChars = string([]byte{
|
|
'\t', // Tab.
|
|
'\v', // Vertical tab.
|
|
'\n', // New line (line feed).
|
|
'\r', // Carriage return.
|
|
'\f', // New page.
|
|
' ', // Ordinary space.
|
|
0x00, // NUL-byte.
|
|
0x85, // Delete.
|
|
0xA0, // Non-breaking space.
|
|
})
|
|
)
|
|
|
|
// IsLetterUpper checks whether the given byte b is in upper case.
|
|
func IsLetterUpper(b byte) bool {
|
|
if b >= byte('A') && b <= byte('Z') {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// IsLetterLower checks whether the given byte b is in lower case.
|
|
func IsLetterLower(b byte) bool {
|
|
if b >= byte('a') && b <= byte('z') {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// IsLetter checks whether the given byte b is a letter.
|
|
func IsLetter(b byte) bool {
|
|
return IsLetterUpper(b) || IsLetterLower(b)
|
|
}
|
|
|
|
// IsNumeric checks whether the given string s is numeric.
|
|
// Note that float string like "123.456" is also numeric.
|
|
func IsNumeric(s string) bool {
|
|
length := len(s)
|
|
if length == 0 {
|
|
return false
|
|
}
|
|
for i := 0; i < len(s); i++ {
|
|
if s[i] == '-' && i == 0 {
|
|
continue
|
|
}
|
|
if s[i] == '.' {
|
|
if i > 0 && i < len(s)-1 {
|
|
continue
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
if s[i] < '0' || s[i] > '9' {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// UcFirst returns a copy of the string s with the first letter mapped to its upper case.
|
|
func UcFirst(s string) string {
|
|
if len(s) == 0 {
|
|
return s
|
|
}
|
|
if IsLetterLower(s[0]) {
|
|
return string(s[0]-32) + s[1:]
|
|
}
|
|
return s
|
|
}
|
|
|
|
// ReplaceByMap returns a copy of `origin`,
|
|
// which is replaced by a map in unordered way, case-sensitively.
|
|
func ReplaceByMap(origin string, replaces map[string]string) string {
|
|
for k, v := range replaces {
|
|
origin = strings.Replace(origin, k, v, -1)
|
|
}
|
|
return origin
|
|
}
|
|
|
|
// RemoveSymbols removes all symbols from string and lefts only numbers and letters.
|
|
func RemoveSymbols(s string) string {
|
|
var b []byte
|
|
for _, c := range s {
|
|
if (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') {
|
|
b = append(b, byte(c))
|
|
}
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
// EqualFoldWithoutChars checks string `s1` and `s2` equal case-insensitively,
|
|
// with/without chars '-'/'_'/'.'/' '.
|
|
func EqualFoldWithoutChars(s1, s2 string) bool {
|
|
return strings.EqualFold(RemoveSymbols(s1), RemoveSymbols(s2))
|
|
}
|
|
|
|
// SplitAndTrim splits string <str> by a string <delimiter> to an array,
|
|
// and calls Trim to every element of this array. It ignores the elements
|
|
// which are empty after Trim.
|
|
func SplitAndTrim(str, delimiter string, characterMask ...string) []string {
|
|
array := make([]string, 0)
|
|
for _, v := range strings.Split(str, delimiter) {
|
|
v = Trim(v, characterMask...)
|
|
if v != "" {
|
|
array = append(array, v)
|
|
}
|
|
}
|
|
return array
|
|
}
|
|
|
|
// Trim strips whitespace (or other characters) from the beginning and end of a string.
|
|
// The optional parameter <characterMask> specifies the additional stripped characters.
|
|
func Trim(str string, characterMask ...string) string {
|
|
trimChars := DefaultTrimChars
|
|
if len(characterMask) > 0 {
|
|
trimChars += characterMask[0]
|
|
}
|
|
return strings.Trim(str, trimChars)
|
|
}
|