gitee.com/zhongguo168a/gocodes@v0.0.0-20230609140523-e1828349603f/datax/convertx/convertx.go (about)

     1  package convertx
     2  
     3  import (
     4  	"strconv"
     5  )
     6  
     7  func IntToString(ival interface{}) string {
     8  	val := ""
     9  	switch x := ival.(type) {
    10  	case int:
    11  		val = strconv.Itoa(x)
    12  	case int8:
    13  		val = strconv.Itoa(int(x))
    14  	case int16:
    15  		val = strconv.Itoa(int(x))
    16  	case int32:
    17  		val = strconv.Itoa(int(x))
    18  	case int64:
    19  		val = strconv.Itoa(int(x))
    20  	}
    21  	return val
    22  }
    23  
    24  func AnyToString(ival interface{}) string {
    25  	val := ""
    26  	switch x := ival.(type) {
    27  	case string:
    28  		val = x
    29  	case int:
    30  		val = strconv.Itoa(x)
    31  	case int8:
    32  		val = strconv.Itoa(int(x))
    33  	case int16:
    34  		val = strconv.Itoa(int(x))
    35  	case int32:
    36  		val = strconv.Itoa(int(x))
    37  	case int64:
    38  		val = strconv.Itoa(int(x))
    39  	case uint:
    40  		val = strconv.Itoa(int(x))
    41  	case uint8:
    42  		val = strconv.Itoa(int(x))
    43  	case uint16:
    44  		val = strconv.Itoa(int(x))
    45  	case uint32:
    46  		val = strconv.Itoa(int(x))
    47  	case uint64:
    48  		val = strconv.Itoa(int(x))
    49  	case float32:
    50  		val = strconv.Itoa(int(x))
    51  	case float64:
    52  		val = strconv.Itoa(int(x))
    53  	case bool:
    54  		if x {
    55  			val = "1"
    56  		} else {
    57  			val = "0"
    58  		}
    59  	}
    60  	return val
    61  }
    62  
    63  func AnyToBool(ival interface{}) bool {
    64  	switch data := ival.(type) {
    65  	case bool:
    66  		return ival.(bool)
    67  	case int:
    68  	case int8:
    69  	case int16:
    70  	case int32:
    71  	case int64:
    72  	case uint:
    73  	case uint8:
    74  	case uint16:
    75  	case uint32:
    76  	case uint64:
    77  	case float32:
    78  	case float64:
    79  		return data > 0
    80  	case string:
    81  		return data == "true" || data == "1"
    82  	default:
    83  	}
    84  
    85  	return false
    86  }
    87  
    88  func AnyToUint(ival interface{}) uint {
    89  	return uint(AnyToInt(ival))
    90  }
    91  
    92  func AnyToInt(ival interface{}) int {
    93  	val := int(0)
    94  	switch data := ival.(type) {
    95  	case int:
    96  		val = data
    97  	case int8:
    98  		val = int(data)
    99  	case int16:
   100  		val = int(data)
   101  	case int32:
   102  		val = int(data)
   103  	case int64:
   104  		val = int(data)
   105  	case uint:
   106  		val = int(data)
   107  	case uint8:
   108  		val = int(data)
   109  	case uint16:
   110  		val = int(data)
   111  	case uint32:
   112  		val = int(data)
   113  	case uint64:
   114  		val = int(data)
   115  	case float32:
   116  		val = int(data)
   117  	case float64:
   118  		val = int(data)
   119  	case string:
   120  		i, err := strconv.Atoi(data)
   121  		if err != nil {
   122  			val = 0
   123  		} else {
   124  			val = i
   125  		}
   126  	case bool:
   127  		if data {
   128  			val = 1
   129  		}
   130  	default:
   131  	}
   132  
   133  	return val
   134  }
   135  
   136  func AnyToInt64(ival interface{}) int64 {
   137  	val := int64(0)
   138  	switch data := ival.(type) {
   139  	case int:
   140  		val = int64(data)
   141  	case int8:
   142  		val = int64(data)
   143  	case int16:
   144  		val = int64(data)
   145  	case int32:
   146  		val = int64(data)
   147  	case int64:
   148  		val = data
   149  	case uint:
   150  		val = int64(data)
   151  	case uint8:
   152  		val = int64(data)
   153  	case uint16:
   154  		val = int64(data)
   155  	case uint32:
   156  		val = int64(data)
   157  	case uint64:
   158  		val = int64(data)
   159  	case float32:
   160  		val = int64(data)
   161  	case float64:
   162  		val = int64(data)
   163  	case string:
   164  		i, err := strconv.ParseFloat(data, 64)
   165  		if err != nil {
   166  			val = 0
   167  		} else {
   168  			val = int64(i + 0.5) // ε››θˆδΊ”ε…₯
   169  		}
   170  	case bool:
   171  		if data {
   172  			val = int64(1)
   173  		}
   174  	default:
   175  	}
   176  
   177  	return val
   178  }
   179  
   180  func AnyToFloat64(ival interface{}) float64 {
   181  	val := float64(0)
   182  	switch data := ival.(type) {
   183  	case int:
   184  		val = float64(data)
   185  	case int8:
   186  		val = float64(data)
   187  	case int16:
   188  		val = float64(data)
   189  	case int32:
   190  		val = float64(data)
   191  	case int64:
   192  		val = float64(data)
   193  	case uint:
   194  		val = float64(data)
   195  	case uint8:
   196  		val = float64(data)
   197  	case uint16:
   198  		val = float64(data)
   199  	case uint32:
   200  		val = float64(data)
   201  	case uint64:
   202  		val = float64(data)
   203  	case float32:
   204  		val = float64(data)
   205  	case float64:
   206  		val = data
   207  	case string:
   208  		i, err := strconv.ParseFloat(data, 64)
   209  		if err != nil {
   210  			val = 0
   211  		} else {
   212  			val = i
   213  		}
   214  	}
   215  
   216  	return val
   217  }