go筆記 - 字符串、數字、byte相互轉換

1、string到int

深州ssl適用于網站、小程序/APP、API接口等需要進行數據傳輸應用場景，ssl證書未來市場廣闊！成為創新互聯的ssl證書銷售渠道，可以享受市場價格4-6折優惠！如果有意向歡迎電話聯系或者加微信：18980820575（備注：SSL證書合作）期待與您的合作！

2、string到int64

3、string到int32

4、字符串 轉 uint64

1、int到string

2、int64到string

3、uint64 轉 字符串

uint8,int8,uint16,int16,uint32,int32,float32,uint64,int64,float64

1、int64與uint64

2、int64轉float64

1、string 轉為[]byte

2、byte轉為string

go類型轉換

type_name(expression)

float跟int可以互轉，但是會丟失所有精度。

func AppendBool(dst []byte, b bool) []byte

AppendBool 根據 b 的值將“true”或“false”附加到 dst 并返回擴展緩沖區。

func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte

AppendFloat 將由 FormatFloat 生成的浮點數 f 的字符串形式附加到 dst 并返回擴展緩沖區。

func AppendInt(dst []byte, i int64, base int) []byte

AppendInt 將由 FormatInt 生成的整數i的字符串形式附加到 dst 并返回擴展緩沖區。

func AppendQuote(dst []byte, s string) []byte

AppendQuote 將由 Quote 生成的代表 s 的雙引號 Go 字符串文字附加到 dst 并返回擴展緩沖區。

func AppendQuoteRune(dst []byte, r rune) []byte

AppendQuoteRune 將由 QuoteRune 生成的表示符文的單引號 Go 字符文字附加到 dst 并返回擴展緩沖區。

func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

AppendQuoteRuneToASCII 將由 QuoteRuneToASCII 生成的代表該符文的單引號 Go 字符文字附加到 dst 并返回擴展緩沖區。

func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte

AppendQuoteRuneToGraphic 將由 QuoteRuneToGraphic 生成的表示符文的單引號 Go 字符文字附加到 dst 并返回擴展緩沖區。

func AppendQuoteToASCII(dst []byte, s string) []byte

AppendQuoteToASCII 將由 QuoteToASCII 生成的代表 s 的雙引號 Go 字符串文字附加到 dst 并返回擴展緩沖區。

func AppendQuoteToGraphic(dst []byte, s string) []byte

AppendQuoteToGraphic 將由 QuoteToGraphic 生成的代表 s 的雙引號 Go 字符串文字附加到 dst 并返回擴展緩沖區。

func AppendUint(dst []byte, i uint64, base int) []byte

AppendUint 將由 FormatUint 生成的無符號整數 i 的字符串形式附加到 dst 并返回擴展緩沖區。

func Atoi(s string) (int, error)

Atoi 返回 ParseInt(s, 10, 0) 轉換為 int 類型的結果。

func CanBackquote(s string) bool

CanBackquote 報告字符串 s 是否可以不改變為單行反引號字符串，而不包含 tab 以外的控制字符。

func FormatBool(b bool) string

FormatBool 根據 b 的值返回“true”或“false”

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

FormatFloat 根據格式 fmt 和 precision prec 將浮點數f轉換為字符串。它將結果進行四舍五入，假設原始數據是從 bitSize 位的浮點值獲得的（float32為32，float64為64）。

格式 fmt 是 'b'（-ddddp±ddd，二進制指數），'e'（-d.dddde±dd，十進制指數），'E'（-d.ddddE±dd，十進制指數），'f'（-ddd.dddd，無指數），'g'（'e'表示大指數，'f'表示否則）或 'G'（'E'表示大指數，否則'f'）。

precision prec 控制由 'e'，'E'，'f'，'g' 和 'G' 格式打印的位數（不包括指數）。對于 'e'，'E' 和 'f'，它是小數點后的位數。對于 'g' 和 'G' 這是總位數。特殊精度-1使用必需的最小位數，以便 ParseFloat 完全返回 f 。

func FormatInt(i int64, base int) string

FormatInt 返回給定基數中的i的字符串表示，對于2 = base = 36.結果對于數字值 = 10使用小寫字母 'a' 到 'z' 。

func FormatUint(i uint64, base int) string

FormatUint 返回給定基數中的 i 的字符串表示，對于2 = base = 36.結果對于數字值 = 10使用小寫字母 'a' 到 'z' 。

func IsGraphic(r rune) bool

