61、Go 语言基础 - strconv 包

作者: 温新

分类: 【Go基础】

阅读: 1200

时间: 2023-12-05 00:56:25

hi，我是温析

strconv 是 Go 语言的内置包之一，主要用于在基本数据类型（例如字符串）和数字之间进行转换。strconv 包提供了一组函数，可用于处理各种类型的数据转换。

常用函数及其功能：

  • Atoi 和 Itoa：

    • Atoi 函数用于将字符串转换为整数。例如，将字符串 "123" 转换为整数 123。

    • Itoa 函数用于将整数转换为字符串。例如，将整数 123 转换为字符串 "123"。

  • ParseBool、FormatBool 和 AppendBool：

    • ParseBool 函数用于将字符串解析为布尔值。例如，将字符串 "true" 解析为布尔值 true。

    • FormatBool 函数用于将布尔值格式化为字符串。例如，将布尔值 true 格式化为字符串 "true"。

    • AppendBool 函数用于将布尔值追加到现有的字节切片中。

  • ParseFloat、FormatFloat 和 AppendFloat：

    • ParseFloat 函数用于将字符串解析为浮点数。

    • FormatFloat 函数用于将浮点数格式化为字符串。

    • AppendFloat 函数用于将浮点数追加到现有的字节切片中。

  • ParseInt、FormatInt 和 AppendInt：

    • ParseInt 函数用于将字符串解析为整数。

    • FormatInt 函数用于将整数格式化为字符串。

    • AppendInt 函数用于将整数追加到现有的字节切片中。

  • ParseUint、FormatUint 和 AppendUint：

    • ParseUint 函数用于将字符串解析为无符号整数。

    • FormatUint 函数用于将无符号整数格式化为字符串。

    • AppendUint 函数用于将无符号整数追加到现有的字节切片中。

  • Quote、QuoteToASCII、Unquote 和 IsPrint：

    • Quote 函数用于将字符串添加引号并进行转义。

    • QuoteToASCII 函数用于将字符串添加引号并进行 ASCII 转义。

    • Unquote 函数用于移除引号和反转义字符串。

    • IsPrint 函数用于检查字符串是否包含可打印字符。

  • CanBackquote 函数用于检查字符串是否可以包含在反引号字符串中。

string 与 int 类型转换

Atoi

Atoi()函数用于将字符串类型的整数转换为 int 类型。

func Atoi(s string) (int, error)
  • s 是要转换的字符串。
  • 返回值包括两部分：
    • int：表示转换后的整数值。
    • error：如果转换过程中出现错误，则返回一个非空的错误值；否则，返回 nil。
package main

import (
	"fmt"
	"strconv"
)

func main() {
	str := "12345"
	// 将字符串转换为整数
	num, err := strconv.Atoi(str)

	if err == nil {
		fmt.Printf("String '%s' converted to int: %d\n", str, num)
	} else {
		fmt.Printf("Conversion error: %v\n", err)
	}
}

Itoa

Itoa() 函数，用于将整数转换为对应的字符串。

func Itoa(i int) string
  • i 是要转换为字符串的整数值。
  • 返回值是一个字符串，表示整数值 i 的 ASCII 表示。
package main

import (
	"fmt"
	"strconv"
)

func main() {
	num := 1000
	// 将整数车为字符串
	str := strconv.Itoa(num)
	fmt.Printf("Integer %d converted to string: %s\n", num, str)
}

Parse 系列函数

Parse 类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()

ParseBool

ParseBool() 函数，用于将字符串解析为布尔值。其作用是尝试解析表示布尔值的字符串，并返回对应的布尔值和解析结果。

func ParseBool(str string) (bool, error)
  • str 是要解析的字符串。
  • 返回值包括两部分：
    • bool：表示解析后的布尔值。
    • error：如果解析成功，则返回 nil 错误；如果解析失败，则返回一个非空的错误值。
func main() {
	str1 := "true"
	str2 := "False"
	str3 := "invalid"

	// 解析字符串为布尔值
	boolValue1, err1 := strconv.ParseBool(str1)
	boolValue2, err2 := strconv.ParseBool(str2)
	boolValue3, err3 := strconv.ParseBool(str3)

	fmt.Printf("Parsing '%s' as bool: %v, error: %v\n", str1, boolValue1, err1)
	fmt.Printf("Parsing '%s' as bool: %v, error: %v\n", str2, boolValue2, err2)
	fmt.Printf("Parsing '%s' as bool: %v, error: %v\n", str3, boolValue3, err3)
}

ParseFloat

ParseFloat() 函数，用于将字符串解析为浮点数（float64 类型）。其作用是尝试解析表示浮点数的字符串，并返回对应的浮点数值和解析结果。

