crypto/aes.go

@@ -4,103 +4,70 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
-	"fmt"
 
 	"github.com/Luzifer/go-openssl/v3"
 )
 
-func addPKCS7Padding(ciphertext []byte, blockSize int) []byte {
+func paddingPKCS7(ciphertext []byte, blockSize int) []byte {
 	padding := blockSize - len(ciphertext)%blockSize
-	padText := bytes.Repeat([]byte{byte(padding)}, padding)
-	return append(ciphertext, padText...)
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
 }
 
-func removePKCS7Padding(data []byte) ([]byte, error) {
-	if len(data) == 0 {
-		return nil, fmt.Errorf("data cannot be empty")
-	}
-
-	padding := int(data[len(data)-1])
-
-	if padding > len(data) {
-		return nil, fmt.Errorf("invalid padding size")
-	}
-
-	return data[:len(data)-padding], nil
+func unpaddingPKCS7(origData []byte) []byte {
+	length := len(origData)
+	unpadding := int(origData[length-1])
+	return origData[:(length - unpadding)]
 }
 
-// EncryptAES 加密函式
+//EncryptAES 加密函式
 func EncryptAES(plaintext, key, iv []byte) ([]byte, error) {
-	// 驗證密鑰長度是否符合 AES 的要求
-	if len(key) != aes.BlockSize && len(key) != 16 && len(key) != 24 && len(key) != 32 {
-		return nil, fmt.Errorf("invalid key size: %d, expected 16, 24, or 32", len(key))
-	}
-
-	// 創建 AES 密碼器
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create AES cipher: %w", err)
+		return nil, err
 	}
-
-	// 確保輸入的資料長度符合 block size，並進行填充
 	blockSize := block.BlockSize()
-	plaintext = addPKCS7Padding(plaintext, blockSize)
-
-	// 創建 CBC 模式加密器
+	plaintext = paddingPKCS7(plaintext, blockSize)
 	blockMode := cipher.NewCBCEncrypter(block, iv)
-
-	// 用來保存加密結果的緩衝區
-	enc := make([]byte, len(plaintext))
-	blockMode.CryptBlocks(enc, plaintext)
-
-	return enc, nil
+	crypted := make([]byte, len(plaintext))
+	blockMode.CryptBlocks(crypted, plaintext)
+	return crypted, nil
 }
 
-// DecryptAES 使用 AES CBC 模式進行解密
+// DecryptAES 解密函式
 func DecryptAES(ciphertext, key, iv []byte) ([]byte, error) {
-	// 驗證密鑰長度是否符合 AES 的要求
-	if len(key) != aes.BlockSize && len(key) != 16 && len(key) != 24 && len(key) != 32 {
-		return nil, fmt.Errorf("invalid key size: %d, expected 16, 24, or 32", len(key))
-	}
-
-	// 創建 AES 密碼器
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create AES cipher: %w", err)
+		return nil, err
 	}
-
-	// 確保輸入的資料長度符合 block size，並進行解密
 	blockSize := block.BlockSize()
 	blockMode := cipher.NewCBCDecrypter(block, iv[:blockSize])
-
-	// 用來保存解密結果的緩衝區
 	origData := make([]byte, len(ciphertext))
 	blockMode.CryptBlocks(origData, ciphertext)
-
-	// 去除 PKCS7 填充
-	return removePKCS7Padding(origData)
+	origData = unpaddingPKCS7(origData)
+	return origData, nil
 }
 
