🍊柑橘 RSS 阅读器 - 鸿蒙首款原生 RSS 阅读器

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

未完。。。

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

未完。。。

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

未完。。。