func ParseFloat(s string, bitSize int) (float64, error)
  • s 是要解析的字符串。
  • bitSize 指定浮点数的位数，通常应该为 32 或 64，表示解析为 float32 或 float64。如果 bitSize 不是有效值，会返回错误。
  • 返回值包括两部分：
    • float64：表示解析后的浮点数值。
    • error：如果解析成功，则返回 nil 错误；如果解析失败，则返回一个非空的错误值。
func main() {
	str1 := "3.14159"
	str2 := "2.71828"
	str3 := "invalid"

	// 解析字符串为浮点数（使用 64 位表示）
	floatValue1, err1 := strconv.ParseFloat(str1, 64)
	floatValue2, err2 := strconv.ParseFloat(str2, 64)
	floatValue3, err3 := strconv.ParseFloat(str3, 64)

	fmt.Printf("Parsing '%s' as float64: %f, error: %v\n", str1, floatValue1, err1)
	fmt.Printf("Parsing '%s' as float64: %f, error: %v\n", str2, floatValue2, err2)
	fmt.Printf("Parsing '%s' as float64: %f, error: %v\n", str3, floatValue3, err3)
}

ParseInt

ParseInt()函数，用于将字符串解析为有符号整数。其作用是尝试解析表示整数的字符串，并返回对应的整数值和解析结果。

func ParseInt(s string, base int, bitSize int) (int64, error)
  • s 是要解析的字符串。
  • base 指定字符串中整数的进制，通常为 0、2、8、10 或 16。如果设置为 0，则会根据字符串的前缀自动确定进制。例如，"0x" 表示十六进制，"0" 表示八进制，否则为十进制。
  • bitSize 指定整数的位数，通常应该为 0、8、16、32 或 64，表示解析为 int, int8, int16, int32, 或 int64。如果 bitSize 不是有效值，会返回错误。
  • 返回值包括两部分：
    • int64：表示解析后的整数值。
    • error：如果解析成功，则返回 nil 错误；如果解析失败，则返回一个非空的错误值。
func main() {
	str1 := "42"
	str2 := "-123"
	str3 := "0xFF" // 十六进制
	str4 := "invalid"

	// 解析字符串为整数（使用 64 位表示）
	intValue1, err1 := strconv.ParseInt(str1, 10, 64)
	intValue2, err2 := strconv.ParseInt(str2, 10, 64)
	intValue3, err3 := strconv.ParseInt(str3, 0, 64) // 自动识别进制
	intValue4, err4 := strconv.ParseInt(str4, 10, 64)

	fmt.Printf("Parsing '%s' as int64: %d, error: %v\n", str1, intValue1, err1)
	fmt.Printf("Parsing '%s' as int64: %d, error: %v\n", str2, intValue2, err2)
	fmt.Printf("Parsing '%s' as int64: %d, error: %v\n", str3, intValue3, err3)
	fmt.Printf("Parsing '%s' as int64: %d, error: %v\n", str4, intValue4, err4)
}

ParseUint

ParseUint() 函数，用于将字符串解析为无符号整数。它与 ParseInt() 类似，但不允许负数，并且返回无符号整数。

func ParseUint(s string, base int, bitSize int) (uint64, error)
  • s 是要解析的字符串。
  • base 指定字符串中整数的进制，通常为 0、2、8、10 或 16。如果设置为 0，则会根据字符串的前缀自动确定进制。
  • bitSize 指定整数的位数，通常应该为 0、8、16、32 或 64，表示解析为 uint, uint8, uint16, uint32, 或 uint64。如果 bitSize 不是有效值，会返回错误。
  • 返回值包括两部分：
    • uint64：表示解析后的无符号整数值。
    • error：如果解析成功，则返回 nil 错误；如果解析失败，则返回一个非空的错误值
func main() {
	str1 := "42"
	str2 := "123"
	str3 := "0xFF" // 十六进制
	str4 := "-123" // 负数

	// 解析字符串为无符号整数（使用 64 位表示）
	uintValue1, err1 := strconv.ParseUint(str1, 10, 64)
	uintValue2, err2 := strconv.ParseUint(str2, 10, 64)
	uintValue3, err3 := strconv.ParseUint(str3, 0, 64) // 自动识别进制
	uintValue4, err4 := strconv.ParseUint(str4, 10, 64)

	fmt.Printf("Parsing '%s' as uint64: %d, error: %v\n", str1, uintValue1, err1)
	fmt.Printf("Parsing '%s' as uint64: %d, error: %v\n", str2, uintValue2, err2)
	fmt.Printf("Parsing '%s' as uint64: %d, error: %v\n", str3, uintValue3, err3)
	fmt.Printf("Parsing '%s' as uint64: %d, error: %v\n", str4, uintValue4, err4)
}

Format系列函数

