腳本之家服務器常用軟件

快捷導航

GoLang中Strconv庫有哪些常用方法

更新時間：2023年01月12日 09:18:00 作者：Ch3n

這篇文章主要介紹了GoLang中Strconv庫有哪些常用方法，strconv庫實現(xiàn)了基本數(shù)據(jù)類型與其字符串表示的轉換，主要有以下常用函數(shù)：?Atoi()、Itia()、parse系列、format系列、append系列

Strconv

strconv包實現(xiàn)了基本數(shù)據(jù)類型和其字符串表示的相互轉換。

更多函數(shù)請查看

官方文檔
中文文檔

string與int類型轉換

Atoi()

Atoi()函數(shù)用于將字符串類型的整數(shù)轉換為int類型，等價于ParseInt (s, 10, 0)，轉換為 int 類型。

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

v := "10"
if s, err := strconv.Atoi(v); err == nil {
	fmt.Printf("%T, %v", s, s)
}
//Output:
//
//int, 10

Itoa()

Itoa()函數(shù)用于將int類型數(shù)據(jù)轉換為對應的字符串表示，等價于FormatInt (int64(i), 10)。

func Itoa(i int) string

例子

i := 10
s := strconv.Itoa(i)
fmt.Printf("%T, %v\n", s, s)
//Output:
//
//string, 10

Parse 系列函數(shù)

Parse類函數(shù)用于轉換字符串為給定類型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()

ParseBool

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

ParseBool 返回字符串表示的布爾值。它接受 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False。任何其他值都會返回錯誤。

例子

v := "true"
if s, err := strconv.ParseBool(v); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
//Output:
//
//bool, true

ParseInt

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

ParseInt 以給定的基數(shù)（0、2 到 36）和位大小（0 到 64）解釋字符串 s，并返回相應的值 i。

字符串可以以前導符號開頭：“+”或“-”。

如果 base 參數(shù)為 0，則真正的基數(shù)由符號后面的字符串前綴（如果存在）暗示：2 表示“0b”，8 表示“0”或“0o”，16 表示“0x”，否則為 10。此外，僅對于以 0 為基數(shù)的參數(shù)，允許使用 Go 語法為整數(shù)文字定義的下劃線字符。

bitSize 參數(shù)指定結果必須適合的整數(shù)類型。位大小 0、8、16、32 和 64 對應于 int、int8、int16、int32 和 int64。如果 bitSize 小于 0 或大于 64，則返回錯誤。

ParseInt 返回的錯誤具有具體類型 * NumError并包括 err.Num = s。如果 s 為空或包含無效數(shù)字，則 err.Err = ErrSyntax ，返回值為 0；如果 s 對應的值不能用給定大小的有符號整數(shù)表示，則 err.Err = ErrRange并且返回值是適當?shù)?bitSize 和符號的最大幅度整數(shù)

例子

v32 := "-354634382"
if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
v64 := "-3546343826724305832"
if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
//Output:
//
//int64, -354634382
//int64, -3546343826724305832

ParseUnit

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

ParseUint 類似于ParseInt但用于無符號數(shù)。

不允許使用符號前綴

例子