IsGraphic 報告符文是否被 Unicode 定義為 Graphic。這些字符包括類別 L，M，N，P，S 和 Z 中的字母，標記，數字，標點，符號和空格。

func IsPrint(r rune) bool

IsPrint 報告該符文是否被 Go 定義為可打印，其定義與 unicode.IsPrint 相同：字母，數字，標點，符號和 ASCII 空格。

func Itoa(i int) string

Itoa 是 FormatInt(int64(i), 10) 的縮寫。

func ParseBool(str string) (bool, error)

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

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

ParseFloat 將字符串 s 轉換為浮點數，精度由 bitSize：32指定，float32為64; float64為64。當 bitSize = 32時，結果仍然具有 float64 類型，但可以在不更改其值的情況下將其轉換為 float32。

如果s格式良好且接近有效的浮點數，則 ParseFloat 返回使用 IEEE754 無偏舍入舍入的最近浮點數。

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

如果 s 在語法上不是格式良好的，ParseFloat 返回 err.Err = ErrSyntax。

如果 s 在語法上格式良好，但距離給定大小的最大浮點數大于1/2 ULP，則 ParseFloat 返回 f =±Inf，err.Err = ErrRange。

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

ParseInt 解釋給定基礎（2到36）中的字符串 s 并返回相應的值 i。如果 base == 0，則基數由字符串的前綴隱含：base 16代表“0x”，base 8代表“0”，否則以10為底數。

bitSize 參數指定結果必須適合的整數類型。位大小 0,8,16,32 和 64 對應于 int，int8，int16，int32 和 int64。

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

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

ParseUint 就像 ParseInt，但是對于無符號數字。

func Quote(s string) string

Quote 返回一個雙引號的 Go 字符串字面表示s。返回的字符串使用 Go 轉義序列 (\t, \n, \xFF, \u0100) 作為 IsPrint 定義的控制字符和非可打印字符。

func QuoteRune(r rune) string

QuoteRune 返回一個表示符文的單引號 Go 字符。返回的字符串使用 Go 轉義序列(\t, \n, \xFF, \u0100) 作為 IsPrint 定義的控制字符和非可打印字符。

func QuoteRuneToASCII(r rune) string

QuoteRuneToASCII 返回表示符文的單引號 Go 字符。對于非 ASCII 字符和 IsPrint 定義的非可打印字符，返回的字符串使用 Go 轉義序列 (\t, \n, \xFF, \u0100)。

func QuoteRuneToGraphic(r rune) string

QuoteRuneToGraphic 返回代表符文的單引號 Go 字符。對于非 ASCII 字符和 IsGraphic 定義的非可打印字符，返回的字符串使用Go轉義序列 (\t, \n, \xFF, \u0100)。

func QuoteToASCII(s string) string

QuoteToASCII 返回一個代表 s 的雙引號 Go 字符串。對于非 ASCII 字符和 IsPrint 定義的非可打印字符，返回的字符串使用 Go 轉義序列 (\t, \n, \xFF, \u0100) 。

func QuoteToGraphic(s string) string

QuoteToGraphic 返回一個代表 s 的雙引號 Go 字符串。對于非 ASCII 字符和 IsGraphic 定義的非可打印字符，返回的字符串使用 Go 轉義序列 (\t, \n, \xFF, \u0100)。

func Unquote(s string) (string, error)

Unquote 將 s 解釋為單引號，雙引號或反引號的 Go 字符串文字，返回引用的字符串值。（如果 s 是單引號，它將是一個 Go 字符字面量； Unquote 會返回相應的一個字符字符串。）

go的uint64轉換成java的哪種類型

Golang 和java/c不同，Go在不同類型的變量之間賦值時需要顯式轉換。也就是說Golang中數據類型不能自動轉換。

基本語法

表達式T（v））將值v 轉換為類型T

T∶就是數據類型，比如int32，int64，float32等等

v∶ 就是需要轉換的變量

var i int = 100

var b float64 = float64(i)

var c int64 = int64(b)

fmt.Printf("b=%f,c=%d",b,c)

b=100.000000,c=100

登錄后復制

細節說明

1）Go中，數據類型的轉換可以是從表示范圍小-表示范圍大，也可以范圍大一范圍小

2） 被轉換的是變量存儲的數據（即值），變量本身的數據類型并沒有變化!

3） 在轉換中，比如將 int64 轉成int8，編譯時不會報錯，只是轉換的結果是按溢出處理，和

我們希望的結果不一樣。（在轉換的時候需要注意范圍）

var a int64 = 10000000

var b int8 = int8(a)

