【原創】go語言學習（二）數據類型、變數量、常量量

2019 年 10 月 11 日
筆記

標識符、關鍵字

1.標識符是⽤用來表示Go中的變數量名或者函數名，以字⺟母或_開頭。後⾯面跟著字⺟母、_或數字
2. 關鍵字
A. 88ab B. _ab28 C. ab_28
關鍵字是Go語⾔言預先定義好的，有特殊含義的標識符

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

變數

1. 語法：

var identifier type

例1

var a int  var b string  var c bool  var d int = 8  var e string = “hello

例2

//變數  package main    import "fmt"    func main() {  	/*  		//方式1  		//整數 默認:0  		var a int  		// 布爾 默認:0flase  		var b bool  		// str 默認:""  		var c string  		// 浮點 默認:0.000000  		var d float32  		// 格式化輸出  	*/    	//方式二  	var (  		a int  		b bool  		c string  		d float32  	)    	fmt.Printf("a=%d b=%t c=%s d=%fn", a, b, c, d)    	a = 10  	b = true  	c = "hello"  	d = 10.8  }

常量

1. 常量使⽤用const 修飾，代表永遠是只讀的，不不能修改。
2. 語法：const identifier [type] = value，其中type可以省略略。
舉例：

const b string = “hello world”  const b = “hello world”  const Pi = 3.1414926 const a = 9/3

3. ⽐比較優雅的寫法：

const(       a = 1      b = 2      c = 3  )

4. 更更加專業的寫法：

iota，特殊常量，可以認為是一個可以被編譯器修改的常量。

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

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //獨立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢復計數
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //獨立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢復計數
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

　　以上實例運行結果為：

const(       a = 1 << iota      b      c  )

　　再看個有趣的的 iota 實例：

package main    import "fmt"  const (      i=1<<iota      j=3<<iota      k      l  )    func main() {      fmt.Println("i=",i)      fmt.Println("j=",j)      fmt.Println("k=",k)      fmt.Println("l=",l)  }

　　以上實例運行結果為：

i= 1  j= 6  k= 12  l= 24

iota 表示從 0 開始自動加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，這沒問題，關鍵在 k 和 l，從輸出結果看 k=3<<2，l=3<<3。

簡單表述:

　　i=1：左移 0 位,不變仍為 1;

j=3：左移 1 位,變為二進位 110, 即 6;
k=3：左移 2 位,變為二進位 1100, 即 12;
l=3：左移 3 位,變為二進位 11000,即 24。

數據類型

1. 布爾類型
a. var b bool 和 var b bool = true 和 var b = false
b. 操作符 == 和 !=
c. 取反操作符： !b
d. && 和 || 操作符
e. 格式化輸出佔位符: %t

2. 整數和浮點數類型
a. int8、int16、int32、int64
b. uint8、uint16、uint32、uint64
c. int 和 uint，和作業系統平台相關
d. float32 和 float64浮點類型
e. 所有整數初始化為0，所有浮點數初始化為0.0，布爾類型初始化為false

3. 整數和浮點數類型
a. Go是強類型語⾔言，不不同類型相加以及賦值是不不允許的
b. 那怎麼樣才能實現，不不同類型相加呢？
c. 輸出佔位符：整數%d，%x⼗十六進位，%f浮點數

字元串

1. 字元串串的兩種表示⽅方式

a. 雙引號， “”，可以包含控制字元

b. 反引號， “，所有字元都是原樣輸出

package main    import “fmt”    func main() {      var str = “hello worldnn”       var str2 = `hello n n n`      fmt.Println(“str=“, str)      fmt.Println(“str2=“, str2)  }

2. 字元串串常⽤用操作

a. ⻓長度：len(str)

b. 拼接：+，fmt.Sprintf

c. 分割：strings.Split

d. 包含： strings.Contains

e. 前綴或後綴判斷：strings.HasPrefix, strings.HasSuffix

f. ⼦子串串出現的位置: strings.Index(), strings.LastIndex()

g. join操作： strings.Join(a[]string, sep string)

數據類型和操作符

1、操作符
a. 邏輯操作符， == 、 != 、<、<=、>=
b. 算數操作符， +、-、*、/、%

go程式的基本結構

1. 任何⼀一個程式碼⽂文件⾪隸屬於⼀一個包

package main  import “fmt”  func main() {      fmt.Println(“hello, world”) 
}

2. import 關鍵字，引⽤用其他包：

import(“fmt”)

import(“os”)

通常習慣寫成：

import (

　　“fmt”

　　“os”

)

3. 開發可執⾏行行程式，package main，並且有且只有⼀一個main⼊入⼝口函數
4. 包中函數調⽤用：

a. 同⼀一個包中函數，直接⽤用函數名調⽤用
b. 不不同包中函數，通過包名+點+ 函數名進⾏行行調⽤用

5. 包訪問控制規則：

a. ⼤大寫意味著這個函數/變數量是可導出的

b. ⼩小寫意味著這個函數/變數量是私有的，包外部不不能訪問