-// EncryptAESWithOpenSSL 使用Openssl 加密AES
-func EncryptAESWithOpenSSL(value, key string) ([]byte, error) {
+// DecryptAESWithOpenSSL 使用Openssl 解密AES
+func DecryptAESWithOpenSSL(value, key string) ([]byte, error) {
 	o := openssl.New()
 
-	enc, err := o.EncryptBytes(key, []byte(value), openssl.DigestMD5Sum)
+	dec, err := o.DecryptBytes(key, []byte(value), openssl.DigestMD5Sum)
 	if err != nil {
-		return nil, fmt.Errorf("failed to encrypt with OpenSSL: %w", err)
+		return nil, err
 	}
 
-	return enc, nil
+	return dec, nil
 }
 
-// DecryptAESWithOpenSSL 使用Openssl 解密AES
-func DecryptAESWithOpenSSL(value, key string) ([]byte, error) {
+// EncryptAESWithOpenSSL 使用Openssl 加密AES
+func EncryptAESWithOpenSSL(value, key string) ([]byte, error) {
 	o := openssl.New()
 
-	dec, err := o.DecryptBytes(key, []byte(value), openssl.DigestMD5Sum)
+	enc, err := o.EncryptBytes(key, []byte(value), openssl.DigestMD5Sum)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decrypt with OpenSSL: %w", err)
+		return nil, err
 	}
 
-	return dec, nil
+	return enc, nil
 }

crypto/crypto.go

@@ -9,15 +9,24 @@ import (
 
 // MD5 回傳md5加密
 func MD5(v string) string {
-	return fmt.Sprintf("%x", md5.Sum([]byte(v)))
+	h := md5.New()
+	h.Write([]byte(v))
+	bs := h.Sum(nil)
+	return fmt.Sprintf("%x", bs)
 }
 
 // SHA1 回傳sha1加密
 func SHA1(v string) string {
-	return fmt.Sprintf("%x", sha1.Sum([]byte(v)))
+	h := sha1.New()
+	h.Write([]byte(v))
+	bs := h.Sum(nil)
+	return fmt.Sprintf("%x", bs)
 }
 
 // SHA256 回傳sha256加密
 func SHA256(v string) string {
-	return fmt.Sprintf("%x", sha256.Sum256([]byte(v)))
+	h := sha256.New()
+	h.Write([]byte(v))
+	bs := h.Sum(nil)
+	return fmt.Sprintf("%x", bs)
 }

crypto/password.go

@@ -1,8 +1,6 @@
 package crypto
 
 import (
-	"fmt"
-
 	"golang.org/x/crypto/bcrypt"
 )
 
@@ -10,7 +8,7 @@ import (
 func EncryptPassword(pwd string) (string, error) {
 	hash, err := bcrypt.GenerateFromPassword([]byte(pwd), bcrypt.DefaultCost)
 	if err != nil {
-		return "", fmt.Errorf("failed to encrypt password: %w", err)
+		return "", err
 	}
 
 	return string(hash), nil
@@ -18,12 +16,5 @@ func EncryptPassword(pwd string) (string, error) {
 
 // CheckPassword 檢查密碼
 func CheckPassword(pwd, hash string) error {
-	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(pwd))
-	if err != nil {
-		// 返回帶有更多上下文信息的錯誤
-		return fmt.Errorf("password does not match: %w", err)
-	}
-
-	// 如果密碼正確，返回 nil
-	return nil
+	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(pwd))
 }

crypto/rsa.go

@@ -6,20 +6,19 @@ import (
 	"crypto/x509"
 	"encoding/pem"
 	"errors"
-	"fmt"
 )
 
 func NewKeyRSA(bitSize int) (pubPEM []byte, keyPEM []byte, err error) {
-	// 生成 RSA 密鑰對
+	// Generate RSA key.
 	key, err := rsa.GenerateKey(rand.Reader, bitSize)
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to generate RSA key: %w", err)
+		return nil, nil, err
 	}
 
-	// 提取公鑰部分並轉換為 PEM 格式
+	// Extract public component.
 	pubBytes, err := x509.MarshalPKIXPublicKey(key.Public())
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to marshal public key: %w", err)
+		return nil, nil, err
 	}
 	pubPEM = pem.EncodeToMemory(
 		&pem.Block{
@@ -28,7 +27,7 @@ func NewKeyRSA(bitSize int) (pubPEM []byte, keyPEM []byte, err error) {
 		},
 	)
 
-	// 編碼私鑰為 PKCS#1 ASN.1 PEM 格式
+	// Encode private key to PKCS#1 ASN.1 PEM.
 	keyPEM = pem.EncodeToMemory(
 		&pem.Block{
 			Type:  "RSA PRIVATE KEY",
@@ -43,44 +42,29 @@ func NewKeyRSA(bitSize int) (pubPEM []byte, keyPEM []byte, err error) {
 func EncryptRSA(value, publicKey []byte) ([]byte, error) {
 	block, _ := pem.Decode(publicKey)
 	if block == nil {
-		return nil, errors.New("failed to decode public key PEM")
+		return nil, errors.New("public key error")
 	}
 
 	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
 	if err != nil {
-		return nil, fmt.Errorf("failed to parse public key: %w", err)
+		return nil, err
 	}
 
-	pub, ok := pubInterface.(*rsa.PublicKey)
-	if !ok {
-		return nil, errors.New("invalid public key type")
-	}
-
-	// 使用公鑰進行加密
-	enc, err := rsa.EncryptPKCS1v15(rand.Reader, pub, value)
-	if err != nil {
-		return nil, fmt.Errorf("failed to encrypt with RSA: %w", err)
-	}
-
-	return enc, nil
+	pub := pubInterface.(*rsa.PublicKey)
+	return rsa.EncryptPKCS1v15(rand.Reader, pub, value)
 }
 
 // DecryptRSA rsa解密
 func DecryptRSA(ciphertext, privateKey []byte) ([]byte, error) {
 	block, _ := pem.Decode(privateKey)
 	if block == nil {
-		return nil, errors.New("failed to decode private key PEM")
+		return nil, errors.New("private key error")
 	}
 
 	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
 	if err != nil {
-		return nil, fmt.Errorf("failed to parse private key: %w", err)
-	}
-
-	dec, err := rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decrypt with RSA: %w", err)
+		return nil, err
 	}
 
-	return dec, nil
+	return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
 }

generate/generate.go

@@ -2,37 +2,52 @@ package generate
 
 import (
 	"crypto/rand"
-	"fmt"
+	"math/big"
 )
 
 // GetRandomString 取得隨機字串
 func GetRandomString(n int) (string, error) {
 	const alphaNum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-	return getRandomFromCharset(n, alphaNum)
+
+	buffer := make([]byte, n)
+	max := big.NewInt(int64(len(alphaNum)))
+
+	for i := 0; i < n; i++ {
+		index, err := randomInt(max)
+		if err != nil {
+			return "", err
+		}
+
+		buffer[i] = alphaNum[index]
+	}
+
+	return string(buffer), nil
 }
 
 // GetRandomKey 取得隨機金鑰
 func GetRandomKey(n int) (string, error) {
 	const alphaNum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@#$%^&*()-_=+"
-	return getRandomFromCharset(n, alphaNum)
-}
 
-// getRandomFromCharset 通用隨機字串生成器
-func getRandomFromCharset(n int, charset string) (string, error) {
-	// 預先計算字符集的長度
-	charsLen := len(charset)
 	buffer := make([]byte, n)
+	max := big.NewInt(int64(len(alphaNum)))
 
-	// 使用 crypto/rand 生成隨機數據
-	_, err := rand.Read(buffer)
+	for i := 0; i < n; i++ {
+		index, err := randomInt(max)
 		if err != nil {
-		return "", fmt.Errorf("failed to generate random data: %w", err)
+			return "", err
 		}
 
-	// 從字元集選擇字符
-	for i := 0; i < n; i++ {
-		buffer[i] = charset[int(buffer[i])%charsLen]
+		buffer[i] = alphaNum[index]
 	}
 
 	return string(buffer), nil
 }
+
+func randomInt(max *big.Int) (int, error) {
+	random, err := rand.Int(rand.Reader, max)
+	if err != nil {
+		return 0, err
+	}
+
+	return int(random.Int64()), nil
+}

image/image.go

@@ -6,6 +6,7 @@ import (
 	"image/jpeg"
 	"image/png"
 	"io"
+	"io/ioutil"
 	"mime/multipart"
 	"os"
 )
@@ -13,42 +14,31 @@ import (
 // CompressImage 壓縮圖片至指定位置
 func CompressImage(input interface{}, output string) (err error) {
 	var file io.Reader
-	var fileToClose io.Closer
-
-	switch v := input.(type) {
+	switch input.(type) {
 	case string:
-		f, err := os.Open(v)
-		if err != nil {
+		if file, err = os.Open(input.(string)); err != nil {
 			return err
 		}
-
-		file = f
-		fileToClose = f
 		defer func() {
-			if fileToClose != nil {
-				_ = fileToClose.Close()
-			}
-			_ = os.Remove(v)
+			_ = file.(*os.File).Close()
 		}()
+		defer os.Remove(input.(string))
+
 	case *multipart.FileHeader:
-		f, err := v.Open()
+		fileHeader := input.(*multipart.FileHeader)
+		file, err = fileHeader.Open()
 		if err != nil {
 			return err
 		}
-		file = f
-		fileToClose = f
 		defer func() {
-			if fileToClose != nil {
-				_ = fileToClose.Close()
-			}
+			_ = file.(multipart.File).Close()
 		}()
 	}
 
-	var buf bytes.Buffer
-	if _, err = io.Copy(&buf, file); err != nil {
+	bs, err := ioutil.ReadAll(file)
+	if err != nil {
 		return err
 	}
-	bs := buf.Bytes()
 
 	var ext string
 	if _, err = jpeg.Decode(bytes.NewReader(bs)); err == nil {
@@ -63,11 +53,7 @@ func CompressImage(input interface{}, output string) (err error) {
 	if err != nil {
 		return err
 	}
-	defer func() {
-		if outputFile != nil {
-			_ = outputFile.Close()
-		}
-	}()
+	defer outputFile.Close()
 
 	switch ext {
 	case "jpg":
@@ -75,22 +61,34 @@ func CompressImage(input interface{}, output string) (err error) {
 		if err != nil {
 			return err
 		}
-		return jpeg.Encode(outputFile, img, &jpeg.Options{Quality: 70})
+		if err = jpeg.Encode(outputFile, img, &jpeg.Options{Quality: 70}); err != nil {
+			return err
+		}
+
 	case "png":
 		img, err := png.Decode(bytes.NewReader(bs))
 		if err != nil {
 			return err
 		}
 		encoder := png.Encoder{CompressionLevel: png.BestCompression}
-		return encoder.Encode(outputFile, img)
+		if err = encoder.Encode(outputFile, img); err != nil {
+			return err
+		}
+
 	case "gif":
 		img, err := gif.DecodeAll(bytes.NewReader(bs))
 		if err != nil {
 			return err
 		}
-		return gif.EncodeAll(outputFile, img)
+		if err = gif.EncodeAll(outputFile, img); err != nil {
+			return err
+		}
+
 	default:
-		_, err = outputFile.Write(bs)
+		if _, err = outputFile.Write(bs); err != nil {
 			return err
 		}
+	}
+
+	return nil
 }

jwt/jwt.go

@@ -2,7 +2,6 @@ package jwt
 
 import (
 	"crypto/rsa"
-	"errors"
 	"fmt"
 
 	"git.simts.cc/common/lib/types"
@@ -12,14 +11,15 @@ import (
 // Encode jwt編碼
 func Encode(values types.Data, key string) (string, error) {
 	claims := jwt.MapClaims{}
-	for k, v := range values {
-		claims[k] = v
+	for key, value := range values {
+		claims[key] = value
 	}
 
-	tokenString, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).
+	tokenString, err := jwt.
+		NewWithClaims(jwt.SigningMethodHS256, claims).
 		SignedString([]byte(key))
 	if err != nil {
-		return "", fmt.Errorf("failed to sign JWT with HS256: %w", err)
+		return "", err
 	}
 
 	return tokenString, nil
@@ -28,14 +28,15 @@ func Encode(values types.Data, key string) (string, error) {
 // EncodeRS256 jwt編碼
 func EncodeRS256(values types.Data, key *rsa.PrivateKey) (string, error) {
 	claims := jwt.MapClaims{}
-	for k, v := range values {
-		claims[k] = v
+	for key, value := range values {
+		claims[key] = value
 	}
 
-	tokenString, err := jwt.NewWithClaims(jwt.SigningMethodRS256, claims).
+	tokenString, err := jwt.
+		NewWithClaims(jwt.SigningMethodRS256, claims).
 		SignedString(key)
 	if err != nil {
-		return "", fmt.Errorf("failed to sign JWT with RS256: %w", err)
+		return "", err
 	}
 
 	return tokenString, nil
@@ -45,27 +46,18 @@ func EncodeRS256(values types.Data, key *rsa.PrivateKey) (string, error) {
 func Decode(tokenString string, key string) (types.Data, error) {
 	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
 		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, fmt.Errorf("unexpected signing method: %w", token.Header["alg"])
+			return nil, fmt.Errorf("Unexpected error: %v. ", token.Header["alg"])
 		}
 		return []byte(key), nil
 	})
 	if err != nil {
-		return nil, fmt.Errorf("failed to parse JWT: %w", err)
-	}
-
-	if token == nil || !token.Valid {
-		return nil, fmt.Errorf("invalid token or claims")
+		return nil, err
 	}
 
 	claims, ok := token.Claims.(jwt.MapClaims)
-	if !ok {
-		return nil, fmt.Errorf("failed to parse token claims")
+	if !ok || !token.Valid {
+		return nil, fmt.Errorf("Token error. ")
 	}
 
 	return types.Data(claims), nil
 }
-
-// IsExpired 檢查 token 是否過期
-func IsExpired(err error) bool {
-	return errors.Is(err, jwt.ErrTokenExpired)
-}

logger/logger.go

@@ -0,0 +1,25 @@
+package logger
+
+import (
+	"go.uber.org/zap"
+)
+
+// NewLoggerProduction 正式版紀錄
+func NewLoggerProduction() (*zap.SugaredLogger, error) {
+	logger, err := zap.NewProduction()
+	if err != nil {
+		return nil, err
+	}
+
+	return logger.Sugar(), nil
+}
+
+// NewLoggerDevelopment 開發版紀錄
+func NewLoggerDevelopment() (*zap.SugaredLogger, error) {
+	logger, err := zap.NewDevelopment()
+	if err != nil {
+		return nil, err
+	}
+
+	return logger.Sugar(), nil
+}

types/data.go

@@ -24,50 +24,75 @@ func (data Data) Get(key string) (interface{}, error) {
 	return value, nil
 }
 
-// GetSlice 取得切片
-func (data Data) GetSlice(key string) (res Slice, err error) {
+// GetString 取得字串
+func (data Data) GetString(key string) (string, error) {
 	value, err := data.Get(key)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 
-	switch v := value.(type) {
-	case []interface{}:
-		return v, nil
+	switch value := value.(type) {
+	case []byte:
+		return string(value), nil
+	case string:
+		return value, nil
 	default:
-		return nil, ErrFormat
+		return "", ErrFormat
 	}
 }
 
-// MustGetSlice 強制取得切片
-func (data Data) MustGetSlice(key string) Slice {
-	values, _ := data.GetSlice(key)
-	return values
+// MustGetString 強制取得字串
+func (data Data) MustGetString(key string) string {
+	value, _ := data.GetString(key)
+	return value
 }
 
-// GetString 取得字串
-func (data Data) GetString(key string) (string, error) {
+// GetBytes 取得字串
+func (data Data) GetBytes(key string) ([]byte, error) {
 	value, err := data.Get(key)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 
 	switch value := value.(type) {
 	case []byte:
-		return string(value), nil
-	case string:
 		return value, nil
+	case string:
+		return []byte(value), nil
 	default:
-		return "", ErrFormat
+		return nil, ErrFormat
 	}
 }
 
-// MustGetString 強制取得字串
-func (data Data) MustGetString(key string) string {
-	value, _ := data.GetString(key)
+// MustGetBytes 強制取得字串
+func (data Data) MustGetBytes(key string) []byte {
+	value, _ := data.GetBytes(key)
 	return value
 }
 
+// GetSlice 取得切片
+func (data Data) GetSlice(key string) (res Slice, err error) {
+	value, err := data.Get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	switch value := value.(type) {
+	case []interface{}:
+		return Slice(value), nil
+	case Slice:
+		return value, nil
+	default:
+		return nil, ErrFormat
+	}
+}
+
+// MustGetSlice 強制取得切片
+func (data Data) MustGetSlice(key string) Slice {
+	values, _ := data.GetSlice(key)
+	return values
+}
+
 // GetStringSlice 取得字串切片
 func (data Data) GetStringSlice(key string) (res []string, err error) {
 	values, err := data.GetSlice(key)
@@ -93,27 +118,51 @@ func (data Data) MustGetStringSlice(key string) []string {
 	return values
 }
 
-// GetBytes 取得字串
-func (data Data) GetBytes(key string) ([]byte, error) {
-	value, err := data.Get(key)
+// GetIntSlice 取得整數切片
+func (data Data) GetIntSlice(key string) (res []int, err error) {
+	values, err := data.GetSlice(key)
 	if err != nil {
 		return nil, err
 	}
 
-	switch value := value.(type) {
-	case []byte:
-		return value, nil
-	case string:
-		return []byte(value), nil
+	for _, v := range values {
+		switch v := v.(type) {
+		case int:
+			res = append(res, int(v))
+		case uint:
+			res = append(res, int(v))
+		case int8:
+			res = append(res, int(v))
+		case uint8:
+			res = append(res, int(v))
+		case int16:
+			res = append(res, int(v))
+		case uint16:
+			res = append(res, int(v))
+		case int32:
+			res = append(res, int(v))
+		case uint32:
+			res = append(res, int(v))
+		case int64:
+			res = append(res, int(v))
+		case uint64:
+			res = append(res, int(v))
+		case float32:
+			res = append(res, int(v))
+		case float64:
+			res = append(res, int(v))
 		default:
 			return nil, ErrFormat
 		}
+	}
+
+	return res, nil
 }
 
-// MustGetBytes 強制取得字串
-func (data Data) MustGetBytes(key string) []byte {
-	value, _ := data.GetBytes(key)
-	return value
+// MustGetIntSlice 強制取得整數切片
+func (data Data) MustGetIntSlice(key string) []int {
+	values, _ := data.GetIntSlice(key)
+	return values
 }
 
 // GetData 取得資料
@@ -123,9 +172,11 @@ func (data Data) GetData(key string) (Data, error) {
 		return nil, err
 	}
 
-	switch v := value.(type) {
+	switch value := value.(type) {
 	case map[string]interface{}:
-		return v, nil
+		return Data(value), nil
+	case Data:
+		return value, nil
 	default:
 		return nil, ErrFormat
 	}
@@ -144,17 +195,17 @@ func (data Data) GetDataSlice(key string) ([]Data, error) {
 		return nil, err
 	}
 
-	var list []Data
-	for _, value := range values {
-		switch v := value.(type) {
+	var vals []Data
+	for _, v := range values {
+		switch v := v.(type) {
 		case map[string]interface{}:
-			list = append(list, v)
+			vals = append(vals, Data(v))
 		default:
 			return nil, ErrFormat
 		}
 	}
 
-	return list, nil
+	return vals, nil
 }
 
 // MustGetDataSlice 強制取得資料切片
@@ -186,53 +237,6 @@ func (data Data) MustGetFloat64(key string) float64 {
 	return value
 }
 
-// GetFloat64Slice 取得64位元浮點數切片
-func (data Data) GetFloat64Slice(key string) (res []float64, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, float64(v))
-		case uint:
-			res = append(res, float64(v))
-		case int8:
-			res = append(res, float64(v))
-		case uint8:
-			res = append(res, float64(v))
-		case int16:
-			res = append(res, float64(v))
-		case uint16:
-			res = append(res, float64(v))
-		case int32:
-			res = append(res, float64(v))
-		case uint32:
-			res = append(res, float64(v))
-		case int64:
-			res = append(res, float64(v))
-		case uint64:
-			res = append(res, float64(v))
-		case float32:
-			res = append(res, float64(v))
-		case float64:
-			res = append(res, v)
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetFloat64Slice 強制取得64位元浮點數切片
-func (data Data) MustGetFloat64Slice(key string) []float64 {
-	values, _ := data.GetFloat64Slice(key)
-	return values
-}
-
 // GetInt64 取得64位元整數
 func (data Data) GetInt64(key string) (int64, error) {
 	value, err := data.Get(key)
@@ -272,53 +276,6 @@ func (data Data) MustGetInt64(key string) int64 {
 	return value
 }
 
-// GetInt64Slice 取得64位元整數切片
-func (data Data) GetInt64Slice(key string) (res []int64, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, int64(v))
-		case uint:
-			res = append(res, int64(v))
-		case int8:
-			res = append(res, int64(v))
-		case uint8:
-			res = append(res, int64(v))
-		case int16:
-			res = append(res, int64(v))
-		case uint16:
-			res = append(res, int64(v))
-		case int32:
-			res = append(res, int64(v))
-		case uint32:
-			res = append(res, int64(v))
-		case int64:
-			res = append(res, v)
-		case uint64:
-			res = append(res, int64(v))
-		case float32:
-			res = append(res, int64(v))
-		case float64:
-			res = append(res, int64(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetInt64Slice 強制取得64位元整數切片
-func (data Data) MustGetInt64Slice(key string) []int64 {
-	values, _ := data.GetInt64Slice(key)
-	return values
-}
-
 // GetUint64 取得64位元正整數
 func (data Data) GetUint64(key string) (uint64, error) {
 	value, err := data.GetInt64(key)
@@ -339,53 +296,6 @@ func (data Data) MustGetUint64(key string) uint64 {
 	return value
 }
 
-// GetUint64Slice 取得64位元正整數切片
-func (data Data) GetUint64Slice(key string) (res []uint64, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, uint64(v))
-		case uint:
-			res = append(res, uint64(v))
-		case int8:
-			res = append(res, uint64(v))
-		case uint8:
-			res = append(res, uint64(v))
-		case int16:
-			res = append(res, uint64(v))
-		case uint16:
-			res = append(res, uint64(v))
-		case int32:
-			res = append(res, uint64(v))
-		case uint32:
-			res = append(res, uint64(v))
-		case int64:
-			res = append(res, uint64(v))
-		case uint64:
-			res = append(res, v)
-		case float32:
-			res = append(res, uint64(v))
-		case float64:
-			res = append(res, uint64(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetUint64Slice 強制取得64位元正整數切片
-func (data Data) MustGetUint64Slice(key string) []uint64 {
-	values, _ := data.GetUint64Slice(key)
-	return values
-}
-
 // GetInt 取得整數
 func (data Data) GetInt(key string) (int, error) {
 	value, err := data.GetInt64(key)
@@ -402,53 +312,6 @@ func (data Data) MustGetInt(key string) int {
 	return value
 }
 
-// GetIntSlice 取得整數切片
-func (data Data) GetIntSlice(key string) (res []int, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, v)
-		case uint:
-			res = append(res, int(v))
-		case int8:
-			res = append(res, int(v))
-		case uint8:
-			res = append(res, int(v))
-		case int16:
-			res = append(res, int(v))
-		case uint16:
-			res = append(res, int(v))
-		case int32:
-			res = append(res, int(v))
-		case uint32:
-			res = append(res, int(v))
-		case int64:
-			res = append(res, int(v))
-		case uint64:
-			res = append(res, int(v))
-		case float32:
-			res = append(res, int(v))
-		case float64:
-			res = append(res, int(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetIntSlice 強制取得整數切片
-func (data Data) MustGetIntSlice(key string) []int {
-	values, _ := data.GetIntSlice(key)
-	return values
-}
-
 // GetUint 取得正整數
 func (data Data) GetUint(key string) (uint, error) {
 	value, err := data.GetInt64(key)
@@ -469,53 +332,6 @@ func (data Data) MustGetUint(key string) uint {
 	return value
 }
 
-// GetUintSlice 取得正整數切片
-func (data Data) GetUintSlice(key string) (res []uint, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, uint(v))
-		case uint:
-			res = append(res, v)
-		case int8:
-			res = append(res, uint(v))
-		case uint8:
-			res = append(res, uint(v))
-		case int16:
-			res = append(res, uint(v))
-		case uint16:
-			res = append(res, uint(v))
-		case int32:
-			res = append(res, uint(v))
-		case uint32:
-			res = append(res, uint(v))
-		case int64:
-			res = append(res, uint(v))
-		case uint64:
-			res = append(res, uint(v))
-		case float32:
-			res = append(res, uint(v))
-		case float64:
-			res = append(res, uint(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetUintSlice 強制取得正整數切片
-func (data Data) MustGetUintSlice(key string) []uint {
-	values, _ := data.GetUintSlice(key)
-	return values
-}
-
 // GetInt16 取得16位元整數
 func (data Data) GetInt16(key string) (int16, error) {
 	value, err := data.GetInt64(key)
@@ -532,53 +348,6 @@ func (data Data) MustGetInt16(key string) uint16 {
 	return value
 }
 
-// GetInt16Slice 取得16位元整數切片
-func (data Data) GetInt16Slice(key string) (res []int16, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, int16(v))
-		case uint:
-			res = append(res, int16(v))
-		case int8:
-			res = append(res, int16(v))
-		case uint8:
-			res = append(res, int16(v))
-		case int16:
-			res = append(res, v)
-		case uint16:
-			res = append(res, int16(v))
-		case int32:
-			res = append(res, int16(v))
-		case uint32:
-			res = append(res, int16(v))
-		case int64:
-			res = append(res, int16(v))
-		case uint64:
-			res = append(res, int16(v))
-		case float32:
-			res = append(res, int16(v))
-		case float64:
-			res = append(res, int16(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetInt16Slice 強制取得16位元整數切片
-func (data Data) MustGetInt16Slice(key string) []int16 {
-	values, _ := data.GetInt16Slice(key)
-	return values
-}
-
 // GetUint16 取得16位元正整數
 func (data Data) GetUint16(key string) (uint16, error) {
 	value, err := data.GetInt64(key)
@@ -599,53 +368,6 @@ func (data Data) MustGetUint16(key string) uint16 {
 	return value
 }
 
-// GetUint16Slice 取得16位元正整數切片
-func (data Data) GetUint16Slice(key string) (res []uint16, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, uint16(v))
-		case uint:
-			res = append(res, uint16(v))
-		case int8:
-			res = append(res, uint16(v))
-		case uint8:
-			res = append(res, uint16(v))
-		case int16:
-			res = append(res, uint16(v))
-		case uint16:
-			res = append(res, v)
-		case int32:
-			res = append(res, uint16(v))
-		case uint32:
-			res = append(res, uint16(v))
-		case int64:
-			res = append(res, uint16(v))
-		case uint64:
-			res = append(res, uint16(v))
-		case float32:
-			res = append(res, uint16(v))
-		case float64:
-			res = append(res, uint16(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetUint16Slice 強制取得16位元正整數切片
-func (data Data) MustGetUint16Slice(key string) []uint16 {
-	values, _ := data.GetUint16Slice(key)
-	return values
-}
-
 // GetInt8 取得8位元整數
 func (data Data) GetInt8(key string) (int8, error) {
 	value, err := data.GetInt64(key)
@@ -662,53 +384,6 @@ func (data Data) MustGetInt8(key string) int8 {
 	return value
 }
 
-// GetInt8Slice 取得8位元整數切片
-func (data Data) GetInt8Slice(key string) (res []int8, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, int8(v))
-		case uint:
-			res = append(res, int8(v))
-		case int8:
-			res = append(res, v)
-		case uint8:
-			res = append(res, int8(v))
-		case int16:
-			res = append(res, int8(v))
-		case uint16:
-			res = append(res, int8(v))
-		case int32:
-			res = append(res, int8(v))
-		case uint32:
-			res = append(res, int8(v))
-		case int64:
-			res = append(res, int8(v))
-		case uint64:
-			res = append(res, int8(v))
-		case float32:
-			res = append(res, int8(v))
-		case float64:
-			res = append(res, int8(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetInt8Slice 強制取得8位元整數切片
-func (data Data) MustGetInt8Slice(key string) []int8 {
-	values, _ := data.GetInt8Slice(key)
-	return values
-}
-
 // GetUint8 取得8位元正整數
 func (data Data) GetUint8(key string) (uint8, error) {
 	value, err := data.GetInt64(key)
@@ -729,53 +404,6 @@ func (data Data) MustGetUint8(key string) uint8 {
 	return value
 }
 
-// GetUint8Slice 取得8位元正整數切片
-func (data Data) GetUint8Slice(key string) (res []uint8, err error) {
-	values, err := data.GetSlice(key)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, v := range values {
-		switch v := v.(type) {
-		case int:
-			res = append(res, uint8(v))
-		case uint:
-			res = append(res, uint8(v))
-		case int8:
-			res = append(res, uint8(v))
-		case uint8:
-			res = append(res, v)
-		case int16:
-			res = append(res, uint8(v))
-		case uint16:
-			res = append(res, uint8(v))
-		case int32:
-			res = append(res, uint8(v))
-		case uint32:
-			res = append(res, uint8(v))
-		case int64:
-			res = append(res, uint8(v))
-		case uint64:
-			res = append(res, uint8(v))
-		case float32:
-			res = append(res, uint8(v))
-		case float64:
-			res = append(res, uint8(v))
-		default:
-			return nil, ErrFormat
-		}
-	}
-
-	return res, nil
-}
-
-// MustGetUint8Slice 強制取得8位元正整數切片
-func (data Data) MustGetUint8Slice(key string) []uint8 {
-	values, _ := data.GetUint8Slice(key)
-	return values
-}
-
 // GetBool 取得布林值
 func (data Data) GetBool(key string) (bool, error) {
 	value, err := data.Get(key)
@@ -851,7 +479,7 @@ func (data Data) MustJSON() []byte {
 	return bs
 }
 
-// GetPage 取得頁數
+// Get 取得資料
 func (data Data) GetPage(key string) (*Page, error) {
 	value, err := data.Get(key)
 	if err != nil {
@@ -866,7 +494,7 @@ func (data Data) GetPage(key string) (*Page, error) {
 	return nil, ErrFormat
 }
 
-// MustGetPage 強制取得頁數
+// Get 取得資料
 func (data Data) MustGetPage(key string) *Page {
 	value, _ := data.GetPage(key)