Go語言基礎

一、Go基礎

識別符號：

? go語言中的識別符號由字母數字和下劃線（_）組成，并且只能以字母和下劃線（_）開頭

關鍵字:

? 關鍵字是指編程語言中預先定義好的具有特殊含義的識別符號，關鍵字和保留字都不建議用作變數名，

Go語言有25個關鍵字：

Go語言有37個保留字:

1、變數宣告

1. 變數的來歷

   ? 程式運行程序中的資料都是保存在記憶體中的，我們想要在代碼中操作某個資料時就要去記憶體上找到這個變數，但是如果我們直接在代碼中通過記憶體地址去操作變數的話，代碼的可讀性會非常差而且還容易出錯，所以我們就利用變數將這個資料的記憶體地址保存起來，以后直接通過這個變數就能在找到記憶體上對應的資料了，

2. 變數型別

   ? 變數（Variable）的功能是存盤資料，不同的變數保存資料型別可能會不一樣，經過半個多世紀的發展，編程語言已經基本形成了一套固定的型別，常見的變數的資料型別有：整形、浮點型、布爾型等，

   ? Go語言中的每一個變數都有自己的型別，并且變數必須經過宣告才能開始使用，

3. 變數的宣告

   ? Go語言中的變數需要宣告后才能使用，同一作用域內不支持重復宣告，并且Go語言的變數宣告后必須使用，

   • 標準宣告

     Go語言的變數宣告格式為：

     var 變數名 變數型別
     

     變數宣告以關鍵字var開頭，變數型別放在變數的后面，行尾無需分號，

     var name string
     var age int
     var isOK bool
     

   • 批量宣告

     每宣告一個變數就需要寫var關鍵字會比較繁瑣，go語言中還支持批量變數的宣告

     var(
     	a string
         b int
         c bool
         d float32
     )
     

   • 變數的初始化

     ? Go語言在宣告變數的時候，會自動對變數對應的記憶體區域進行初始劃操作，每個變數會被初始化成其型別的默認值，例如：整形和浮點型別變數的默認值為0，字串變數的默認值為空字串，布爾型別莫認為false，切片、函式、指標變數默認為nil，

     也可以在宣告變數的時候為其指定初始值，變數初始化的標準格式如下：

     var 變數名 型別 = 運算式
     // 例
     var username string = "eric"
     var age int = 18
     

     也能一次初始化多個變數

     var name, age = "eric", 18
     

   • 型別推導

     有時候我們會將變數的型別省略，這個時候編譯器會根據等號右邊的值來推導變數的型別完成初始化，

     var name = "eric"
     var age = 18
     

   • 短變數宣告

     在函式內部，可以使用跟簡略的:=方式宣告并初始化變數，

     package main
     
     import ("fmt")
     // 全域變數m
     var m = 100
     
     func main(){
         n := 10
         m := 200  //此處宣告區域變數m
         fmt.PrintLn(m,n)
     }
     
     

   • 匿名變數

     在使用多重賦值的時候，如果想要忽略某個值，可以使用匿名變數（anonymous variable），匿名變數用一個下劃線_表示，例如：

     func foo() (int, string){
         return 18, "eric"
     }
     func main() {
         x,_ := foo()
         _,y := foo()
         fmt.Println("x=", x)
         fmt.Println("y=", y)
     }
     

     匿名變數不占命名空間，不會分配記憶體，所以匿名變數之間不存在重復宣告，（在Lua等變編程語言里，匿名變數也被叫做啞圓變數，）

     注意事項：

     1. 函式外的每個陳述句都必須以關鍵字開始（var、const、func等）
     2. :=不能使用在函式外，
     3. _多用于占位，表示忽略值，
     4. go語言中變數宣告必須使用，不適用就編譯不過去
     5. 同一個作用域（{}）中不能重復宣告同名的變數

2、常量

? 相對于變數，常量是恒定不變的值，多用于定義程式運行期間不會改變的那些值，常量的宣告和變數的宣告非常類似，只是把var換成了const，常量在定義的時候必須賦值，

const pi = 3.14159275453
const e = 2.7182

? 宣告了pi e 這兩個常量之后，在整個程式運行期間他們的值都不能再發生變化了，多個常量也可以一起宣告：

