From 7e14a2b3d5932cfc4b012dfb8da83c0159006343 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 25 Nov 2025 11:29:56 +0000 Subject: [PATCH 1/2] Initial plan From 4a5a3724e69a2e410d643381e042e0fd8870e023 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 25 Nov 2025 11:37:25 +0000 Subject: [PATCH 2/2] Rename variables and function parameters to be more descriptive Co-authored-by: duguying <3050360+duguying@users.noreply.github.com> --- base62/base62.go | 12 ++--- fs.go | 76 +++++++++++++++--------------- functions.go | 40 ++++++++-------- http/httpclient.go | 74 +++++++++++++++--------------- log/log.go | 112 ++++++++++++++++++++++----------------------- log/logger.go | 52 ++++++++++----------- serialize.go | 24 +++++----- stream/token.go | 26 +++++------ string.go | 60 ++++++++++++------------ time/time.go | 8 ++-- 10 files changed, 242 insertions(+), 242 deletions(-) diff --git a/base62/base62.go b/base62/base62.go index f953114..eed9c50 100644 --- a/base62/base62.go +++ b/base62/base62.go @@ -36,17 +36,17 @@ func Encode(number int) string { // converts base62 token to int func Decode(token string) int { number := 0 - idx := 0.0 + index := 0.0 chars := []byte(alphabet) charsLength := float64(len(chars)) tokenLength := float64(len(token)) - for _, c := range []byte(token) { - power := tokenLength - (idx + 1) - index := bytes.IndexByte(chars, c) - number += index * int(math.Pow(charsLength, power)) - idx++ + for _, char := range []byte(token) { + power := tokenLength - (index + 1) + charIndex := bytes.IndexByte(chars, char) + number += charIndex * int(math.Pow(charsLength, power)) + index++ } return number diff --git a/fs.go b/fs.go index b6c330c..a60ddb1 100644 --- a/fs.go +++ b/fs.go @@ -50,35 +50,35 @@ func PathExist(filename string) bool { // ReadFileByte 读取文件 func ReadFileByte(path string) ([]byte, error) { - fi, err := os.Open(path) + file, err := os.Open(path) if err != nil { return nil, err } - defer fi.Close() - return ioutil.ReadAll(fi) + defer file.Close() + return ioutil.ReadAll(file) } // ReadFileString 读取文本文件 func ReadFileString(path string) (string, error) { - fi, err := os.Open(path) + file, err := os.Open(path) if err != nil { return "", err } - defer fi.Close() - fd, err := ioutil.ReadAll(fi) - return string(fd), err + defer file.Close() + fileData, err := ioutil.ReadAll(file) + return string(fileData), err } // ReadFile 读取文本文件 func ReadFile(path string) (string, error) { - fi, err := os.Open(path) + file, err := os.Open(path) if err != nil { return "", err } - defer fi.Close() - fd, err := ioutil.ReadAll(fi) + defer file.Close() + fileData, err := ioutil.ReadAll(file) - return string(fd), err + return string(fileData), err } // FileExist 检查文件或目录是否存在 @@ -101,16 +101,16 @@ func WriteFileAppend(fullpath string, str string) error { } func writeFileAppend(filename string, data []byte, perm os.FileMode) error { - f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, perm) + file, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, perm) if err != nil { return err } - n, err := f.Write(data) - if err == nil && n < len(data) { + bytesWritten, err := file.Write(data) + if err == nil && bytesWritten < len(data) { err = io.ErrShortWrite } - if err1 := f.Close(); err == nil { - err = err1 + if closeErr := file.Close(); err == nil { + err = closeErr } return err } @@ -149,9 +149,9 @@ func MkdirWithCreatePath(fullpath string) error { for i := 0; i < len(dirArray); i++ { dir := dirArray[i] path = path + string(filepath.Separator) + dir - p := SubString(path, 1, len(path)-1) - if !PathExist(p) { - err = Mkdir(p) + subPath := SubString(path, 1, len(path)-1) + if !PathExist(subPath) { + err = Mkdir(subPath) } } @@ -244,25 +244,25 @@ func Dir(fullpath string) string { } // 解压 tar.gz -func UnpackTar(fpath string, dist string) error { - if fpath == "" { +func UnpackTar(filePath string, destDir string) error { + if filePath == "" { return fmt.Errorf("empty input") } - _ = os.Mkdir(dist, 0755) + _ = os.Mkdir(destDir, 0755) - f, err := os.Open(fpath) + file, err := os.Open(filePath) if err != nil { return err } - defer f.Close() + defer file.Close() - gzf, err := gzip.NewReader(f) + gzipReader, err := gzip.NewReader(file) if err != nil { return err } - tarReader := tar.NewReader(gzf) + tarReader := tar.NewReader(gzipReader) for true { header, err := tarReader.Next() @@ -275,7 +275,7 @@ func UnpackTar(fpath string, dist string) error { return err } - name := filepath.Join(dist, header.Name) + name := filepath.Join(destDir, header.Name) switch header.Typeflag { case tar.TypeDir: @@ -302,18 +302,18 @@ func UnpackTar(fpath string, dist string) error { } // 计算文件MD5 -func FileMD5(fpath string) string { - file, err := os.OpenFile(fpath, os.O_RDONLY, 0755) +func FileMD5(filePath string) string { + file, err := os.OpenFile(filePath, os.O_RDONLY, 0755) if err != nil { log.Println("get md5 err:", err.Error()) return "" } defer file.Close() - buf := md5.New() - io.Copy(buf, file) + hashBuffer := md5.New() + io.Copy(hashBuffer, file) - return hex.EncodeToString(buf.Sum(nil)) + return hex.EncodeToString(hashBuffer.Sum(nil)) } // GenSuid 生成随机短号 @@ -321,11 +321,11 @@ func GenSuid() string { uidMin := base36.Decode("10000000") uidMax := base36.Decode("zzzzzzzz") uid := rand.Intn(int(uidMax-uidMin)) + int(uidMin) - b36s := base36.Encode(uint64(uid)) - mb36b := bytes.Buffer{} - for _, c := range b36s { - idx := base36map[c] - mb36b.WriteRune(base36mix[idx]) + base36String := base36.Encode(uint64(uid)) + mixedBase36Buffer := bytes.Buffer{} + for _, char := range base36String { + idx := base36map[char] + mixedBase36Buffer.WriteRune(base36mix[idx]) } - return strings.ToLower(mb36b.String()) + return strings.ToLower(mixedBase36Buffer.String()) } diff --git a/functions.go b/functions.go index c9530c2..c126886 100644 --- a/functions.go +++ b/functions.go @@ -36,37 +36,37 @@ func TagSplit(keywords string) string { } // 四舍五入 -func Round(val float64, places int) float64 { - var t float64 - f := math.Pow10(places) - x := val * f - if math.IsInf(x, 0) || math.IsNaN(x) { - return val +func Round(inputValue float64, places int) float64 { + var result float64 + scaleFactor := math.Pow10(places) + scaledValue := inputValue * scaleFactor + if math.IsInf(scaledValue, 0) || math.IsNaN(scaledValue) { + return inputValue } - if x >= 0.0 { - t = math.Ceil(x) - if (t - x) > 0.50000000001 { - t -= 1.0 + if scaledValue >= 0.0 { + result = math.Ceil(scaledValue) + if (result - scaledValue) > 0.50000000001 { + result -= 1.0 } } else { - t = math.Ceil(-x) - if (t + x) > 0.50000000001 { - t -= 1.0 + result = math.Ceil(-scaledValue) + if (result + scaledValue) > 0.50000000001 { + result -= 1.0 } - t = -t + result = -result } - x = t / f + scaledValue = result / scaleFactor - if !math.IsInf(x, 0) { - return x + if !math.IsInf(scaledValue, 0) { + return scaledValue } - return t + return result } // http GET -func Get(reqUrl string) (string, error) { - response, err := http.Get(reqUrl) +func Get(requestURL string) (string, error) { + response, err := http.Get(requestURL) if nil != err { return "", err } diff --git a/http/httpclient.go b/http/httpclient.go index ad8ff05..e72c0d3 100644 --- a/http/httpclient.go +++ b/http/httpclient.go @@ -22,7 +22,7 @@ import ( // Jar - cookie jar type Jar struct { - lk sync.Mutex + lock sync.Mutex CookiesData map[string][]*http.Cookie } @@ -33,41 +33,41 @@ func NewJar() *Jar { return jar } -func (j *Jar) addCookie(host string, cookie *http.Cookie) { - hostCookiesData, ok := j.CookiesData[host] +func (jar *Jar) addCookie(host string, cookie *http.Cookie) { + hostCookiesData, ok := jar.CookiesData[host] if ok { - finded := false + found := false for i := 0; i < len(hostCookiesData); i++ { - c := hostCookiesData[i] - if c.Name == cookie.Name { + existingCookie := hostCookiesData[i] + if existingCookie.Name == cookie.Name { hostCookiesData[i] = cookie - finded = true + found = true } } - if !finded { + if !found { hostCookiesData = append(hostCookiesData, cookie) } - j.CookiesData[host] = hostCookiesData + jar.CookiesData[host] = hostCookiesData } else { - j.CookiesData[host] = append(hostCookiesData, cookie) + jar.CookiesData[host] = append(hostCookiesData, cookie) } } // SetCookies - set cookies -func (j *Jar) SetCookies(u *url.URL, cookies []*http.Cookie) { - j.lk.Lock() +func (jar *Jar) SetCookies(u *url.URL, cookies []*http.Cookie) { + jar.lock.Lock() for i := 0; i < len(cookies); i++ { - j.addCookie(u.Host, cookies[i]) + jar.addCookie(u.Host, cookies[i]) } - j.lk.Unlock() + jar.lock.Unlock() } // Cookies - get cookie -func (j *Jar) Cookies(u *url.URL) []*http.Cookie { - return j.CookiesData[u.Host] +func (jar *Jar) Cookies(u *url.URL) []*http.Cookie { + return jar.CookiesData[u.Host] } // HTTPClient - http client @@ -144,49 +144,49 @@ func newProxyTransport(proxyAddr string) *http.Transport { return &http.Transport{Dial: tbDialer.Dial} } -func (h *HTTPClient) serialze() { - jar := h.jar +func (httpClient *HTTPClient) serialize() { + jar := httpClient.jar jsonData, err := com.JsonEncode(jar) - if err == nil && h.cookiePath != "" { - com.WriteFile(h.cookiePath, string(jsonData)) + if err == nil && httpClient.cookiePath != "" { + com.WriteFile(httpClient.cookiePath, string(jsonData)) } } // Post - post method -func (h *HTTPClient) Post(urlstr string, parm url.Values) (string, error) { - resp, err := h.client.PostForm(urlstr, parm) +func (httpClient *HTTPClient) Post(urlstr string, parm url.Values) (string, error) { + resp, err := httpClient.client.PostForm(urlstr, parm) if err != nil { return "", err } - b, err := ioutil.ReadAll(resp.Body) + body, err := ioutil.ReadAll(resp.Body) resp.Body.Close() if err != nil { return "", err } - h.serialze() - return string(b), err + httpClient.serialize() + return string(body), err } // Get - get method -func (h *HTTPClient) Get(urlstr string) (string, error) { - resp, err := h.client.Get(urlstr) +func (httpClient *HTTPClient) Get(urlstr string) (string, error) { + resp, err := httpClient.client.Get(urlstr) if err != nil { return "", err } - b, err := ioutil.ReadAll(resp.Body) + body, err := ioutil.ReadAll(resp.Body) resp.Body.Close() if err != nil { return "", err } - h.serialze() - return string(b), err + httpClient.serialize() + return string(body), err } // Download download file to path -func (h *HTTPClient) Download(urlstr, path string) error { +func (httpClient *HTTPClient) Download(urlstr, path string) error { var err error directory := filepath.Dir(path) if !file.IsExist(directory) { @@ -195,22 +195,22 @@ func (h *HTTPClient) Download(urlstr, path string) error { return err } } - resp, err := h.client.Get(urlstr) + resp, err := httpClient.client.Get(urlstr) if err != nil { return err } fmt.Println(urlstr, resp.Status) - file, err := os.Create(path) + outputFile, err := os.Create(path) if err != nil { return err } - _, err = io.Copy(file, resp.Body) + _, err = io.Copy(outputFile, resp.Body) if err!=nil { fmt.Println("io copy error") return err } - err = file.Sync() + err = outputFile.Sync() if err != nil { fmt.Println("io sync error") } @@ -218,6 +218,6 @@ func (h *HTTPClient) Download(urlstr, path string) error { } // Do http client do method -func (h *HTTPClient) Do(r *http.Request) (*http.Response, error) { - return h.client.Do(r) +func (httpClient *HTTPClient) Do(request *http.Request) (*http.Response, error) { + return httpClient.client.Do(request) } diff --git a/log/log.go b/log/log.go index a06daae..8da0482 100644 --- a/log/log.go +++ b/log/log.go @@ -26,153 +26,153 @@ var ( Debug bool = true ) -func Warnf(format string, v ...interface{}) (n int, err error) { +func Warnf(format string, values ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintf(YELLOW, format, v...) - return n, err + bytesWritten, err = Cprintf(YELLOW, format, values...) + return bytesWritten, err } -func Yellowf(format string, v ...interface{}) (n int, err error) { - return Warnf(format, v...) +func Yellowf(format string, values ...interface{}) (bytesWritten int, err error) { + return Warnf(format, values...) } -func Dangerf(format string, v ...interface{}) (n int, err error) { +func Dangerf(format string, values ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintf(RED, format, v...) - return n, err + bytesWritten, err = Cprintf(RED, format, values...) + return bytesWritten, err } -func Redf(format string, v ...interface{}) (n int, err error) { - return Dangerf(format, v...) +func Redf(format string, values ...interface{}) (bytesWritten int, err error) { + return Dangerf(format, values...) } -func Finef(format string, v ...interface{}) (n int, err error) { +func Finef(format string, values ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintf(GREEN, format, v...) - return n, err + bytesWritten, err = Cprintf(GREEN, format, values...) + return bytesWritten, err } -func Greenf(format string, v ...interface{}) (n int, err error) { - return Finef(format, v...) +func Greenf(format string, values ...interface{}) (bytesWritten int, err error) { + return Finef(format, values...) } -func Bluef(format string, v ...interface{}) (n int, err error) { +func Bluef(format string, values ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintf(BLUE, format, v...) - return n, err + bytesWritten, err = Cprintf(BLUE, format, values...) + return bytesWritten, err } -func Infof(format string, v ...interface{}) (n int, err error) { - return Bluef(format, v...) +func Infof(format string, values ...interface{}) (bytesWritten int, err error) { + return Bluef(format, values...) } -func Pinkf(format string, v ...interface{}) (n int, err error) { +func Pinkf(format string, values ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintf(PINK, format, v...) - return n, err + bytesWritten, err = Cprintf(PINK, format, values...) + return bytesWritten, err } // line -func Warnln(a ...interface{}) (n int, err error) { +func Warnln(args ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintln(YELLOW, a...) - return n, err + bytesWritten, err = Cprintln(YELLOW, args...) + return bytesWritten, err } -func Yellowln(a ...interface{}) (n int, err error) { - return Warnln(a...) +func Yellowln(args ...interface{}) (bytesWritten int, err error) { + return Warnln(args...) } -func Dangerln(a ...interface{}) (n int, err error) { +func Dangerln(args ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintln(RED, a...) - return n, err + bytesWritten, err = Cprintln(RED, args...) + return bytesWritten, err } -func Redln(a ...interface{}) (n int, err error) { - return Dangerln(a...) +func Redln(args ...interface{}) (bytesWritten int, err error) { + return Dangerln(args...) } -func Fineln(a ...interface{}) (n int, err error) { +func Fineln(args ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintln(GREEN, a...) - return n, err + bytesWritten, err = Cprintln(GREEN, args...) + return bytesWritten, err } -func Greenln(a ...interface{}) (n int, err error) { - return Fineln(a...) +func Greenln(args ...interface{}) (bytesWritten int, err error) { + return Fineln(args...) } -func Blueln(a ...interface{}) (n int, err error) { +func Blueln(args ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintln(BLUE, a...) - return n, err + bytesWritten, err = Cprintln(BLUE, args...) + return bytesWritten, err } -func Infoln(a ...interface{}) (n int, err error) { - return Blueln(a...) +func Infoln(args ...interface{}) (bytesWritten int, err error) { + return Blueln(args...) } -func Pinkln(a ...interface{}) (n int, err error) { +func Pinkln(args ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - n, err = Cprintln(PINK, a...) - return n, err + bytesWritten, err = Cprintln(PINK, args...) + return bytesWritten, err } // fatal -func Fatalf(format string, v ...interface{}) { - Dangerf(format, v...) +func Fatalf(format string, values ...interface{}) { + Dangerf(format, values...) os.Exit(1) } -func Fatal(v ...interface{}) { - Dangerln(v...) +func Fatal(values ...interface{}) { + Dangerln(values...) os.Exit(1) } -func Fatalln(v ...interface{}) { - Dangerln(v...) +func Fatalln(values ...interface{}) { + Dangerln(values...) os.Exit(1) } -func Println(a ...interface{}) (n int, err error) { +func Println(args ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - return fmt.Println(a...) + return fmt.Println(args...) } -func Printf(format string, v ...interface{}) (n int, err error) { +func Printf(format string, values ...interface{}) (bytesWritten int, err error) { if !Debug { return 0, nil } - return fmt.Printf(format, v...) + return fmt.Printf(format, values...) } diff --git a/log/logger.go b/log/logger.go index b46a08d..918cd29 100644 --- a/log/logger.go +++ b/log/logger.go @@ -15,51 +15,51 @@ func New(out io.Writer, prefix string, flag int) *Logger { return New(out, prefix, flag) } -func (l *Logger) Fatal(v ...interface{}) { - l.Logger.Output(2, fmt.Sprint(v...)) +func (logger *Logger) Fatal(values ...interface{}) { + logger.Logger.Output(2, fmt.Sprint(values...)) os.Exit(1) } -func (l *Logger) Fatalf(format string, v ...interface{}) { - l.Logger.Output(2, fmt.Sprintf(format, v...)) +func (logger *Logger) Fatalf(format string, values ...interface{}) { + logger.Logger.Output(2, fmt.Sprintf(format, values...)) os.Exit(1) } -func (l *Logger) Fatalln(v ...interface{}) { - l.Logger.Output(2, fmt.Sprintln(v...)) +func (logger *Logger) Fatalln(values ...interface{}) { + logger.Logger.Output(2, fmt.Sprintln(values...)) os.Exit(1) } -func (l *Logger) Panic(v ...interface{}) { - s := fmt.Sprint(v...) - l.Logger.Output(2, s) - panic(s) +func (logger *Logger) Panic(values ...interface{}) { + message := fmt.Sprint(values...) + logger.Logger.Output(2, message) + panic(message) } -func (l *Logger) Panicf(format string, v ...interface{}) { - s := fmt.Sprintf(format, v...) - l.Logger.Output(2, s) - panic(s) +func (logger *Logger) Panicf(format string, values ...interface{}) { + message := fmt.Sprintf(format, values...) + logger.Logger.Output(2, message) + panic(message) } -func (l *Logger) Panicln(v ...interface{}) { - s := fmt.Sprintln(v...) - l.Logger.Output(2, s) - panic(s) +func (logger *Logger) Panicln(values ...interface{}) { + message := fmt.Sprintln(values...) + logger.Logger.Output(2, message) + panic(message) } -func (l *Logger) Flags() int { - return l.Logger.Flags() +func (logger *Logger) Flags() int { + return logger.Logger.Flags() } -func (l *Logger) SetFlags(flag int) { - l.Logger.SetFlags(flag) +func (logger *Logger) SetFlags(flag int) { + logger.Logger.SetFlags(flag) } -func (l *Logger) Prefix() string { - return l.Logger.Prefix() +func (logger *Logger) Prefix() string { + return logger.Logger.Prefix() } -func (l *Logger) SetPrefix(prefix string) { - l.Logger.SetPrefix(prefix) +func (logger *Logger) SetPrefix(prefix string) { + logger.Logger.SetPrefix(prefix) } diff --git a/serialize.go b/serialize.go index 76ca183..f9c80ba 100644 --- a/serialize.go +++ b/serialize.go @@ -8,31 +8,31 @@ import ( // json编码 func JsonEncode(data interface{}) (string, error) { - a, err := json.Marshal(data) - return string(a), err + jsonBytes, err := json.Marshal(data) + return string(jsonBytes), err } // json解码 func JsonDecode(data string) (interface{}, error) { dataByte := []byte(data) - var dat interface{} + var decoded interface{} - err := json.Unmarshal(dataByte, &dat) - return dat, err + err := json.Unmarshal(dataByte, &decoded) + return decoded, err } func Encode(data interface{}) ([]byte, error) { - buf := bytes.NewBuffer(nil) - enc := gob.NewEncoder(buf) - err := enc.Encode(data) + buffer := bytes.NewBuffer(nil) + encoder := gob.NewEncoder(buffer) + err := encoder.Encode(data) if err != nil { return nil, err } - return buf.Bytes(), nil + return buffer.Bytes(), nil } func Decode(data []byte, to interface{}) error { - buf := bytes.NewBuffer(data) - dec := gob.NewDecoder(buf) - return dec.Decode(to) + buffer := bytes.NewBuffer(data) + decoder := gob.NewDecoder(buffer) + return decoder.Decode(to) } diff --git a/stream/token.go b/stream/token.go index a65e30b..0f7b967 100644 --- a/stream/token.go +++ b/stream/token.go @@ -16,29 +16,29 @@ func NewTokenStream[T any](input []T) TokenStream[T] { return &commonTokenStream[T]{tokens: input, pos: -1} } -func (s *commonTokenStream[T]) Next() *T { - if s.pos < len(s.tokens)-1 { - s.pos++ - return &s.tokens[s.pos] +func (stream *commonTokenStream[T]) Next() *T { + if stream.pos < len(stream.tokens)-1 { + stream.pos++ + return &stream.tokens[stream.pos] } return nil } -func (s *commonTokenStream[T]) Prev() *T { - if s.pos > 0 { - s.pos-- - return &s.tokens[s.pos] +func (stream *commonTokenStream[T]) Prev() *T { + if stream.pos > 0 { + stream.pos-- + return &stream.tokens[stream.pos] } return nil } -func (s *commonTokenStream[T]) Peek() *T { - if s.pos < len(s.tokens)-1 { - return &s.tokens[s.pos+1] +func (stream *commonTokenStream[T]) Peek() *T { + if stream.pos < len(stream.tokens)-1 { + return &stream.tokens[stream.pos+1] } return nil } -func (s *commonTokenStream[T]) EOF() bool { - return s.pos == len(s.tokens)-1 +func (stream *commonTokenStream[T]) EOF() bool { + return stream.pos == len(stream.tokens)-1 } diff --git a/string.go b/string.go index 0eddfad..13521fe 100644 --- a/string.go +++ b/string.go @@ -15,31 +15,31 @@ import ( // CreateGUID 创建GUID func CreateGUID() string { - b := make([]byte, 32) - if _, err := io.ReadFull(rand.Reader, b); err != nil { + randomBytes := make([]byte, 32) + if _, err := io.ReadFull(rand.Reader, randomBytes); err != nil { return "" } - return base64.URLEncoding.EncodeToString(b) + return base64.URLEncoding.EncodeToString(randomBytes) } // SubString 截取子串 func SubString(str string, begin, length int) (substr string) { - rs := []rune(str) - lth := len(rs) + runes := []rune(str) + runeLength := len(runes) if begin < 0 { begin = 0 } - if begin >= lth { - begin = lth + if begin >= runeLength { + begin = runeLength } end := begin + length - if end > lth { - end = lth + if end > runeLength { + end = runeLength } - return string(rs[begin:end]) + return string(runes[begin:end]) } // RandString 创建随机串 @@ -68,16 +68,16 @@ func CheckUsername(username string) bool { // Md5 MD5加密 func Md5(value string) string { - h := md5.New() - h.Write([]byte(value)) - return fmt.Sprintf("%s", hex.EncodeToString(h.Sum(nil))) + hash := md5.New() + hash.Write([]byte(value)) + return fmt.Sprintf("%s", hex.EncodeToString(hash.Sum(nil))) } // Sha1 对字符串进行sha1 计算 func Sha1(data string) string { - t := sha1.New() - io.WriteString(t, data) - return fmt.Sprintf("%x", t.Sum(nil)) + sha1Hash := sha1.New() + io.WriteString(sha1Hash, data) + return fmt.Sprintf("%x", sha1Hash.Sum(nil)) } // Strim 去除空白符 @@ -90,23 +90,23 @@ func Strim(str string) string { } // Unicode 转 unicode 编码 -func Unicode(rs string) string { - json := "" - for _, r := range rs { - rint := int(r) - if rint < 128 { - json += string(r) +func Unicode(inputString string) string { + result := "" + for _, r := range inputString { + runeInt := int(r) + if runeInt < 128 { + result += string(r) } else { - json += "\\u" + strconv.FormatInt(int64(rint), 16) + result += "\\u" + strconv.FormatInt(int64(runeInt), 16) } } - return json + return result } // HTMLEncode 对字符串进行HTML编码 -func HTMLEncode(rs string) string { +func HTMLEncode(inputString string) string { html := "" - for _, r := range rs { + for _, r := range inputString { html += "&#" + strconv.Itoa(int(r)) + ";" } return html @@ -114,14 +114,14 @@ func HTMLEncode(rs string) string { // StringToBytes converts string to byte slice without a memory allocation. // For more details, see https://github.com/golang/go/issues/53003#issuecomment-1140276077. -func StringToBytes(s string) []byte { - return *(*[]byte)(unsafe.Pointer(&s)) +func StringToBytes(str string) []byte { + return *(*[]byte)(unsafe.Pointer(&str)) } // BytesToString converts byte slice to string without a memory allocation. // For more details, see https://github.com/golang/go/issues/53003#issuecomment-1140276077. -func BytesToString(b []byte) string { - return *(*string)(unsafe.Pointer(&b)) +func BytesToString(bytes []byte) string { + return *(*string)(unsafe.Pointer(&bytes)) } func UniqueStrings(input []string) []string { diff --git a/time/time.go b/time/time.go index 6ba83ee..991166b 100644 --- a/time/time.go +++ b/time/time.go @@ -9,11 +9,11 @@ import ( func Tonight() time.Time { now := time.Now() date := fmt.Sprintf("%04d-%02d-%02d", now.Year(), now.Month(), now.Day()) - pt, _ := time.Parse("2006-01-02", date) - return pt + parsedTime, _ := time.Parse("2006-01-02", date) + return parsedTime } // Days get d days period -func Days(d int) (time.Duration, error) { - return time.ParseDuration(fmt.Sprintf("%dh", d*24)) +func Days(days int) (time.Duration, error) { + return time.ParseDuration(fmt.Sprintf("%dh", days*24)) }