61、Go 语言基础 - strconv 包

作者: 温新

分类: 【Go基础】

阅读: 2110

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

hi,我是温析

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

常用函数及其功能:

  • AtoiItoa

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

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

  • ParseBoolFormatBoolAppendBool

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

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

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

  • ParseFloatFormatFloatAppendFloat

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

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

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

  • ParseIntFormatIntAppendInt

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

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

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

  • ParseUintFormatUintAppendUint

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

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

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

  • QuoteQuoteToASCIIUnquoteIsPrint

    • 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,表示解析为 float32float64。如果 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 转换为字符串,如果 btrue,则返回字符串 "true",如果 bfalse,则返回字符串 "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 是浮点数的位数,通常为 3264,对应 float32float64

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)
}
请登录后再评论