Go語言基礎

1、Go基礎

標識符：

​ go語言中的標識符由字母數字和下劃線（_）組成，而且只能以字母和下劃線（_）開頭

關鍵字:

​ 關鍵字是指編程語言中預先定義好的具備特殊含義的標識符。關鍵字和保留字都不建議用做變量名。

Go語言有25個關鍵字：

關鍵字
break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

Go語言有37個保留字:

類型	包含保留字
Constants	true false iota nil
Types	int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error
Functions	make len cap new append copy close delete complex real imag panic recover

一、變量聲明

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. 同一個做用域（{}）中不能重複聲明同名的變量

二、常量

​ 相對於變量，常量是恆定不變的值，多用於定義程序運行期間不會改變的那些值。常量的聲明和變量的聲明很是相似，只是把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

三、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
)

2、Go的基本數據類型

​ Go語言中有豐富的數據類型，除了基本的整形、浮點型、布爾型、字符串外，還有數組、切片、結構體、函數、map、通道（channel）等。Go語言的基本數據類型和其它語言大同小異。

一、整形

基本整形

整形分爲如下兩個大類：

• 按長度分爲：int八、int1六、int3二、int64
• 對應的無符號整形：uint八、uint1六、uint3二、uint64

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

類型	描述
uint8	無符號 8位整型 (0 到 255)
uint16	無符號 16位整型 (0 到 65535)
uint32	無符號 32位整型 (0 到 4294967295)
uint64	無符號 64位整型 (0 到 18446744073709551615)
int8	有符號 8位整型 (-128 到 127)
int16	有符號 16位整型 (-32768 到 32767)
int32	有符號 32位整型 (-2147483648 到 2147483647)
int64	有符號 64位整型 (-9223372036854775808 到 9223372036854775807)

特殊整形

類型	描述
uint	32位操做系統上就是uint32，64位操做系統上就是uint64
int	32位操做系統上就是int32，64位操做系統上就是int64
uintptr	無符號整型，用於存放一個指針

注意： 在使用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
}

二、浮點型

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，反之也不行。
}

三、複數

兩種數據類型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)
}

四、布爾值

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

注意：

1. 布爾類型變量的默認值爲false。
2. Go語言中不容許將整形強制轉換爲布爾型。
3. 布爾型沒法參予數值運算，也沒法與其它類型進行轉換。

五、字符串

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

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

字符串轉義符

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

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

舉個例子，咱們要打印一個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)
}

反引號間換行將被做爲字符串中的換行，可是全部的轉義字符均無效，文本將會原樣輸出。

字符串的經常使用操做

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