1、Golang 變量定義方法：

1）定義變量 變量名 類型 = 表達式

var go string = "hello"

2）在函數內部，可以使用更簡略的 := 方式聲明并初始化變量。

注意：短變量只能用于聲明局部變量，不能用于全局變量的聲明

go := "hello"

2、fmt 包、Print、Println、Printf

Go 中要打印一個值需要引入 fmt 包 import "fmt" 。fmt 包里面給我們提供了一些常見的打印數據的方法，比如：Print 、Println、Printf，在我 們實際開發中 Println、Printf 用的非常多。

1）Print 和 Println 區別：

一次輸入多個值的時候 Println 中間有空格 Print 沒有

fmt.Println("go", "python", "php", "javascript") fmt.Print("go", "python", "php", "javascript") // Println 會自動換行，Print 不會 package main import "fmt" func main() { fmt.Println("hello") fmt.Println("world") // hello // world fmt.Print("hello") fmt.Print("world") // helloworld }

2）Println 和 Printf 區別：

Printf 是格式化輸出，在很多場景下比 Println 更方便

a := 10 b := 20 c := 30 fmt.Println("a=", a, ",b=", b, ",c=", c) //a= 10 ,b= 20 ,c= 30 fmt.Printf("a=%d,b=%d,c=%d", a, b, c) //a=10,b=20,c=30

%d 是占位符，表示數字的十進制表示。Printf 中的占位符與后面的數字變量一一對應。常用%v、%T等

更多的占位符參考：http://docscn.studygolang.com/pkg/fmt/

3、Go 語言中的注釋

win 下面 ctrl+/ ，mac 下面 command+/ 可以快速的注釋一行

/* 這是一個多行注釋 */ // 這是一個單行注釋

4、匿名變量

在使用多重賦值時，如果想要忽略某個值，可以使用匿名變量（anonymous variable）。

匿名變量用一個下劃線_表示，例如：

func getInfo() (int, string) { return 10, "張三" }func main() { _, username := getInfo() fmt.Println(username) }

匿名變量不占用命名空間，不會分配內存，所以匿名變量之間不存在重復聲明。

5、常量結合ioat

iota 是 golang 語言的常量計數器,只能在常量的表達式中使用。

iota 在 const 關鍵字出現時將被重置為 0(const 內部的第一行之前)，const 中每新增一行常量 聲明將使 iota 計數一次(iota 可理解為 const 語句塊中的行索引)。

1）iota 只能在常量的表達式中使用。

2）每次 const 出現時，都會讓 iota 初始化為 0.【自增長】

const a = iota // a=0 const ( b = iota //b=0 c //c=1 )

3）const iota 使用_跳過某些值