const(
	pi = 3.14159275453
    e = 2.7182
)

const同時宣告多個常量時，如果省略了值則表示和上面一行的值相同，例如：

const(
	n1 = 100
    n2
    n3
)
// n1,n2,n3的值都是100

3、iota

使用_跳過某些值

const(
	n1 = iote // 第一次默認為0
    n2        // 1
    _
    n4        //3
)

iota宣告中間插隊

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

? 定義數量級（這里的<<表示左移操作，1<<10表示將1的二進制向左移10位，也就是由1變成了10000000000，也就是十進制的1024，同理2<<2表示將2的二進制向左移2位，也就是由10變成了1000，也就是十進制的8，）

const(
	_ = iota
    KB = 1<<(10*iota)
    MB = 1<<(10*iota)
    GB = 1<<(10*iota)
    TB = 1<<(10*iota)
    PB = 1<<(10*iota)
)

多個iota定義在一行

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

二、Go的基本資料型別

? Go語言中有豐富的資料型別，除了基本的整形、浮點型、布爾型、字串外，還有陣列、切片、結構體、函式、map、通道（channel）等，Go語言的基本資料型別和其它語言大同小異，

1、整形

基本整形

整形分為以下兩個大類：

• 按長度分為：int8、int16、int32、int64
• 對應的無符號整形：uint8、uint16、uint32、uint64

其中，uint8是我們常用和熟知的byte型，int16對應C語言中的shot型（C：短整型），int64對應C語言中的long型（C：長整型），

特殊整形

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

注意事項：獲取物件的長度的內建len()函式回傳值的長度可以根據不同平臺的位元組長度進行變化，實際使用中，切片或map的元素數量等都可以用int來表示，在涉及到二進制傳輸、讀寫檔案的結構描述時，為了保持檔案的結構不會受到不同編譯目標平臺的位元組長度影響，不要使用int和uint，

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

Go1.13版本之后引入了數字字面量語法，這樣便于開發者以二進制、八進制或十六進制浮點數的格式定義數字，例如：v:=0b001101101，代表二進制的101101，相當于十進制的45，v:=0o377，代表八進制的377，相當于十進制的255，v:=0x1p-2，代表十六進制的1除以2²，也就是0.25，

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

2、浮點型

Go語言中有兩種浮點型數：float32和float64，這兩種浮點型資料格式遵循IEEE 754標準：flaot32的浮點最大范圍約為1.8e308，可以使用一個常量定義：mathMaxFloat64，

列印浮點數時，可以使用fmt包配合動詞%f，代碼示例：

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%.2f\n", math.Pi)
    // 浮點數
	asd := 3.1415926
	fmt.Printf("%T\n", asd) // 默認Go語言中的小鼠都是float64型別
	asf := float32(3.14159)
	fmt.Printf("%T\n", asf) // 顯示宣告float32型別
	// asd = asf  // float32型別的值不能直接賦值給float64，反之還真不能
}

3、復數

兩種資料型別complate64和complate128

package main
import (
    "fmt"
    "math"
)
func main() {
    var c1 complex64
    c1 = 1 + 2i
    var c2 complex128
    c2 = 2 + 3i
    fmt.Println(c1)
    fmt.Println(c2)
}

4、布林值

Go語言中以bool型別進行宣告布爾型別資料，布爾型別資料只有true(真)和falde(假)兩個值，

注意：

1. 布爾型別變數的默認值為false，
2. Go語言中不允許將整形強制轉換為布爾型，
3. 布爾型無法參予數值運算，也無法與其它型別進行轉換，

5、字串

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

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

字串轉義符

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

舉個例子，我們要列印一個Windows平臺下的一個檔案路徑：

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\User\\AppDate\\.go\"")
}

多行字串

Go語言中要定義一個多行字串時，就必須使用反引號字符：

package main
import (
    "fmt"
)
func main() {
	asd := `第一行
第二行
第三行`
	fmt.Println(asd)
}

反引號間換行將被作為字串中的換行，但是所有的轉義字符均無效，文本將會原樣輸出，

字串的常用操作

標籤：Go

上一篇：[GO] golang happen before 的保證原則

下一篇：你好，Spring！