fmt.Printf("%d",b)

-128

登錄后復制

可以看到在轉換的時候，一定要保證轉換大數據要是對方可以接受的范圍。

n1類型是int32，那么?20整個就是int32類型，可是n2是int64，這樣就會編譯錯誤。

題二n4是12 + 127溢出超過了范圍，運行的時候按照溢出處理。n3是直接編譯不通過，128已經超過了int8類型的范圍

基本數據類型和string的轉換

字符串格式化

Go語言用于控制文本輸出常用的標準庫是fmt

fmt中主要用于輸出的函數有:

Print: 輸出到控制臺,不接受任何格式化操作

Println: 輸出到控制臺并換行

Printf : 只可以打印出格式化的字符串。只可以直接輸出字符串類型的變量（不可以輸出別的類型）

Sprintf：格式化并返回一個字符串而不帶任何輸出

Fprintf：來格式化并輸出到 io.Writers 而不是 os.Stdout

整數類型

格 式 描 述

%b 整型以二進制方式顯示

%o 整型以八進制方式顯示

%d 整型以十進制方式顯示

%x 整型以十六進制方式顯示

%X 整型以十六進制、字母大寫方式顯示

%c 相應Unicode碼點所表示的字符

%U Unicode 字符, Unicode格式：123，等同于 "U+007B"

浮點數

格 式 描 述

%e 科學計數法，例如 -1234.456e+78

%E 科學計數法，例如 -1234.456E+78

%f 有小數點而無指數，例如 123.456

%g 根據情況選擇 %e 或 %f 以產生更緊湊的（無末尾的0）輸出

%G 根據情況選擇 %E 或 %f 以產生更緊湊的（無末尾的0）輸出

布爾

格 式 描 述

%t true 或 false

字符串

格 式 描 述

%s 字符串或切片的無解譯字節

%q 雙引號圍繞的字符串，由Go語法安全地轉義

%x 十六進制，小寫字母，每字節兩個字符

%X 十六進制，大寫字母，每字節兩個字符

指針

格 式 描 述

%p 十六進制表示，前綴 0x

var num1 int64 = 99

var num2 float64 = 23.99

var b bool = true

var mychar byte = 'h'

str1 := fmt.Sprintf("%d",num1)

str2 := fmt.Sprintf("%f",num2)

bool1 := fmt.Sprintf("%t",b)

mychar1 := fmt.Sprintf("%c",mychar)

fmt.Printf("%T,%T,%T,str1=%v,str2=%v,bool1=%v,mychar1=%v",str1,bool1,str2,str1,str2,bool1,mychar1)

string,string,string,string,str1=99,str2=23.990000,bool1=true,mychar1=h

登錄后復制

?

使用strconv包 基本類型 - string類型

num1 := 99

str1 := strconv.FormatInt(int64(num1),10)

fmt.Printf("%T,%v",str1,str1)

num2 := 99.99

str2 := strconv.FormatFloat(num2,'f',10,64)

fmt.Printf("%T,%v\n",str2,str2)

登錄后復制

strconv包提供了字符串與簡單數據類型之間的類型轉換功能，可以將簡單類型轉換為字符串，也可以將字符串轉換為其它簡單類型

string和int轉換

int轉string的方法是: Itoa()

str := strconv.Itoa(100)

fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)

登錄后復制

2.string轉int的方法是:

i, err := strconv.Atoi("100")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登錄后復制

并不是所有string都能轉化為int, 所以可能會報錯:

i, err := strconv.Atoi("100x")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登錄后復制

使用strconv包 string轉其他類型

strconv包提供的Parse類函數用于將字符串轉化為給定類型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint() 由于字符串轉換為其它類型可能會失敗，所以這些函數都有兩個返回值，第一個返回值保存轉換后的值，第二個返回值判斷是否轉換成功。

1.轉bool

b, err := strconv.ParseBool("true")

fmt.Println(b, err)

登錄后復制

2.轉float

f1, err := strconv.ParseFloat("3.1", 32)

fmt.Println(f1, err)

f2, err := strconv.ParseFloat("3.1", 64)

fmt.Println(f2, err)

登錄后復制

由于浮點數的小數部分 并不是所有小數都能在計算機中精確的表示, 這就造成了浮點數精度問題, 比如下面

var n float64 = 0

for i := 0; i 1000; i++ {

n += .01

}

fmt.Println(n)

關于浮點數精度問題: c計算機不都是0101嗎，你有想過計算機是怎么表示的小數嗎, 簡單理解就是:

將其整數部分與小樹部分分開, 比如5.25

對于整數部分 5 ，我們使用"不斷除以2取余數"的方法，得到 101

對于小數部分 .25 ，我們使用"不斷乘以2取整數"的方法，得到 .01

聽說有一個包可以解決這個問題: github.com/shopspring/decimal

3.轉int

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

base: 進制，有效值為0、2-36。當base=0的時候，表示根據string的前綴來判斷以什么進制去解析：0x開頭的以16進制的方式去解析，0開頭的以8進制方式去解析，其它的以10進制方式解析

bitSize: 多少位，有效值為0、8、16、32、64。當bitSize=0的時候，表示轉換為int或uint類型。例如bitSize=8表示轉換后的值的類型為int8或uint8

fmt.Println(bInt8(-1)) // 0000 0001(原碼) - 1111 1110(反碼) - 1111 1111

// Parse 二進制字符串

i, err := strconv.ParseInt("11111111", 2, 16)

fmt.Println(i, err)

// Parse 十進制字符串

i, err = strconv.ParseInt("255", 10, 16)

fmt.Println(i, err)

// Parse 十六進制字符串

i, err = strconv.ParseInt("4E2D", 16, 16)

fmt.Println(i, err)

4.轉uint

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

用法和轉int一樣, 只是轉換后的數據類型是uint64

u, err := strconv.ParseUint("11111111", 2, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("255", 10, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("4E2D", 16, 16)

fmt.Println(u, err)

其他類型轉string

將給定類型格式化為string類型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

fmt.Println(strconv.FormatBool(true))

// 問題又來了

fmt.Println(strconv.FormatInt(255, 2))

fmt.Println(strconv.FormatInt(255, 10))

fmt.Println(strconv.FormatInt(255, 16))

fmt.Println(strconv.FormatUint(255, 2))

fmt.Println(strconv.FormatUint(255, 10))

fmt.Println(strconv.FormatUint(255, 16))

fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))

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控制精度（排除指數部分）：對'f'、'e'、'E'，它表示小數點后的數字個數；對'g'、'G'，它控制總的數字個數。如果prec 為-1，則代表使用最少數量的、但又必需的數字來表示f。

go基礎系列——go 數組轉字符串

func ImplodeUint64Array (arr []uint64, char string) string {

result := ""

for _, i := range arr {

result += strconv.FormatUint(i, 10) + char

}

return strings.Trim(result,char)

}

go語言uint64轉int64問題

go語言是強類型的，沒有直接的強制類型轉換。但是可以使用unsafe.Pointer來進行強制類型轉換(*int64)(unsafe.Pointer(x))

Go數據結構篇

1、基本數據類型

bool

string

int int8 int16 int32 int64

uint uint8 uint16 uint32 uint64 uintptr

byte // alias for int8

rune // alias for int32,represents a Unicode code point

float32 float64

complex64 complex128

常量定義

2、類型轉換

（1）Go語言不允許隱式類型轉換（不支持小位數類型向大位數類型轉）

（2）別名和原有類型也不能進行隱式類型轉換（type MyInt int64 = int64）

3、類型的預定義值

1.math.MaxInt64

2.math.MaxFloat64

3.math.MaxUInt32

4、指針類型

（1）不支持指針運算

（2）string是值類型，其默認的初始化值為空字符串，而不是nil

5、算術運算符

+ - * / % ++ --（不支持前置++ --）

6、比較運算符

#== != = =

（1）比較數組

相同維數且含有形同個數元素的數組才可以比較

每個元素都相同的才相等

7、位運算符

｜ ^

^ (按位置零) a (^b)

1 ^ 0 1

1 ^ 1 0

0 ^ 1 0

0 ^ 0 0

8、條件與循環

（1）循環

Go 語?僅?持循環關鍵字 for

（2）條件

9、數組和切片

數組截取，索引下標從0開始計數

a[開始索引(包含), 結束索引(不包含)]

a := [...]int{1, 2, 3, 4, 5}

a[1:2] //2

a[1:3] //2,3

a[1:len(a)] //2,3,4,5

a[1:] //2,3,4,5

a[:3] //1,2,3

切片內部結構

9、Map

9、字符串

Unicode UTF8

常?字符串函數

標題名稱：關于go語言uint轉換格式的信息
路徑分享：http://www.yijiale78.com/article16/hhcggg.html

成都網站建設公司_創新互聯，為您提供外貿建站、網站導航、靜態網站、企業建站、軟件開發、動態網站

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