v := "42"
if s, err := strconv.ParseUint(v, 10, 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseUint(v, 10, 64); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
//Output:
//
//uint64, 42
//uint64, 42

ParseFloat

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

ParseFloat 將字符串 s 轉換為精度由 bitSize 指定的浮點數(shù)：對于 float32 為 32，對于 float64 為 64。當 bitSize=32 時，結果仍然是 float64 類型，但它可以轉換為 float32 而不會改變它的值。

ParseFloat 接受十進制和十六進制浮點數(shù)語法。如果 s 格式正確且接近有效浮點數(shù)，則 ParseFloat 返回使用 IEEE754 無偏舍入舍入的最接近的浮點數(shù)。（僅當十六進制表示中的位數(shù)多于尾數(shù)中的位數(shù)時，才對十六進制浮點值進行四舍五入。）

ParseFloat 返回的錯誤具有具體類型 * NumError并包括 err.Num = s。

如果 s 的語法格式不正確，則 ParseFloat 返回 err.Err = ErrSyntax 。

如果 s 在語法上格式正確，但距離給定大小的最大浮點數(shù)超過 1/2 ULP，則 ParseFloat 返回 f = ±Inf, err.Err = ErrRange 。

ParseFloat 將字符串“NaN”和（可能有符號的）字符串“Inf”和“Infinity”識別為它們各自的特殊浮點值。匹配時忽略大小寫

例子

v := "3.1415926535"
if s, err := strconv.ParseFloat(v, 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat(v, 64); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("NaN", 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
// ParseFloat is case insensitive
if s, err := strconv.ParseFloat("nan", 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("inf", 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+Inf", 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-Inf", 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-0", 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+0", 32); err == nil {
	fmt.Printf("%T, %v\n", s, s)
}
//Output:
//
//float64, 3.1415927410125732
//float64, 3.1415926535
//float64, NaN
//float64, NaN
//float64, +Inf
//float64, +Inf
//float64, -Inf
//float64, -0
//float64, 0

Format系列函數(shù)

Format系列函數(shù)實現(xiàn)了將給定類型數(shù)據(jù)格式化為string類型數(shù)據(jù)的功能。

FormatBool

func FormatBool(b bool) string

FormatBool 根據(jù) b 的值返回“true”或“false”。

例子

v := true
s := strconv.FormatBool(v)
fmt.Printf("%T, %v\n", s, s)
//Output:
//
//string, true

FormatInt

func FormatInt(i int64, base int) string

FormatInt 返回給定基數(shù)中 i 的字符串表示形式，即 2 <= base <= 36。對于 >= 10 的數(shù)字值，結果使用小寫字母 ‘a’ 到 ‘z’。

例子

v := int64(-42)
s10 := strconv.FormatInt(v, 10)
fmt.Printf("%T, %v\n", s10, s10)
s16 := strconv.FormatInt(v, 16)
fmt.Printf("%T, %v\n", s16, s16)
//Output:
//
//string, -42
//string, -2a

FormatUint

func FormatUint(i uint64, base int) string

FormatUint 返回給定基數(shù)中 i 的字符串表示形式，即 2 <= base <= 36。對于 >= 10 的數(shù)字值，結果使用小寫字母 ‘a’ 到 ‘z’

例子

v := uint64(42)
s10 := strconv.FormatUint(v, 10)
fmt.Printf("%T, %v\n", s10, s10)
s16 := strconv.FormatUint(v, 16)
fmt.Printf("%T, %v\n", s16, s16)
//Output:
//
//string, 42
//string, 2a

FormatFloat

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

FormatFloat 根據(jù)格式 fmt 和精度 prec 將浮點數(shù) f 轉換為字符串。

假設原始值是從 bitSize 位的浮點值（32 表示 float32，64 表示 float64）獲得的，它會對結果進行四舍五入。格式 fmt 是 ‘b’（-ddddp±ddd，二進制指數(shù)）、‘e’（-d.dddde±dd，十進制指數(shù)）、‘E’（-d.ddddE±dd，十進制指數(shù)）之一), ‘f’ (-ddd.dddd, 無指數(shù)), ‘g’ (‘e’ 表示大指數(shù)，‘f’ 否則), ‘G’ (‘E’ 表示大指數(shù)，‘f’ 否則), ’ x’（-0xd.ddddp±ddd，十六進制分數(shù)和二進制指數(shù)），或 ‘X’（-0Xd.ddddP±ddd，十六進制分數(shù)和二進制指數(shù)）。精度 prec 控制由“e”、“E”、“f”、“g”、“G”、“x”和“X”格式打印的位數(shù)（不包括指數(shù)）。對于’e’、‘E’、‘f’、‘x’和’X’，它是小數(shù)點后的位數(shù)。對于“g”和“G”，它是有效數(shù)字的最大數(shù)量（刪除尾隨零）。特殊精度 -1 使用所需的最少位數(shù)，以便ParseFloat將準確返回 f

例子

v := 3.1415926535
s32 := strconv.FormatFloat(v, 'E', -1, 32)
fmt.Printf("%T, %v\n", s32, s32)
s64 := strconv.FormatFloat(v, 'E', -1, 64)
fmt.Printf("%T, %v\n", s64, s64)
//Output:
//
//string, 3.1415927E+00
//string, 3.1415926535E+00