Golang学习笔记（三）——数据类型转换

Go
字数统计: 1.9k   |   阅读时长≈ 8 分钟

作者: 杰克小麻雀
原文链接: https://blog.csdn.net/yushuaigee/article/details/106305233

强制类型转换

类似于其他语言，Go语言也支持强制类型转换：

20200523205009481.png

但是只有相同底层类型的变量之间可以进行相互转换（如将 int16 和 int32 相互转换，float 类型和 int 类型相互转换），不同底层类型的变量相互转换时会引发编译错误（如 bool 类型和 int 类型，string 与 int 类型之间的转换）： 

20200523200617332.png

字符串和数值类型的相互转换 (strconv)

如果需要string、int、int64、float 等数据类型之间的转换功能，可以使用标准包中的 strconv 包。

strconv 包中常用的函数包括 Atoi()**、Itia()、parse** 系列函数、format **系列函数、append **系列函数等。

Itoa()：整型转字符串

integer to alphanumeric

函数原型：

func Itoa(i int) string   

输入 int，输出 string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"
	"strconv"
)

func main() {
	num := 100
	str := strconv.Itoa(num)
	fmt.Printf("type:%T value:%#v\n", str, str)
}

//输出:
//type:string value:"100"

Atoi()：字符串转整型

alphanumeric to integer

函数原型：

func Atoi(s string) (i int, err error)

输入 string，输出 int 和 错误信息

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
package main

import (
	"fmt"
	"strconv"
)

func main() {
	str1 := "110"
	str2 := "s100"
	num1, err := strconv.Atoi(str1)
	if err != nil {
		fmt.Printf("%v 转换失败！", str1)
	} else {
		fmt.Printf("type:%T value:%#v\n", num1, num1)
	}
	num2, err := strconv.Atoi(str2)
	if err != nil {
		fmt.Printf("%v 转换失败！", str2)
	} else {
		fmt.Printf("type:%T value:%#v\n", num2, num2)
	}
}

//输出：
//type:int value:110
//s100 转换失败！

Parse 系列：str 转其他

ParseBool()

函数原型：

func ParseBool(str string) (value bool, err error)

它只能接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE，其它的值均返回错误。

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
package main

import (
	"fmt"
	"strconv"
)

func main() {
	str1 := "110"
	boo1, err := strconv.ParseBool(str1)
	if err != nil {
		fmt.Printf("str1: %v\n", err)
	} else {
		fmt.Println(boo1)
	}
	str2 := "t"
	boo2, err := strconv.ParseBool(str2)
	if err != nil {
		fmt.Printf("str2: %v\n", err)
	} else {
		fmt.Println(boo2)
	}
}

//输出：
//str1: strconv.ParseBool: parsing "110": invalid syntax
//true

ParseInt()

函数原型：

func ParseInt(s string, base int, bitSize int) (i int64, err error)

函数用于返回字符串表示的整数值，可以包含正负号。

参数说明：

  • base 指定进制，取值范围是 2 到 36。如果 base 为 0，则会从字符串前置判断，“0x” 是 16 进制，“0” 是 8 进制，否则是 10 进制。
  • bitSize 指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64。
  • 返回的 err 是 *NumErr 类型的，如果语法有误，err.Error = ErrSyntax，如果结果超出类型范围 err.Error = ErrRange。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package main

    import (
    	"fmt"
    	"strconv"
    )

    func main() {
    	str := "-11"
    	num, err := strconv.ParseInt(str, 10, 0)
    	if err != nil {
    		fmt.Println(err)
    	} else {
    		fmt.Println(num)
    	}
    }

    //输出：
    //-11

    ParseUint()

函数原型：

func ParseUint(s string, base int, bitSize int) (n uint64, err error)

函数用于返回字符串表示的整数值，但 ParseUint() 函数不接受正负号，用于无符号整型。

参数说明：(同ParseInt())

  • base 指定进制，取值范围是 2 到 36。如果 base 为 0，则会从字符串前置判断，“0x”是 16 进制，“0”是 8 进制，否则是 10 进制。
  • bitSize 指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64。
  • 返回的 err 是 *NumErr 类型的，如果语法有误，err.Error = ErrSyntax，如果结果超出类型范围 err.Error = ErrRange。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package main

    import (
    	"fmt"
    	"strconv"
    )

    func main() {
    	str := "11"
    	num, err := strconv.ParseUint(str, 10, 0)
    	if err != nil {
    		fmt.Println(err)
    	} else {
    		fmt.Println(num)
    	}
    }

    //输出：
    //11

    ParseFloat()

函数原型：

func ParseFloat(s string, bitSize int) (f float64, err error)

函数用于将一个表示浮点数的字符串转换为 float 类型。

