kefu/tools/stringutil.go

// stringutil 包含有用于处理字符串的工具函数。
package tools

import (
	"crypto/rand"
	"fmt"
	"github.com/gobuffalo/packr/v2"
	"net"
	"regexp"
	"strconv"
	"strings"
)

// Reverse 将其实参字符串以符文为单位左右反转。
func Reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

// Reverse2 将其实参字符串以符文为单位左右反转。
func Reverse2(s string) string {
	r := []rune(s)
	left := 0
	right := len(r) - 1
	for left < right {
		r[left], r[right] = r[right], r[left]
		left++
		right--
	}
	return string(r)
}

// 获取文件内容，可以打包到二进制
func FileGetContent(file string) string {
	str := ""
	box := packr.New("tmpl", "../static")
	content, err := box.FindString(file)
	if err != nil {
		return str
	}
	return content
}

func ShowStringByte(str string) {
	s := []byte(str)
	for i, c := range s {
		fmt.Println(i, c)
	}
}
func NilChannel() {
	var ch chan int
	ch <- 1
}

// 截取字符串，支持多字节字符
// start：起始下标，负数从从尾部开始，最后一个为-1
// length：截取长度，负数表示截取到末尾
func SubStr(str string, start int, length int) (result string) {
	s := []rune(str)
	total := len(s)
	if total == 0 {
		return
	}
	// 允许从尾部开始计算
	if start < 0 {
		start = total + start
		if start < 0 {
			return
		}
	}
	if start > total {
		return
	}
	// 到末尾
	if length < 0 {
		length = total
	}

	end := start + length
	if end > total {
		result = string(s[start:])
	} else {
		result = string(s[start:end])
	}

	return
}

// 替换字符串中特定位置的字符
//
//	str2 := []rune("21")
//	str3 := ReplaceAtPosition(string(str2), len(str2), "3")
//	log.Println(str3)//替换最后一位
func ReplaceAtPosition(originaltext string, indexofcharacter int, replacement string) string {
	if originaltext == "" {
		for i := 1; i <= indexofcharacter; i++ {
			originaltext += "0"
		}
	}
	runes := []rune(originaltext)
	partOne := string(runes[0 : indexofcharacter-1])
	partTwo := string(runes[indexofcharacter:len(runes)])
	return partOne + replacement + partTwo
}
func Str2Int(str string) int {
	res := 0
	var err error
	if res, err = strconv.Atoi(str); err != nil {
		return 0
	}
	return res
}
func Str2Int64(str string) int64 {
	var res int64
	var err error
	if res, err = strconv.ParseInt(str, 10, 64); err != nil {
		return 0
	}
	return res
}
func Str2Float64(str string) float64 {
	var res float64
	var err error
	if res, err = strconv.ParseFloat(str, 64); err != nil {
		return res
	}
	return res
}
func Str2Uint(str string) uint {
	res := Str2Int(str)
	return uint(res)
}
func Int2Str(i interface{}) string {
	return fmt.Sprintf("%v", i)
}

/*
*
去除html标签，过滤html标签
*/
func TrimHtml(src string) string {
	//将HTML标签全转换成小写
	re, _ := regexp.Compile("\\<[\\S\\s]+?\\>")
	src = re.ReplaceAllStringFunc(src, strings.ToLower)
	//去除STYLE
	re, _ = regexp.Compile("\\<style[\\S\\s]+?\\</style\\>")
	src = re.ReplaceAllString(src, "")
	//去除SCRIPT
	re, _ = regexp.Compile("\\<script[\\S\\s]+?\\</script\\>")
	src = re.ReplaceAllString(src, "")
	//去除所有尖括号内的HTML代码，并换成换行符
	re, _ = regexp.Compile("\\<[\\S\\s]+?\\>")
	src = re.ReplaceAllString(src, "\n")
	//去除连续的换行符
	re, _ = regexp.Compile("\\s{2,}")
	src = re.ReplaceAllString(src, "\n")
	return strings.TrimSpace(src)
}

// 三元运算
func Ifelse(condition bool, trueValue, falseValue interface{}) interface{} {
	if condition {
		return trueValue
	} else {
		return falseValue
	}
}

// 判断是不是IP
func IsIP(str string) bool {
	ip := net.ParseIP(str)
	return ip != nil
}

// 判断是否手机
func IsPhoneNumber(str string) bool {
	reg := `^1[3456789]\d{9}$`
	r := regexp.MustCompile(reg)
	return r.MatchString(str)
}

// 判断是否邮箱
func IsEmail(str string) bool {
	// 定义邮箱正则表达式
	emailRegexp := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
	// 编译正则表达式
	r := regexp.MustCompile(emailRegexp)
	// 匹配字符串
	return r.MatchString(str)
}

// 是否匹配域名
func IsMatchingDomain(allowedDomain, domainToCheck string) bool {
	// 将通配符域名中的 * 替换为正则表达式可以匹配的模式
	allowedDomain = strings.ReplaceAll(allowedDomain, "*", ".*")

	// 使用正则表达式匹配
	matched, err := regexp.MatchString("^"+allowedDomain+"$", domainToCheck)
	if err != nil {
		return false
	}
	return matched
}

// 强密码验证，必须包含大写字母，小写字母，数字和特殊字符，并且不能少于8位
func IsStrongPass(pass string) bool {
	// 编写多个子正则表达式来检查密码的不同方面
	var regexps = []*regexp.Regexp{
		regexp.MustCompile(`[a-z]`),        // 小写字母
		regexp.MustCompile(`[A-Z]`),        // 大写字母
		regexp.MustCompile(`[0-9]`),        // 数字
		regexp.MustCompile(`[^a-zA-Z0-9]`), // 非字母和非数字字符
	}

	for _, re := range regexps {
		idx := re.FindStringIndex(pass)
		if idx == nil {
			return false // 如果某个条件不满足，返回 false
		}
	}

	// 检查密码长度是否大于等于8
	if len(pass) < 8 {
		return false
	}

	return true // 所有条件都满足，返回 true
}

// 判断字符串是否位于字符串数组
func IsInArray(str string, arr []string) bool {
	for _, v := range arr {
		if str == v {
			return true
		}
	}
	return false
}

// 生成随机字符
func randomChar() rune {
	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	length := len(charset)
	b := make([]byte, 1)
	rand.Read(b)
	return rune(charset[int(b[0])%length])
}

// 生成随机字符串
func GenerateRandomString(n int) string {
	var sb strings.Builder
	sb.Grow(n) // 预分配内存
	for i := 0; i < n; i++ {
		sb.WriteRune(randomChar())
	}
	return sb.String()
}