1. Go語言中變數的宣告

Go 語言變數名由字母, 數字, 下劃線組成; 其中首個字元不能為數字; Go語言中關鍵字和保留字都不能作變數名;

Go 語言中的變數需要宣告後才能使用, 同一作用域內不支援重複宣告; 並且Go語言的變數宣告後必須使用;

1.1 var宣告變數

var 變數名稱 變數型別

• 變數宣告後沒有初始化的話, 值為空

func main() {
	// 變數名  :=  表示式
	var name string
	var a1 = "張三"         //可以省略型別
	fmt.Println(name, a1) //變數宣告後沒有初始化的話,  值為空
}

1.2 變數的初始化

Go 語言在宣告變數的時候，會自動對變數對應的記憶體區域進行初始化操作。每個變數會被初始化成其型別的預設值;

例如：

1. 整型和浮點型變數的預設值為 0。

2. 字串變數的預設值為空字串。

            3.  布林型變數預設為 false。
            4.  切片、函式、指標變數的預設為 nil。
   

• 初始化第一種方式, 先宣告後賦值

  func main() {
  	var name string //變數宣告
  	name = "張三"     //變數初始化賦值
  	fmt.Printf(name)
  }
  

• 第二種方式, 宣告的時候直接賦值

  //定義入口檔案
  func main() {
  	var name string = "張三" 
  	fmt.Println(name, age)
  }
  

• 第三種初始化方式, 型別推導的方式直接賦值, 省略 變數型別, 推薦使用

  func main() {
  	var age = 18 //型別可以省略, 可以根據型別推導自動判斷型別
  	fmt.Println(age)
  }
  

1.3 一次宣告多個變數

• var 變數名稱, 變數名稱 型別; 宣告的變數型別必須一致

  //定義入口檔案
  func main() {
  	var name, sex string  //宣告的變數型別必須一致
  	fmt.Printf("name的型別是%T sex的型別是%T", name, sex)
  }
  

• 宣告的變數型別可以不一致

  func main() {
  	var (
  		name string
  		age  int
  		sex  = "男" //宣告的時候可以直接賦值,可以省略資料型別,自動推導型別
  	)
  	fmt.Printf("name的型別是%T age的型別是%T sex的值是=%v", name, age, sex)
  }
  

  注意:

  • go語言中, 宣告的變數型別和賦值的型別必須保持一致, 比如,宣告為string,就必須賦值為string
  • 變數宣告之後, 必須要使用, 不然會報錯

1.4 短變數宣告法(推薦使用)

• 在函式的內部, 可以使用更簡略的 := 方式宣告並初始化變數
• 注意: 短變數只能用於宣告區域性變數; 不能用於全域性變數的宣告

var a = 10
//定義入口檔案
func main() {
	b := "男"
	fmt.Printf("a=%v b=%v", a, b)
}

• 宣告多個變數

  func main() {
  	a, b, c := 12, 13, "學習" //型別可以不一致,  var宣告必須保持型別一致, 不能型別推導
  	fmt.Println(a, b, c)
  }
  

1.5 型別推導

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

1.6 匿名變數(忽略某個值)

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

• 匿名變數不佔用名稱空間, 不會分配記憶體, 所以匿名變數之間不存在重複宣告

//(int, string) 表示要返回資料的型別
func getInfo() (int, string) {
	return 10, "張三"
}

func main() {
	// 下劃線_ 忽略了10, 張三賦值給了username
	_, username := getInfo()
	fmt.Println(username)
}

2. Go語言中的常量

2.1 使用const定義常量

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

• 常量在定義的時候必須賦值
• const 同時宣告多個常量時，如果省略了值則表示和上面一行的值相同

func main() {
	const p = 3.1415
	// p = 1.123 不能重新賦值, 變數可以
	fmt.Println(p) //在整個程式執行期間它們的值都不能再發生變化了
	const (
		n1 = 100
		n2  //如果省略了值則表示和上面一行的值相同
		n3  //如果省略了值則表示和上面一行的值相同
	)
	fmt.Println(n1, n2, n3) 
}

輸出:
I:\goiteam>go run main.go
3.1415
100 100 100

2.2 const常量和iota的使用

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

iota 在 const 關鍵字出現時將被重置為 0(const 內部的第一行之前);

const 中每新增一行常量宣告將使 iota 計數一次(iota 可理解為 const 語句塊中的行索引)。

2.2.1 iota 只能在常量的表示式中使用;

2.2.2 每次 const 出現時, 都會讓 iota 初始化為0 (自增長)

func main() {
	const p = iota //p=0
	const (
		n1 = iota //0
		n2        //1
		n3        //2
	)
	fmt.Println(p, n1, n2, n3) //0 0 1 2
}

2.2.3 const iota 使用_跳過某些值

func main() {
	const (
		n1 = iota //0
		n2        //1
		_
		n3 //3
	)
	fmt.Println(n1, n2, n3) // 0 1 3
}

2.2.4 iota 宣告中間插隊

func main() {
	const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	fmt.Println(n1, n2, n3, n4) //0 100 2 3
}

2.2.5 多個 iota 定義在一行

func main() {
	const (
		n1     = iota               //0
		n2, n3 = iota + 1, iota + 2 //2,3
		n4, n5                      //3,4
	)
	fmt.Println(n1, n2, n3, n4, n5) //0 2 3 3 4
}

3. Go語言變數, 常量命名規則

• 變數名稱必須由數字、字母、下劃線組成
• 識別符號開頭不能是數字
• 識別符號不能是保留字和關鍵字
• 變數的名字是區分大小寫的如: age 和 Age 是不同的變數。在實際的運用中,也建議,不要用一個單詞大小寫區分兩個變數。
• 識別符號(變數名稱)一定要見名思意 ：變數名稱建議用名詞，方法名稱建議用動詞;
• 變數命名一般採用駝峰式(大駝峰或小駝峰)，當遇到特有名詞（縮寫或簡稱，如 DNS）的時候，特有名詞根據是否私有全部大寫或小寫;

4. Go語言程式碼風格

• 程式碼每一行結束後不用寫分號（ ;）

• 運算子左右建議各加一個空格: var username string = "itying"

• Go 語言程式設計師推薦使用駝峰式命名; 當名字有幾個單片語成的時優先使用大小寫分隔

  小駝峰表示私有, 大駝峰表示公有

• 強制的程式碼風格

  左括號必須緊接著語句不換行，這個特性剛開始會使開發者不習慣，但隨著對 Go 語言的不斷熟悉，就會發現風格統一讓大家在閱讀程式碼時把注意力集中到了解決問題上，而不是程式碼風格上

• go fmt 主要用於格式化文件，讓所有人的程式碼風格保持一致, 現在一般編輯器儲存都自動格式化了

D:\golang\src\demo01>go fmt main.go main.go