Format() 包中的函数，用于将数字或其他数据类型转换为字符串。它提供了一种将不同数据类型转换为字符串的灵活方式。

FormatBool

FormatBool() 函数，用于将布尔值格式化为字符串。它接受一个布尔值作为参数，将其转换为相应的字符串表示。

func FormatBool(b bool) string
  • b 是要格式化的布尔值。

FormatBool() 函数将布尔值 b 转换为字符串，如果 b 为 true，则返回字符串 "true"，如果 b 为 false，则返回字符串 "false"。

func main() {
	// 格式化布尔值为字符串
	boolValue := true
	boolStr := strconv.FormatBool(boolValue)
	fmt.Printf("Formatted bool: %s\n", boolStr)

	boolValue = false
	boolStr = strconv.FormatBool(boolValue)
	fmt.Printf("Formatted bool: %s\n", boolStr)
}

FormatInt

FormatInt() 函数，用于将整数值格式化为字符串，支持指定进制。它接受整数值和要使用的进制作为参数，并返回相应进制的字符串表示。

func FormatInt(i int64, base int) string
  • i 是要格式化的整数值。
  • base 是进制，通常为 2、8、10 或 16。

FormatInt() 函数将整数值 i 按照指定进制 base 转换为字符串表示。进制可以是 2（二进制）、8（八进制）、10（十进制）或 16（十六进制）。

func main() {
	// 格式化整数为不同进制的字符串
	intValue := 42

	// 十进制
	decimalStr := strconv.FormatInt(int64(intValue), 10)
	fmt.Printf("Decimal: %s\n", decimalStr)

	// 二进制
	binaryStr := strconv.FormatInt(int64(intValue), 2)
	fmt.Printf("Binary: %s\n", binaryStr)

	// 八进制
	octalStr := strconv.FormatInt(int64(intValue), 8)
	fmt.Printf("Octal: %s\n", octalStr)

	// 十六进制
	hexStr := strconv.FormatInt(int64(intValue), 16)
	fmt.Printf("Hexadecimal: %s\n", hexStr)
}

FormatUint

FormatUint() 个函数，用于将无符号整数值格式化为字符串，支持指定进制。它接受无符号整数值和要使用的进制作为参数，并返回相应进制的字符串表示。

func FormatUint(i uint64, base int) string
  • i 是要格式化的无符号整数值。
  • base 是进制，通常为 2、8、10 或 16。

FormatUint() 函数将无符号整数值 i 按照指定进制 base 转换为字符串表示。进制可以是 2（二进制）、8（八进制）、10（十进制）或 16（十六进制

func main() {
	// 格式化无符号整数为不同进制的字符串
	uintValue := uint64(12345)

	// 十进制
	decimalStr := strconv.FormatUint(uintValue, 10)
	fmt.Printf("Decimal: %s\n", decimalStr)

	// 二进制
	binaryStr := strconv.FormatUint(uintValue, 2)
	fmt.Printf("Binary: %s\n", binaryStr)

	// 八进制
	octalStr := strconv.FormatUint(uintValue, 8)
	fmt.Printf("Octal: %s\n", octalStr)

	// 十六进制
	hexStr := strconv.FormatUint(uintValue, 16)
	fmt.Printf("Hexadecimal: %s\n", hexStr)
}

FormatFloat

FormatFloat() 函数，用于将浮点数值格式化为字符串。它接受浮点数值、格式说明符以及精度作为参数，并返回相应格式的字符串表示。

func FormatFloat(f float64, fmt byte, prec, bitSize int) string
  • f 是要格式化的浮点数值。
  • fmt 是格式说明符，可以是 'e'、'E'、'f'、'g' 或 'G'，分别对应科学计数法、定点数法和通用格式。
  • prec 是精度，控制小数部分的位数。
  • bitSize 是浮点数的位数，通常为 32 或 64，对应 float32 和 float64。

FormatFloat() 函数根据提供的格式说明符和精度，将浮点数值 f 格式化为字符串表示。格式说明符 'e' 和 'E' 分别表示科学计数法，'f' 表示定点数法，'g' 和 'G' 表示通用格式，根据实际情况选择最短精确表示

func main() {
	// 格式化浮点数为不同格式的字符串
	floatValue := 123.456

	// 科学计数法
	scientificStr := strconv.FormatFloat(floatValue, 'e', 2, 64)
	fmt.Printf("Scientific Notation: %s\n", scientificStr)

	// 定点数法
	fixedStr := strconv.FormatFloat(floatValue, 'f', 2, 64)
	fmt.Printf("Fixed Point Notation: %s\n", fixedStr)

	// 通用格式
	generalStr := strconv.FormatFloat(floatValue, 'g', 2, 64)
	fmt.Printf("General Format: %s\n", generalStr)
}
请登录后再评论