参数说明：

  • 如果 s 合乎语法规则，函数会返回最为接近 s 表示值的一个浮点数（使用 IEEE754 规范舍入）。
  • bitSize 指定了返回值的类型，32 表示 float32，64 表示 float64；
  • 返回值 err 是 *NumErr 类型的，如果语法有误 err.Error=ErrSyntax，如果返回值超出表示范围，返回值 f 为 ±Inf，err.Error= ErrRange。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package main

    import (
    	"fmt"
    	"strconv"
    )

    func main() {
    	str := "3.1415926"
    	num, err := strconv.ParseFloat(str, 64)
    	if err != nil {
    		fmt.Println(err)
    	} else {
    		fmt.Println(num)
    	}
    }

    //输出：
    //3.1415926

    Format 系列：其他转 str

FormatBool()

函数原型：

func FormatBool(b bool) string

函数可以将一个 bool 类型的值转换为对应的字符串类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"
	"strconv"
)

func main() {
	num := true
	str := strconv.FormatBool(num)
	fmt.Printf("type:%T,value:%v\n ", str, str)
}

//输出：
//type:string,value:true

FormatInt()

函数原型：

func FormatInt(i int64, base int) string

函数用于将整型数据转换成指定进制并以字符串的形式返回。

参数说明：

  • 参数 i 必须是 int64 类型，参数 base 必须在 2 到 36 之间，返回结果中会使用小写字母“a”到“z”表示大于 10 的数字。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package main

    import (
    	"fmt"
    	"strconv"
    )

    func main() {
    	var num int64 = 100
    	str := strconv.FormatInt(num, 16)
    	fmt.Printf("type:%T,value:%v\n ", str, str)
    }

    //输出：
    //type:string,value:64

    FormatUint()

函数原型：

func FormatUint(i uint64, base int) string

函数用于将无符号的整型数据转换成指定进制并以字符串的形式返回。

参数说明：

  • 参数 i 必须是无符号的 uint64 类型，参数 base 必须在 2 到 36 之间，返回结果中会使用小写字母“a”到“z”表示大于 10 的数字。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package main

    import (
    	"fmt"
    	"strconv"
    )

    func main() {
    	var num uint64 = 110
    	str := strconv.FormatUint(num, 16)
    	fmt.Printf("type:%T,value:%v\n ", str, str)
    }

    //输出：
    //type:string,value:6e

    FormatFloat()

函数原型：

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

函数用于将浮点数转换为字符串类型并以字符串的形式返回。

参数说明：

  • bitSize 表示参数 f 的来源类型（32 表示 float32、64 表示 float64），会据此进行舍入。
  • fmt 表示格式，可以设置为“f”表示 -ddd.dddd、“b”表示 -ddddp±ddd，指数为二进制、“e”表示 -d.dddde±dd 十进制指数、“E”表示 -d.ddddE±dd 十进制指数、“g”表示指数很大时用“e”格式，否则“f”格式、“G”表示指数很大时用“E”格式，否则“f”格式。
  • prec 控制精度（排除指数部分）：当参数 fmt 为“f”、“e”、“E”时，它表示小数点后的数字个数；当参数 fmt 为“g”、“G”时，它控制总的数字个数。如果 prec 为 -1，则代表使用最少数量的、但又必需的数字来表示 f。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package main

    import (
    	"fmt"
    	"strconv"
    )

    func main() {
    	var num float64 = 3.1415926
    	str := strconv.FormatFloat(num, 'E', -1, 64)
    	fmt.Printf("type:%T,value:%v\n ", str, str)
    }

    //输出：
    //type:string,value:3.1415926E+00

    Append 系列：其他转 str 后加到切片中

Append 系列函数和 Format 系列函数的使用方法类似，只不过是将转换后的结果追加到一个切片中。

相比之下，入参多了一个 []string 类型的数组，返回值是加完元素的数组。

函数原型：

func FormatBool(slice []string, b bool) []string

func FormatInt(slice []string, i int64, base int) []sting

func FormatUint(slice []string, i uint64, base int)  []string

func FormatFloat(slice []string, f float64, fmt byte, prec, bitSize int) []string

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

import (
	"fmt"
	"strconv"
)

func main() {
	// 声明一个slice
	b10 := []byte("int (base 10):")

	// 将转换为10进制的string，追加到slice中
	b10 = strconv.AppendInt(b10, -42, 10)
	fmt.Println(string(b10))
	b16 := []byte("int (base 16):")
	b16 = strconv.AppendInt(b16, -42, 16)
	fmt.Println(string(b16))
}

//输出：
//int (base 10):-42
//int (base 16):-2a

参考链接

 Go语言strconv包：字符串和数值类型的相互转换

  • 版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！
  • Copyrights © 2020-2021 杰克小麻雀
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~

支付宝
微信