go封装将所有数字类型转浮点型，可设置保留几位小数

封装转换方法

/*
*
* 将类型转浮点型，并保留小数
ToFloat(123, 2)
ToFloat(3.5254, 0)
*/
func ToFloat(value interface{}, precision int) (float64, error) {
	var f float64
	var err error

	switch v := value.(type) {
	case float64:
		f = v
	case float32:
		f = float64(v)
	case int:
		f = float64(v)
	case int32:
		f = float64(v)
	case int64:
		f = float64(v)
	case uint:
		f = float64(v)
	case uint64:
		f = float64(v)
	case string:
		f, err = strconv.ParseFloat(v, 64)
		if err != nil {
			return 0, fmt.Errorf("无法将字符串转换为浮点数: %v", err)
		}
	case bool:
		if v {
			f = 1
		} else {
			f = 0
		}
	default:
		return 0, fmt.Errorf("不支持的类型: %T", v)
	}

	// 处理精度
	if precision >= 0 {
		shift := math.Pow(10, float64(precision))
		f = math.Round(f*shift) / shift
	}
	return f, nil
}

使用

if m["state"] != nil && m["state"] != "" {
	state, _ := ToFloat(m["state"], 0)
	if state == 1 {
		where = fmt.Sprintf("%s and b.status='%s'", where, "1")
	}
	if state == 2 {
		where = fmt.Sprintf("%s and b.status='%s'", where, "2")
	}
}

使用

package main

import (
	"fmt"
	"utils"
)

func main() {
	// 示例 1: 转换整数并保留2位小数
	result, _ := utils.ToFloat(123, 2)
	fmt.Println(result) // 输出: 123.00

	// 示例 2: 转换字符串并保留3位小数
	result, _ = utils.ToFloat("3.14159", 3)
	fmt.Println(result) // 输出: 3.142 (四舍五入)

	// 示例 3: 转换布尔值
	result, _ = utils.ToFloat(true, 0)
	fmt.Println(result) // 输出: 1

	// 示例 4: 转换失败时返回默认值
	result = utils.ToFloatWithDefault("abc", 2, 0.0)
	fmt.Println(result) // 输出: 0
}

封装

package task

import (
	"fmt"
	"math"
	"strconv"
)

/*
将类型转浮点型，并保留小数
ToFloat(123, 2)
ToFloat(3.5254, 0)
*/
func ToFloat(value interface{}, precision int) (float64, error) {
	var f float64
	var err error

	switch v := value.(type) {
	case float64:
		f = v
	case float32:
		f = float64(v)
	case int:
		f = float64(v)
	case int32:
		f = float64(v)
	case int64:
		f = float64(v)
	case uint:
		f = float64(v)
	case uint64:
		f = float64(v)
	case string:
		f, err = strconv.ParseFloat(v, 64)
		if err != nil {
			return 0, fmt.Errorf("无法将字符串转换为浮点数: %v", err)
		}
	case bool:
		if v {
			f = 1
		} else {
			f = 0
		}
	default:
		return 0, fmt.Errorf("不支持的类型: %T", v)
	}

	// 处理精度
	if precision >= 0 {
		shift := math.Pow(10, float64(precision))
		f = math.Round(f*shift) / shift
	}
	return f, nil
}