golang 作为强类型语言，我们在日常开发过程中，遇到类型转换的场景也非常多，本文整理我在工作开发中遇到过的类型转换实践。

# String To Other

• string to int

  • 方法一

    	str := "10"
    	int, err := strconv.Atoi(str)
    

    1
    2
    

  • 方法二

    	str := "10"
    	int, err := strconv.ParseInt(str, 10, 0)
    

    1
    2
    

• string to int8

  	str := "10"
  	int, err := strconv.ParseInt(str, 10, 8)
  

  1
  2
  

• string to int32

  int32 也叫做 rune

  	str := "10"
  	int, err := strconv.ParseInt(str, 10, 32)
  

  1
  2
  

• string to int64

  	str := "10"
  	int, err := strconv.ParseInt(str, 10, 64)
  

  1
  2
  

• string to float32

  	ret, _ := strconv.ParseFloat("3.14159", 32)
  	fmt.Println(ret)
  

  1
  2
  

• string to float64

  	ret, _ := strconv.ParseFloat("3.14159", 64)
  	fmt.Println(ret)
  

  1
  2
  

• string to []byte

  	s1 := "hello"
    b := []byte(s1)
  

  1
  2
  

• json string to map

  func JsonToMap(jsonStr string) (m map[string]string, err error) {
  	err = json.Unmarshal([]byte(jsonStr), &m)
  	if err != nil {
  		return nil, err
  	}
  	return
  }
  

  1
  2
  3
  4
  5
  6
  7
  

# Other To String

• []byte to string

  	var s1 []byte
  	fmt.Println(string(s1))
  

  1
  2
  

• int64 to string

  int, int32, int16, int8 转十进制字符串

  	var number int = 12 // 您可以在这里使用任何整数: int32, int16, int8
  	s := strconv.FormatInt(int64(123), 10)
  	fmt.Println(s)
  

  1
  2
  3
  

  要转换int为string也可以使用strconv.Itoa (opens new window)which 等价于strconv.FormatInt(int64(i), 10) (opens new window).

  	number := 12
  	str := strconv.Itoa(number)
  	fmt.Println(str)
  

  1
  2
  3
  

# Map To Other

• map to json string

  func MapToJson(m map[string]string) (string, error) {
  	result, err := json.Marshal(m)
  	if err != nil {
  		return "", nil
  	}
  	return string(result), nil
  }
  

  1
  2
  3
  4
  5
  6
  7
  

  通常也会使用一些第三方的 json 库进行解析，这里推荐：github.com/json-iterator/go (opens new window)

  package main
  
  import (
  	"fmt"
  
  	jsoniter "github.com/json-iterator/go"
  )
  
  var json = jsoniter.ConfigCompatibleWithStandardLibrary
  
  func main() {
  	tmpData := map[string]interface{}{"name": "eryajf", "age": 18}
  
  	output, err := json.Marshal(&tmpData)
  	if err != nil {
  		fmt.Println(err)
  	}
  	fmt.Println(string(output))
  }
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  

• map to slice

  func MapToSlice(m map[int]string) []string {
    s := make([]string, 0, len(m))
    for _, v := range m {
      s = append(s, v)
    }
    return s
  }
  

  1
  2
  3
  4
  5
  6
  7
  

# Json To Other

• json to map

  func JsonToMap() {
  	jsonStr := `{"name": "eryajf","age": 18}`
  	var mapResult map[string]interface{}
  	err := json.Unmarshal([]byte(jsonStr), &mapResult)
  	if err != nil {
  		fmt.Println("JsonToMap err: ", err)
  	}
  	fmt.Println(mapResult)
  }
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  

• json to struct

  package main
  
  import (
  	"encoding/json"
  	"fmt"
  )
  
  type People struct {
  	Name string `json:"name"`
  	Age int `json:"age"`
  }
  
  func main() {
  	jsonStr := `{"name": "eryajf","age": 18}`
  	var people People
  	json.Unmarshal([]byte(jsonStr), &people)
  	fmt.Println(people.Name, people.Age)
  }
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  

  使用第三方 JSON 库进行解析：

  package main
  
  import (
  	"fmt"
  
  	jsoniter "github.com/json-iterator/go"
  )
  
  type People struct {
  	Name string `json:"name"`
  	Age int `json:"age"`
  }
  
  func main() {
  	jsonStr := `{"name": "eryajf","age": 18}`
  	var people People
  	json.Unmarshal([]byte(jsonStr), &people)
  	fmt.Println(people.Name, people.Age)
  }
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  

# Struct To Other

• struct to json

  package main
  
  import (
  	"encoding/json"
  	"fmt"
  )
  
  type People struct {
  	Name string `json:"name"`
  	Age int `json:"age"`
  }
  
  func main() {
  	p := People{
  		Name: "eryajf",
  		Age:  18,
  	}
  	jsonBytes, err := json.Marshal(p)
  	if err != nil {
  		fmt.Println(err)
  	}
  	fmt.Println(string(jsonBytes))
  }
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  

  同理，这里仍旧可以借助第三方 JSON 库进行解析：

  package main
  
  import (
  	"fmt"
  
  	jsoniter "github.com/json-iterator/go"
  )
  
  var json = jsoniter.ConfigCompatibleWithStandardLibrary
  
  type People struct {
  	Name string `json:"name"`
  	Age  int    `json:"age"`
  }
  
  func main() {
  	p := People{
  		Name: "eryajf",
  		Age:  18,
  	}
  	jsonBytes, err := json.Marshal(p)
  	if err != nil {
  		fmt.Println(err)
  	}
  	fmt.Println(string(jsonBytes))
  }
  

  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
  

未完。。。