# golang 常用数据类型转化，字符串，字节，int，float，map[string]interface{}，json，sql查询结果

# 其他类型转化为字符串

可以使用strconv包的方法，也可以用fmt，如果数据本身是interface的话就只能用fmt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
**interface string转化string：** fmt.Sprintf("%s", v)
**int转化string：** fmt.Sprintf("%d", v) 
或
string := strconv.Itoa(int)  string := strconv.FormatInt(int64,10)
**case float64:**
var km  = 9900.10 
strKm := strconv.FormatFloat(km, 'f', 1, 64)
或
fmt.Sprintf("%f", v) 
**case byte:**
string(v) 

# 32 byte转字符串

1
2
3
passwordSHA := sha256.Sum256([]byte(new_password))
password_hash := hex.EncodeToString(passwordSHA[:])
fmt.Println(password_hash)

字符串转byte byte转字符串

1
2
3
s1 := "hello"
b := []byte(s1)
C:=string(b)

字符串转化为其他类型

1
2
int64, err := strconv.ParseInt(string, 10, 64)
int, err := strconv.Atoi(string)

字符串转化float64 float32

1
2
3
float,err := strconv.ParseFloat(string,64)
float,err := strconv.ParseFloat(string,32)
#ParseFloat 只能返回float64，指定了32 也会返回float64非要用32 需要再次转化

float64转化int

1
2
3
4
5
var x float64 = 5.7
var y int = int(x)

var i float32 = 10.1 
var n int32 = int32(i)

int转化float

1
2
v1 := 99
v2 := float64(v2).

int和int64互转

1
2
int64_ := int64(1234)
int64转int 先转字符串 再转int

time转int

1
2
3
timestamp := time.Now().Unix()
fmt.Println(timestamp)
fmt.Sprintf("%d", v) 

map[string]interface{} 的一个数字转化为int 需要三步

1
2
3
4
5
user_id_string := fmt.Sprintf("%f", json_row_map[0]["user_id"])
user_id_float64, _ := strconv.ParseFloat(user_id_string , 64)
user_id_int := int(user_id_float64)
如果要拼接到sql 还需要再转到string
user_id_sql_string:=strconv.Itoa(user_id_int)

json 和 map互转

map转化json字符串

1
2
3
4
5
func MapToJson(param map[string]interface{}) string {
	dataType, _ := json.Marshal(param)
	dataString := string(dataType)
	return dataString
}

json 字符串转化为map

使用encoding/json库，性能比github.com/buger/jsonparser 要差一些 jsonparser 不知怎么转换

不带数组格式的json转map

1
2
3
4
5
6
7
8
func JsonToMap(str string) map[string]interface{} {
	var tempMap map[string]interface{}
	err := json.Unmarshal([]byte(str), &tempMap)
	if err != nil {
		fmt.Println(err)
	}
	return tempMap
} 

数组格式的json转map

1
2
3
4
5
6
7
8
func JsonArrToMap(str string) []map[string]interface{} {
	tempMap := make([]map[string]interface{}, 0)
	err := json.Unmarshal([]byte(str), &tempMap)
	if err != nil {
		fmt.Println(err)
	}
	return tempMap
} 

Sql查询结果转json字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
//db_r 是全局变量 var db_r       *sql.DB
func sql_to_json(sqlString string) (string, error) {
	stmt, err := db_r.Prepare(sqlString)
	if err != nil {
		return "", err
	}
	defer stmt.Close()
	rows, err := stmt.Query()
	if err != nil {
		return "", err
	}
	defer rows.Close()
	columns, err := rows.Columns()
	if err != nil {
		return "", err
	}
	count := len(columns)
	tableData := make([]map[string]interface{}, 0)
	values := make([]interface{}, count)
	valuePtrs := make([]interface{}, count)
	for rows.Next() {
		for i := 0; i < count; i++ {
			valuePtrs[i] = &values[i]
		}
		rows.Scan(valuePtrs...)
		entry := make(map[string]interface{})
		for i, col := range columns {
			var v interface{}
			val := values[i]
			b, ok := val.([]byte)
			if ok {
				v = string(b)
			} else {
				v = val
			}
			entry[col] = v
		}
		tableData = append(tableData, entry)
	}
	jsonData, err := json.Marshal(tableData)

	if err != nil {
		return "", err
	}
	//fmt.Println(string(jsonData))
	return string(jsonData), nil

}