gitee.com/quant1x/num@v0.3.2/type_bool.go (about)

     1  package num
     2  
     3  import (
     4  	"fmt"
     5  	"gitee.com/quant1x/gox/exception"
     6  	"gitee.com/quant1x/gox/logger"
     7  	"gitee.com/quant1x/num/x64"
     8  	"reflect"
     9  	"strconv"
    10  )
    11  
    12  const (
    13  	Nil2Bool              = false      // 空指针转bool
    14  	BoolNaN               = false      // bool 无效值
    15  	True2Bool             = true       // true转bool
    16  	False2Bool            = false      // false 转bool
    17  	True2Float32  float32 = float32(1) // true转float32
    18  	False2Float32 float32 = float32(0) // false转float32
    19  
    20  	StringBad2Bool   = false // 字符串解析bool异常
    21  	StringTrue2Bool  = true  // 字符串true转bool
    22  	StringFalse2Bool = false // 字符串false转bool
    23  )
    24  
    25  func StringIsTrue(s string) bool {
    26  	switch s {
    27  	case "true", "TRUE", "True":
    28  		return true
    29  	case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON":
    30  		return true
    31  	case "1":
    32  		return true
    33  	case "真", "对", "好":
    34  		return true
    35  	default:
    36  		return false
    37  	}
    38  }
    39  
    40  func StringIsFalse(s string) bool {
    41  	switch s {
    42  	case "false", "FALSE", "False":
    43  		return true
    44  	case "n", "N", "no", "No", "NO", "off", "Off", "OFF":
    45  		return true
    46  	case "0":
    47  		return true
    48  	case "假", "错", "坏":
    49  		return true
    50  	default:
    51  		return false
    52  	}
    53  }
    54  
    55  func BoolToInt(b bool) int8 {
    56  	if b {
    57  		return int8(1)
    58  	}
    59  	return int8(0)
    60  }
    61  
    62  func BoolToInt32(b bool) int32 {
    63  	if b {
    64  		return True2Int32
    65  	}
    66  	return False2Int32
    67  }
    68  
    69  func BoolToInt64(b bool) int64 {
    70  	if b {
    71  		return True2Int64
    72  	}
    73  	return False2Int64
    74  }
    75  
    76  // BoolToFloat32 bool转float32
    77  func BoolToFloat32(b bool) float32 {
    78  	if b {
    79  		return True2Float32
    80  	}
    81  	return False2Float32
    82  }
    83  
    84  // BoolToFloat64 bool转float64
    85  func BoolToFloat64(b bool) float64 {
    86  	if b {
    87  		return True2Float64
    88  	}
    89  	return False2Float64
    90  }
    91  
    92  // BoolToString bool 转 string
    93  func BoolToString(b bool) string {
    94  	if b {
    95  		return True2String
    96  	}
    97  	return False2String
    98  }
    99  
   100  // ParseBool 字符串转bool
   101  //
   102  //	任意组合的nan字符串都会被解析成NaN
   103  func ParseBool(s string, v any) bool {
   104  	defer func() {
   105  		// 解析失败以后输出日志, 以备检查
   106  		if err := recover(); err != nil {
   107  			logger.Errorf("ParseBool %+v, error=%+v\n", v, err)
   108  		}
   109  	}()
   110  	f, err := strconv.ParseBool(s)
   111  	if err != nil {
   112  		if IgnoreParseExceptions {
   113  			f = Nil2Bool
   114  		} else {
   115  			_ = v.(float64) // Intentionally panic
   116  		}
   117  	}
   118  	return f
   119  }
   120  
   121  // AnyToBool any转换bool
   122  func AnyToBool(v any) bool {
   123  	switch val := v.(type) {
   124  	case nil:
   125  		return Nil2Bool
   126  	case *bool:
   127  		if val == nil {
   128  			return Nil2Bool
   129  		}
   130  		if *val == true {
   131  			return True2Bool
   132  		}
   133  		return False2Bool
   134  	case bool:
   135  		if val == true {
   136  			return True2Bool
   137  		}
   138  		return False2Bool
   139  	case *int:
   140  		if val == nil {
   141  			return Nil2Bool
   142  		}
   143  		return integer2Bool[int](*val)
   144  	case int:
   145  		return integer2Bool[int](val)
   146  	case *int64:
   147  		if val == nil {
   148  			return Nil2Bool
   149  		}
   150  		return integer2Bool[int64](*val)
   151  	case int64:
   152  		return integer2Bool[int64](val)
   153  	case *float64:
   154  		if val == nil {
   155  			return Nil2Bool
   156  		}
   157  		return integer2Bool[float64](*val)
   158  	case float64:
   159  		return integer2Bool[float64](val)
   160  	case *string:
   161  		if val == nil {
   162  			return Nil2Bool
   163  		}
   164  		if IsEmpty(*val) {
   165  			return Nil2Bool
   166  		}
   167  		if StringIsTrue(*val) {
   168  			return StringTrue2Bool
   169  		} else if StringIsFalse(*val) {
   170  			return StringFalse2Bool
   171  		}
   172  		f := ParseBool(*val, v)
   173  		return f
   174  	case string:
   175  		if IsEmpty(val) {
   176  			return Nil2Bool
   177  		}
   178  		if StringIsTrue(val) {
   179  			return StringTrue2Bool
   180  		} else if StringIsFalse(val) {
   181  			return StringFalse2Bool
   182  		}
   183  		f := ParseBool(val, v)
   184  		return f
   185  	default:
   186  		f := ParseBool(fmt.Sprintf("%v", v), v)
   187  		return f
   188  	}
   189  }
   190  
   191  func slice_any_to_bool[T Number](s []T) []bool {
   192  	count := len(s)
   193  	if count == 0 {
   194  		return []bool{}
   195  	}
   196  	d := make([]bool, count)
   197  	for idx, iv := range s {
   198  		d[idx] = AnyToGeneric[bool](iv)
   199  	}
   200  	return d
   201  }
   202  
   203  // SliceToBool any输入只能是一维slice或者数组
   204  func SliceToBool(v any) []bool {
   205  	var vs []bool
   206  	switch values := v.(type) {
   207  	case []int8:
   208  		return slice_any_to_bool(values)
   209  	case []uint8:
   210  		return slice_any_to_bool(values)
   211  	case []int16:
   212  		return slice_any_to_bool(values)
   213  	case []uint16:
   214  		return slice_any_to_bool(values)
   215  	case []int32:
   216  		return slice_any_to_bool(values)
   217  	case []uint32:
   218  		return slice_any_to_bool(values)
   219  	case []int64:
   220  		return slice_any_to_bool(values)
   221  	case []uint64:
   222  		return slice_any_to_bool(values)
   223  	case []int:
   224  		return slice_any_to_bool(values)
   225  	case []uint:
   226  		return slice_any_to_bool(values)
   227  	case []float32: // 不能加速
   228  		return slice_any_to_bool(values)
   229  	case []float64: // 加速
   230  		return x64.ToBool(values)
   231  	case []bool:
   232  		// 加速
   233  		return values
   234  	case []string:
   235  		count := len(values)
   236  		if count == 0 {
   237  			return []bool{}
   238  		}
   239  		vs = make([]bool, count)
   240  		for idx, iv := range values {
   241  			vs[idx] = AnyToBool(iv)
   242  		}
   243  	default:
   244  		vv := reflect.ValueOf(v)
   245  		vk := vv.Kind()
   246  		panic(exception.New(errorFloat64Base+0, fmt.Sprintf("Unsupported type: %s", vk.String())))
   247  	}
   248  	return []bool{}
   249  }