const ( n1 = iota //0 n2 //1 _ n4 //3 )

4）iota 聲明中間插隊

const ( n1 = iota //0 n2 = 100 //100 n3 = iota //2 n4 //3 ) const n5 = iota //0

5）多個 iota 定義在一行

const ( a, b = iota + 1, iota + 2 //1,2 c, d //2,3 e, f //3,4 )

6、Go 語言變量、常量命名規則

1）變量名稱必須由數字、字母、下劃線組成。

2）標識符開頭不能是數字

3）標識符不能是保留字和關鍵字。

4）變量的名字是區分大小寫的如: age 和 Age 是不同的變量。在實際的運用中,也建議,不要 用一個單詞大小寫區分兩個變量。

5）標識符(變量名稱)一定要見名思意 ：變量名稱建議用名詞，方法名稱建議用動詞

6）變量命名一般采用駝峰式，當遇到特有名詞（縮寫或簡稱，如 DNS）的時候，特有名詞 根據是否私有全部大寫或小寫。

7、基本數據類型

1）Golang 數據類型介紹

Go 語言中數據類型分為：基本數據類型和復合數據類型

基本數據類型有： 整型、浮點型、布爾型、字符串

復合數據類型有： 數組、切片、結構體、函數、map、通道（channel）、接口等。

2）整型 整型分為以下兩個大類：

有符號整形按長度分為：int8、int16、int32、int64

對應的無符號整型：uint8、uint16、uint32、uint64

字節也叫 Byte，是計算機數據的基本存儲單位。8bit(位)=1Byte(字節) 1024Byte(字節)=1KB 1024KB=1MB 1024MB=1GB 1024GB=1TB 。一個中文字是占兩個字節的。

特殊整型

注意： 在使用 int 和 uint 類型時，不能假定它是 32 位或 64 位的整型，而是考慮 int 和 uint 可能在不同平臺上的差異。

實際項目中整數類型、切片、 map 的元素數量等都可以用 int 來表示。在涉及 到二進制傳輸、為了保持文件的結構不會受到不同編譯目標平臺字節長度的影響，不要使 用 int 和 uint。

unsafe.Sizeof

unsafe.Sizeof(n1) 是 unsafe 包的一個函數，可以返回 n1 變量占用的字節數

package main import ( "fmt" "unsafe" ) func main() {var a int8 = 120 fmt.Printf("%Tn", a) fmt.Println(unsafe.Sizeof(a)) }

int 不同長度直接的轉換

數字字面量語法（Number literals syntax）

Go1.13 版本之后引入了數字字面量語法，這樣便于開發者以二進制、八進制或十六進制浮 點數的格式定義數字，例如：

v := 0b00101101， 代表二進制的 101101，相當于十進制的 45。 v := 0o377，代表八進制的 377，相當于十進制的 255。 v := 0x1p-2，代表十六進制的 1 除以 22，也就是 0.25。

而且還允許我們用 _ 來分隔數字，比如說： v := 123_456 等于 123456。 我們可以借助 fmt 函數來將一個整數以不同進制形式展示。

package mainimport "fmt" func main(){ // 十進制var a int a = 10 fmt.Printf("%d n", a) // 10fmt.Printf("%b n", a) // 1010 占位符%b 表示二進制// 八進制 以 0 開頭var b int b = 077 fmt.Printf("%o n", b) // 77// 十六進制 以 0x 開頭var c int c = 0xff fmt.Printf("%x n", c) // ff fmt.Printf("%X n", c) // FF fmt.Printf("%d n", c) // 255 }

3）浮點型

Go 語言支持兩種浮點型數：float32 和 float64。這兩種浮點型數據格式遵循 IEEE 754 標準： float32 的浮點數的最大范圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。float64 的浮點數的最大范圍約為 1.8e308，可以使用一個常量定義：`math.MaxFloat64`。

打印浮點數時，可以使用 fmt 包配合動詞%f，代碼如下：

package main import ( "fmt" "math" )func main() { fmt.Printf("%fn", math.Pi) //默認保留 6 位小數 fmt.Printf("%.2fn", math.Pi) //保留 2 位小數 }

Go 語言中浮點數默認是 float64

num := 1.1 fmt.Printf("值：%v--類型:%T", num, num) //值：1.1--類型:float64

Golang 中 float 精度丟失問題

幾乎所有的編程語言都有精度丟失這個問題，這是典型的二進制浮點數精度損失問題，在定 長條件下，二進制小數和十進制小數互轉可能有精度丟失。

d := 1129.6 fmt.Println((d * 100)) //輸出：112959.99999999999var d float64 = 1129.6 fmt.Println((d * 100)) //輸出：112959.99999999999m1 := 8.2 m2 := 3.8 fmt.Println(m1 - m2) // 期望是 4.4，結果打印出了 4.399999999999999

使用第三方包來解決精度損失問題：https://github.com/shopspring/decimal

Golang 科學計數法表示浮點類型

num8 := 5.1234e2 // ? 5.1234 * 10 的 2 次 方 num9 := 5.1234E2 // ? 5.1234 * 10 的 2 次方 shift+alt+向下的箭頭num10 := 5.1234E-2 // ? 5.1234 / 10 的 2 次 方 0.051234fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)

4）布爾值

Go 語言中以 bool 類型進行聲明布爾型數據，布爾型數據只有 true（真）和 false（假）兩個值。

注意：

1. 布爾類型變量的默認值為 false。

2. Go 語言中不允許將整型強制轉換為布爾型.

3. 布爾型無法參與數值運算，也無法與其他類型進行轉換。、

5）字符串

Go 語言中的字符串以原生數據類型出現，使用字符串就像使用其他原生數據類型（int、bool、float32、float64 等）一樣。 Go 語言里的字符串的內部實現使用 UTF-8 編碼。 字符串的值為雙引號(")中的內容，可以在 Go 語言的源碼中直接添加非 ASCII 碼字符，例如：

s1 := "hello" s2 := "你好"

字符串轉義符

Go 語言的字符串常見轉義符包含回車、換行、單雙引號、制表符等，如下表所示。

轉義符	含義
r	回車符（返回行首）
n	換行符（直接跳到下一行的同列位置）
t	制表符
'	單引號
"	雙引號
	反斜杠

舉個例子，我們要打印一個 Windows 平臺下的一個文件路徑：

package main import ( "fmt" ) func main() { fmt.Println("str := "c:Codedemogo.exe"") }

多行字符串

// Go 語言中要定義一個多行字符串時，就必須使用反引號字符： s1 := `第一行 第二行 第三行 ` fmt.Println(s1) // 反引號間換行將被作為字符串中的換行，但是所有的轉義字符均無效，文本將會原樣輸出。

字符串的常用操作

方法	介紹
len(str)	求長度
+或 fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判斷是否包含
strings.HasPrefix,strings.HasSuffix	前綴/后綴判斷
strings.Index(),strings.LastIndex()	子串出現的位置
strings.Join(a[]string, sep string)	join 操作

方法	介紹
len(str)	求長度
+或 fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判斷是否包含
strings.HasPrefix,strings.HasSuffix	前綴/后綴判斷
strings.Index(),strings.LastIndex()	子串出現的位置
strings.Join(a[]string, sep string)	join 操作

方法	介紹
len(str)	求長度
+或 fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判斷是否包含
strings.HasPrefix,strings.HasSuffix	前綴/后綴判斷
strings.Index(),strings.LastIndex()	子串出現的位置
strings.Join(a[]string, sep string)	join 操作

拼接字符串

var str1 = "你好" var str2 = "golang"fmt.Println(str1 + str2)var str3 = fmt.Sprintf("%v %v", str1, str2) fmt.Println(str3)var str = "this is golang" var flag = strings.Contains(str, "golang") fmt.Println(flag)

判斷首字符尾字母是否包含指定字符

var str = "this is golang" var flag = strings.HasPrefix(str, "this") fmt.Println(flag)var str = "this is golang" var flag = strings.HasSuffix(str, "go") fmt.Println(flag)

判斷字符串出現的位置

var str = "this is golang" var index = strings.Index(str, "is") //從前往后 fmt.Println(index)var str = "this is golang" var index = strings.LastIndex(str, "is") //從后網前 fmt.Println(index)

Join 拼接字符串

var str = "123-456-789" var arr = strings.Split(str, "-") var str2 = strings.Join(arr, "*") fmt.Println(str2)

6）byte 和 rune 類型

組成每個字符串的元素叫做“字符”，可以通過遍歷字符串元素獲得字符。 字符用單引號（’） 包裹起來，如：

package main import "fmt" func main() { a := 'a' b := '0' //當我們直接輸出 byte（字符）的時候輸出的是這個字符對應的碼值 fmt.Println(a) fmt.Println(b)//如果我們要輸出這個字符，需要格式化輸出 fmt.Printf("%c--%c", a, b) //%c 相應 Unicode 碼點所表示的字符}

字節（byte）：是計算機中 數據處理 的基本單位，習慣上用大寫 B 來表示,1B（byte,字節）

= 8bit（位）

字符：是指計算機中使用的字母、數字、字和符號

一個漢子占用 3 個字節 一個字母占用一個字節

a := "m" fmt.Println(len(a)) //1b := " 張 " fmt.Println(len(b)) //3

Go 語言的字符有以下兩種：

1. uint8 類型，或者叫 byte 型，代表了 ASCII 碼的一個字符。

2. rune 類型，代表一個 UTF-8 字符。

當需要處理中文、日文或者其他復合字符時，則需要用到 rune 類型。rune 類型實際是一個

int32。

Go 使用了特殊的 rune 類型來處理 Unicode，讓基于 Unicode 的文本處理更為方便，也可以使用 byte 型進行默認字符串處理，性能和擴展性都有照顧。

// 遍歷字符串 package mainimport "fmt"func main() { s := "hello 張三" for i := 0; i < len(s); i++ { //byte fmt.Printf("%v(%c) ", s[i], s[i]) } fmt.Println()for _, r := range s { //rune fmt.Printf("%v(%c) ", r, r) } fmt.Println() }輸出：104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 229(?) 188(?) 160( ) 228(?) 184(?) 137() 104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 24352(張) 19977(三)

因為 UTF8 編碼下一個中文漢字由 3 個字節組成，所以我們不能簡單的按照字節去遍歷一個包含中文的字符串，否則就會出現上面輸出中第一行的結果。

字符串底層是一個 byte 數組，所以可以和[]byte 類型相互轉換。字符串是不能修改的 字符串是由 byte 字節組成，所以字符串的長度是 byte 字節的長度。 rune 類型用來表示 utf8 字符，一個 rune 字符由一個或多個 byte 組成。

rune 類型實際是一個 int32.

7）修改字符串

要修改字符串，需要先將其轉換成[]rune 或[]byte，完成后再轉換為 string。無論哪種轉換， 都會重新分配內存，并復制字節數組。

func changeString() { s1 := "big" // 強制類型轉換 byteS1 := []byte(s1) byteS1[0] = 'p' fmt.Println(string(byteS1))s2 := " 白 蘿 卜 " runeS2 := []rune(s2) runeS2[0] = '紅' fmt.Println(string(runeS2)) }

總結

以上是生活随笔為你收集整理的golang int64转string_(一)Golang从入门到原地起飞的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。