05-Go語言常量和變數

摘要： Go語言資料型別 Go語言本質是用C語言編寫的一套高階開發語言, 所以Go語言中的資料型別大部分都是由C語言演變而來的 C語言資料型別 Go語言資料型別 C語言各資料型別佔用記...

Go語言資料型別

• Go語言本質是用C語言編寫的一套高階開發語言, 所以Go語言中的資料型別大部分都是由C語言演變而來的

• C語言資料型別

  

• Go語言資料型別

  

• C語言各資料型別佔用記憶體空間

型別	32位編譯器	64位編譯器
char	1	1
int	4	4
float	4	4
double	8	8
short	2	2
long	4	8
long long	8	8
void*	4	8

• Go語言各資料型別佔用記憶體空間

型別	32位編譯器	64位編譯器	本質
int8/uint8	1	1	signed char/unsigned char
int16/uint16	2	2	signed short/unsigned short
int32/uint32	4	4	signed int/unsigned int
int64/uint64	8	8	signed long long int/unsigned long long int
byte	1	1	uint8/unsigned char
rune	4	4	int32/signed int
int	4	8	根據機器位數決定長度
uintptr	4	8	根據機器位數決定長度 uint32/uint64
float32	4	4	float
float64	8	8	double
true	1	1	char型別的整型
false	1	1	char型別的整型

• 和C語言一樣,Go語言也提供了Sizeof計算變數的記憶體空間
  • 1.匯入import "unsafe"包
  • 2.通過unsafe.Sizeof()計算變數記憶體空間

package main

import (
"fmt"
"unsafe"
)

func main() {
fmt.Println("int size = ", unsafe.Sizeof(int(0)))
fmt.Println("int8 size = ", unsafe.Sizeof(int8(0)))
fmt.Println("int16 size = ", unsafe.Sizeof(int16(0)))
fmt.Println("int32 size = ", unsafe.Sizeof(int32(0)))
fmt.Println("int64 size = ", unsafe.Sizeof(int64(0)))
fmt.Println("uint size = ", unsafe.Sizeof(uint(0)))
fmt.Println("uint8 size = ", unsafe.Sizeof(uint8(0)))
fmt.Println("uint16 size = ", unsafe.Sizeof(uint16(0)))
fmt.Println("uint32 size = ", unsafe.Sizeof(uint32(0)))
fmt.Println("uint64 size = ", unsafe.Sizeof(uint64(0)))
fmt.Println("uintptr size = ", unsafe.Sizeof(uintptr(0)))
fmt.Println("byte size = ", unsafe.Sizeof(byte(0)))
fmt.Println("rune size = ", unsafe.Sizeof(rune(0)))
fmt.Println("float32 size = ", unsafe.Sizeof(float32(0)))
fmt.Println("float64 size = ", unsafe.Sizeof(float64(0)))
fmt.Println("true size = ", unsafe.Sizeof(true))
fmt.Println("false size = ", unsafe.Sizeof(false))

}

• Go語言基本資料型別內部實現
  • ofollow,noindex">golang官方網站下載go1.4版本原始碼
    • 越老版本的程式碼越純粹,越適合新手學習
    • 隨著程式碼的更新迭代會逐步變得非常複雜, 所以此處建議下載1.4版本
  • 解壓後開啟路徑: go\src\runtime\runtime.h
  • 
  • 得到如下實現程式碼

// 第8行到35行
typedef signed charint8;
typedef unsigned charuint8;
typedef signed shortint16;
typedef unsigned shortuint16;
typedef signed intint32;
typedef unsigned intuint32;
typedef signed long long intint64;
typedef unsigned long long intuint64;
typedef floatfloat32;
typedef doublefloat64;

#ifdef _64BIT
typedef uint64uintptr;
typedef int64intptr;
typedef int64intgo; // Go's int
typedef uint64uintgo; // Go's uint
#else
typedef uint32uintptr;
typedef int32intptr;
typedef int32intgo; // Go's int
typedef uint32uintgo; // Go's uint
#endif

#ifdef _64BITREG
typedef uint64uintreg;
#else
typedef uint32uintreg;
#endif

// 第153行到157行
enum
{
true= 1,
false= 0,
};

install B 時刻:

Go本質就是用C語言編寫的一門高階程式語言

所以江哥前面教你C語言就是為了今天能讓你看懂Go的實現程式碼,做到知其然知其所以然

注意點: 企業開發中一般使用int, 因為int會根據你當前的作業系統自動轉換為int32和int64

Go語言變數

• Go語言中變數的概念和C語言中也一樣, 所以我們直接來看下如何定義和使用變數即可
• C語言中定義變數的格式

資料型別 變數名稱;
資料型別 變數名稱1, 變數名稱2;

#include <stdio.h>

int main(int argc, const char * argv[])
{
int num1; // 先定義
num1 = 10; // 後初始化
printf("num1 = %d\n", num1);

int num2 = 20; // 定義的同時初始化
printf("num2 = %d\n", num2);

// 注意: 同時定義多個變數,不支援定義時初始化, 只能先定義後初始化
int num3, num4; //同時定義多個變數
num3 = 30;
num4 = 40;
printf("num3 = %d\n", num3);
printf("num4 = %d\n", num4);

return 0;
}

• Go語言中定義變數有三種格式

// 標準格式
var 變數名稱 資料型別 = 值;
// 自動推到型別格式
var 變數名稱 = 值;
// 簡短格式(golang官方推薦格式)
變數名稱 := 值;

package main
import "fmt"
func main() {
var num1 int // 先定義
num1 = 10 // 後賦值
fmt.Println("num1 = ", num1)

var num2 int = 20 // 定義的同時賦值
fmt.Println("num2 = ", num2)

var num3= 30 // 定義的同時賦值, 並省略資料型別
fmt.Println("num3 = ", num3)

num4:= 40 // 定義的同時賦值, 並省略關鍵字和資料型別
/*
num4:= 40 等價於
var num4 int
num4 = 40
*/
fmt.Println("num4 = ", num4)
}

• 和C語言一樣,除了可以定義單個變數以外,還支援一次性定義多個變數
  • 方式一, 連續定義

  package main
   import "fmt"
   func main() {
  var num1, num2 int // 先定義
  num1 = 10// 後賦值
  num2 = 20
  fmt.Println("num1 = ", num1)
  fmt.Println("num2 = ", num2)
   
  var num3, num4 int = 30, 40 // 定義的同時賦值
  fmt.Println("num3 = ", num3)
  fmt.Println("num4 = ", num4)
   
  var num5, num6 = 50, 60 // 定義的同時賦值, 並省略資料型別
  fmt.Println("num5 = ", num5)
  fmt.Println("num6 = ", num6)
   
  num7, num8 := 70, 80 // 定義的同時賦值, 並省略關鍵字和資料型別
  fmt.Println("num7 = ", num7)
  fmt.Println("num8 = ", num8)
   }

  • 方式二, 變數組

  package main
  import "fmt"
  func main() {
  var( // 先定義
  num1 int
  num2 float32
  )
  num1 = 10 // 後賦值
  num2 = 3.14
  fmt.Println("num1 = ", num1)
  fmt.Println("num2 = ", num2)
  
  var( // 定義的同時賦值
  num3 int = 30
  num4 float32 = 6.66
  )
  fmt.Println("num3 = ", num3)
  fmt.Println("num4 = ", num4)
  
  var( // 定義的同時賦值, 並省略資料型別
  num5 = 50
  num6 = 7.77
  )
  fmt.Println("num5 = ", num5)
  fmt.Println("num6 = ", num6)
  
  var( // 一行定義多個
  num7, num8 = 70, 80
  num9, num10 = 9.99, 100
  )
  fmt.Println("num7 = ", num7)
  fmt.Println("num8 = ", num8)
  fmt.Println("num9 = ", num9)
  fmt.Println("num10 = ", num10)
  }

Go語言變數定義注意點

• 簡短模式的含義是定義的同時初始化

package main
import "fmt"
func main() {
num := 10
num := 20 // 編譯報錯, 重複定義
fmt.Println("num = ", num)
}

• 一定不要把:=當做賦值運算子來使用

package main
import "fmt"
var num = 10 // 定義一個全域性變數
func main() {
num := 20 // 定義一個區域性變數
fmt.Println("num = ", num)
test()
}
func test() {
fmt.Println("num = ", num) // 還是輸出10
}

• :=只能用於定義區域性變數,不能用於定義全域性變數

package main
import "fmt"
num := 10 // 編譯報錯
func main() {
fmt.Println("num = ", num)
}

• 使用:=定義變數時,不能指定var關鍵字和資料型別

package main
import "fmt"
func main() {
//var num int := 10 // 編譯報錯
//var num := 10 // 編譯報錯
num int := 10 // 編譯報錯
fmt.Println("num = ", num)
fmt.Println("num = ", num)
}

• 變數組中不能夠使用:=

package main
import "fmt"
func main() {
var(
num := 10 // 編譯報錯
)
fmt.Println("num = ", num)
}

• 通過:=同時定義多個變數, 必須給所有變數初始化

package main
import "fmt"
func main() {
//num1, num2 := 666, 888 // 正確
num1, num2 := 666 // 報錯
fmt.Printf("%d, %d\n", num1, num2)
}

• 通過:=同時定義多個變數, 只要任意一個變數沒有定義過,都會做退化賦值操作

package main
import "fmt"
func main() {
// 定義一個變數num1
num1 := 10
// 同時定義兩個變數num1和num2, 由於num2從來沒有定義過,
// 所以對於num1來說:=退化為賦值運算子, 而對於num2來說:=仍然是定義+賦值
num1, num2 := 20, 30
fmt.Println("num1 = ", num1)
fmt.Println("num2 = ", num2)
}

package main
import "fmt"
func main() {
num1 := 10
num2 := 20
// 報錯, 因為num1,和num2都已經被定義過
// 至少要有任意一個變數沒有被定義過,才會退化賦值
num1, num2 := 30, 40
fmt.Println("num1 = ", num1)
fmt.Println("num2 = ", num2)
}

• 定義的區域性變數或者匯入的包沒有被使用, 那麼編譯器會報錯,無法編譯執行,但是定義的全域性變數沒有被使用,編譯器不會報錯, 可以編譯執行

區域性變數和全域性變數

• 和C語言一樣,按照變數的作用域,我們可以把變數劃分為區域性變數和全域性變數

• Go語言中區域性變數的概念以及全域性變數的概念和C語言一模一樣

• 區域性變數：

  • 定義在函式內部的變數以及函式的形參稱為區域性變數
  • 作用域：從定義哪一行開始直到與其所在的程式碼塊結束
  • 生命週期:從程式執行到定義哪一行開始分配儲存空間到程式離開該變數所在的作用域

• 全域性變數：

  • 定義在函式外面的變數稱為全域性變數
  • 作用域範圍：從定義哪行開始直到檔案結尾
  • 生命週期:程式一啟動就會分配儲存空間,直到程式結束

• 和C語言不同的是, C語言中可以定義相同名稱的全域性變數, 而Go語言中無論全域性變數還是區域性變數, 只要作用域相同都不能出現同名的變數

package main
import "fmt"
//var num1 int
//var num1 int // 報錯, 重複定義
var num3 int
func main() {
//var num2
//var num2 // 報錯, 重複定義

var num3 int // 不報錯, 因為作用域不同
fmt.Println("num3 = ", num3)
}

• C語言中全域性變數沒有賦值,那麼預設初始值為0, 區域性變數沒有賦值,那麼預設初始值是隨機值
• Go語言中無論是全域性變數還是區域性變數,只要定義了一個變數都有預設的0值
  • int/int8/int16/int32/int64/uint/uint8/uint16/uint32/uint64/byte/rune/uintptr的預設值是0
    +float32/float64的預設值是0.0
  • bool的預設值是false
  • string的預設值是""
  • pointer/function/interface/slice/channel/map/error的預設值是nil
  • 其它複合型別array/struct預設值是內部資料型別的預設值

package main
import "fmt"
func main() {
var intV int // 整型變數
var floatV float32 // 實型變數
var boolV bool // 布林型變數
var stringV string // 字串變數
var pointerV *int // 指標變數
var funcV func(int, int)int // function變數
var interfaceV interface{} // 介面變數
var sliceV []int // 切片變數
var channelV chan int // channel變數
var mapV map[string]string // map變數
var errorV error // error變數

fmt.Println("int = ", intV) // 0
fmt.Println("float = ", floatV) // 0
fmt.Println("bool = ", boolV) // false
fmt.Println("string = ", stringV) // ""
fmt.Println("pointer = ", pointerV) // nil
fmt.Println("func = ", funcV) // nil
fmt.Println("interface = ", interfaceV) // nil
fmt.Println("slice = ", sliceV) // []
fmt.Println("slice = ", sliceV == nil) // true
fmt.Println("channel = ", channelV) // nil
fmt.Println("map = ", mapV) // map[]
fmt.Println("map = ", mapV == nil) // true
fmt.Println("error = ", errorV) // nil

var arraryV [3]int // 陣列變數
type Person struct{
name string
age int
}
var structV Person // 結構體變數
fmt.Println("arrary = ", arraryV) // [0, 0, 0]
fmt.Println("struct = ", structV) // {"" 0}
}

資料型別轉換

只能顯示轉換

#include <stdio.h>
int main(){
// 隱式轉換:自動將實型10.6轉換為整型後儲存
int a = 10.6;
 // 自動型別提升: 運算時會自動將小型別轉換為大型別後運算
double b = 1.0 / 2; // 等價於1.0 / 2.0
}

• C語言顯示轉換(強制轉換)

#include <stdio.h>
int main(){
// 顯示轉換:強制將實型10.6轉換為整型後儲存
int a = (int)10.5;
}

• Go語言數值型別之間轉換

  資料型別(需要轉換的資料)
  

  package main
  import "fmt"
  func main() {
  var num0 int = 10
  var num1 int8 = 20
  var num2 int16
  //num2 = num0 // 編譯報錯, 不同長度的int之間也需要顯示轉換
  //num2 = num1 // 編譯報錯, 不同長度的int之間也需要顯示轉換
  num2 = int16(num0)
  num2 = int16(num1)
  fmt.Println(num2)
  
  var num3 float32 = 3.14
  var num4 float64
  //num4 = num3 // 編譯報錯, 不同長度的float之間也需要顯示轉換
  num4 = float64(num3)
  fmt.Println(num4)
  
  var num5 byte = 11
  var num6 uint8 // 這裡不是隱式轉換, 不報錯的原因是byte的本質就是uint8
  num6 = num5
  fmt.Println(num6)
  
  var num7 rune = 11
  var num8 int32
  num8 = num7 // 這裡不是隱式轉換, 不報錯的原因是byte的本質就是int32
  fmt.Println(num8)
  }

數值型別和字串型別之間轉換

• Go語言中不能通過 資料型別(變數)的格式將數值型別轉換為字串, 也不能通過 資料型別(變數)的格式將字串轉換為數值型別

package main
import "fmt"
func main() {
var num1 int32 = 65
// 可以將整型強制轉換, 但是會按照ASCII碼錶來轉換
// 但是不推薦這樣使用
var str1 string = string(num1)
fmt.Println(str1)

var num2 float32 = 3.14
// 不能將其它基本型別強制轉換為字串型別
var str2 string = string(num2)
fmt.Println(str2)

var str3 string = "97"
// 不能強制轉換, cannot convert str2 (type string) to type int
var num3int = int(str3)
fmt.Println(num3)
}

• 數值型別轉字串型別 strconv..FormatXxx()

package main
import "fmt"
func main() {
var num1 int32 = 10
// 第一個引數: 需要被轉換的整型,必須是int64型別
// 第二個引數: 轉換為幾進位制,必須在2到36之間
// 將32位十進位制整型變數10轉換為字串,並繼續保留10進位制格式
str1 := strconv.FormatInt(int64(num1), 10)
fmt.Println(str1) // 10
// 將32位十進位制整型變數10轉換為字串,並轉換為2進位制格式
str2 := strconv.FormatInt(int64(num1), 2)
fmt.Println(str2) // 1010

var num5 float64 = 3.1234567890123456789
// 第一個引數: 需要轉換的實型, 必須是float64型別
// 第二個引數: 轉換為什麼格式,f小數格式, e指數格式
// 第三個引數: 轉換之後保留多少位小數, 傳入-1按照指定型別有效位保留
// 第四個引數: 被轉換資料的實際位數,float32就傳32, float64就傳64
// 將float64位實型,按照小數格式並保留預設有效位轉換為字串
str3 := strconv.FormatFloat(num5, 'f', -1, 64)
fmt.Println(str3) // 3.1234567
str4 := strconv.FormatFloat(num5, 'f', -1, 64)
fmt.Println(str4) // 3.1234567890123457
// 將float64位實型,按照小數格式並保留2位有效位轉換為字串
str5 := strconv.FormatFloat(num5, 'f', 2, 64)
fmt.Println(str5) // 3.12
// 將float64位實型,按照指數格式並保留2位有效位轉換為字串
str6 := strconv.FormatFloat(num5, 'e', 2, 64)
fmt.Println(str6) // 3.12

var num6 bool = true
str7 := strconv.FormatBool(num6)
fmt.Println(str7) // true
}

• 字串型別轉數值型別 strconv.ParseXxx()

package main
import "fmt"
func main() {
var str1 string = "125"
// 第一個引數: 需要轉換的資料
// 第二個引數: 轉換為幾進位制
// 第三個引數: 轉換為多少位整型
// 注意點: ParseInt函式會返回兩個值, 一個是轉換後的結果, 一個是錯誤
// 如果被轉換的資料轉換之後沒有超出指定的範圍或者不能被轉換時,
// 那麼錯誤為nil, 否則錯誤不為nil
// 將字串"125"轉換為10進位制的int8
num1, err := strconv.ParseInt(str1, 10, 8)
if err != nil {
fmt.Println(err)
}
fmt.Println(num1)

var str2 string = "150"
// 將字串"150"轉換為10進位制的int8
// 由於int8的取值範圍是-128~127, 所以轉換之後超出了指定的範圍, error不為nil
num2, err := strconv.ParseInt(str2, 10, 8)
if err != nil {
fmt.Println(err)
}
fmt.Println(num2)

var str3 string = "3.1234567890123456789"
// 第一個引數: 需要轉換的資料
// 第二個引數: 轉換為多少位小數, 32 or 64
// ParseFloat同樣有兩個返回值, 如果能夠正常轉換則錯誤為nil, 否則不為nil
num3, err := strconv.ParseFloat(str3, 32)
if err != nil {
// 例如: 把字串"3.14abc"轉換為小數就會報錯, 因為"3.14abc"不是一個小數
fmt.Println(err)
}
fmt.Println(num3)

var str4 string = "true"
// 第一個引數: 需要轉換的資料
// ParseBool同樣有兩個返回值, 如果能夠正常轉換則錯誤為nil, 否則不為nil
num4, _ := strconv.ParseBool(str4)
fmt.Println(num4)
}

• 字串型別轉換為數值型別時,如果不能轉換除了返回error以外,還會返回對應型別的預設值

package main
import "fmt"
func main() {
var str1 string = "abc"
num1, _ := strconv.ParseInt(str1, 10, 32)
fmt.Println(num1) // 0

num2, _ := strconv.ParseFloat(str1, 32)
fmt.Println(num2) // 0

num3, _ := strconv.ParseBool(str1)
fmt.Println(num3) // false
}

• 看完上面的程式碼有沒有種想打人的感覺? 如果有那麼請繼續往下看
• 字串型別和整型快速轉換

package main
import "fmt"
func main() {
var num1 int32 = 110
// 快速將整型轉換為字串型別
// 注意:Itoa方法只能接受int型別
var str1 string = strconv.Itoa(int(num1))
fmt.Println(str1)

var str2 string = "666"
// 快速將字串型別轉換為整型
// 注意: Atoi方法返回兩個值, 一個值是int,一個值是error
// 如果字串能被轉換為int,那麼error為nil, 否則不為nil
num2, err := strconv.Atoi(str2)
if err != nil{
fmt.Println(err)
}
fmt.Println(num2)
}

• 數值型別轉字串型別其它方式

package main
import "fmt"
func main() {
var num1 int32 = 110
// Sprintf函式和Printf函式很像, 只不過不是輸出而將格式化的字串返回給我們
var str1 string = fmt.Sprintf("%d", num1)
fmt.Println(str1)

var num2 float32 = 3.14
var str2 string = fmt.Sprintf("%f", num2)
fmt.Println(str2)

var num3 bool = true
var str3 string = fmt.Sprintf("%t", num3)
fmt.Println(str3)
}

Go語言常量

• 和C語言一樣Go語言中的常量也分為 整型常量 、 實型常量 、 字元常量 、 字串常量 、 自定義常量

• 自定義常量

  • C語言自定義常量: const 資料型別 常量名稱 = 值;

  #include <stdio.h>
  int main(int argc, const char * argv[])
  {
  const float PI = 998;
  PI = 110; // 報錯
  printf("PI = %d\n", PI );
  return 0;
  }

  • Go語言自定義常量: const 常量名稱 資料型別 = 值 or const 常量名稱 = 值

  package main
  import "fmt"
  func main() {
  //const PI float32 = 3.14
  //PI = 110 // 報錯
  //fmt.Println("PI = ", PI )
  
  const PI = 3.14
  PI = 110 // 報錯
  fmt.Println("PI = ", PI )
  }

  • 除此之外Go語言還支援 一次性定義多個常量

  package main
  import "fmt"
  func main() {
  // 多重賦值方式
  const num1, num2 int= 100, 200
  fmt.Println("num1 = ", num1)
  fmt.Println("num2 = ", num2)
  
  // 常量組方式
  const (
  num3 = 100
  num4 = 200
  )
  fmt.Println("num3 = ", num3)
  fmt.Println("num4 = ", num4)
  
  // 常量組+多重賦值
  const (
  num5, num6 = 100, 200
  num7 = 300
  )
  fmt.Println("num5 = ", num5)
  fmt.Println("num6 = ", num6)
  fmt.Println("num7 = ", num7)
  }

• Go語言自定義常量注意點
  • 定義的區域性變數或者匯入的包沒有被使用, 那麼編譯器會報錯,無法編譯執行
  • 但是定義的常量沒有被使用,編譯器不會報錯, 可以編譯執行

  package main
  import "fmt"
  func main() {
  // 可以編譯執行
  const PI float32 = 3.14
  }

  • 在常量組中, 如果上一行常量有初始值,但是下一行沒有初始值, 那麼下一行的值就是上一行的值

  package main
  import "fmt"
  func main() {
  const (
  num1 = 998
  num2 // 和上一行的值一樣
  num3 = 666
  num4 // 和上一行的值一樣
  num5 // 和上一行的值一樣
  )
  fmt.Println("num1 = ", num1) // 998
  fmt.Println("num2 = ", num2) // 998
  fmt.Println("num3 = ", num3) // 666
  fmt.Println("num4 = ", num4) // 666
  fmt.Println("num5 = ", num5) // 666
  
  const (
  num1, num2 = 100, 200
  num3, num4// 和上一行的值一樣, 注意變數個數必須也和上一行一樣
  )
  fmt.Println("num1 = ", num1)
  fmt.Println("num2 = ", num2)
  fmt.Println("num3 = ", num3)
  fmt.Println("num4 = ", num4)
  }

• 列舉常量
  • C語言中列舉型別的本質就是整型常量
  • Go語言中沒有C語言中明確意義上的enum定義, 但是可以藉助iota識別符號來實現列舉型別
• C語言列舉格式:

enum　列舉名　{
列舉元素1,
列舉元素2,
… …
 };

• • C語言列舉中,如果沒有指定初始值,那麼從0開始遞增

  #include <stdio.h>
  int main(int argc, const char * argv[])
  {
  enum Gender{
  male,
  female,
  yao,
  };
  //enum Gender g = male;
  //printf("%d\n", g); // 0
  //enum Gender g = female;
  //printf("%d\n", g); // 1
  enum Gender g = yao;
  printf("%d\n", g); // 2
  return 0;
  }

  • C語言列舉中, 如果指定了初始值,那麼從指定的數開始遞增

  #include <stdio.h>
  int main(int argc, const char * argv[])
  {
  enum Gender{
  male = 5,
  female,
  yao,
  };
  //enum Gender g = male;
  //printf("%d\n", g); // 5
  //enum Gender g = female;
  //printf("%d\n", g); // 6
  enum Gender g = yao;
  printf("%d\n", g); // 7
  return 0;
  }

• Go語言實現列舉格式

const(
列舉元素1 = iota
列舉元素2 = iota
... ...
)

• • 利用iota識別符號識別符號實現從0開始遞增的列舉

  package main
  import "fmt"
  func main() {
  const (
  male = iota
  female = iota
  yao = iota
  )
  fmt.Println("male = ", male) // 0
  fmt.Println("male = ", female) // 1
  fmt.Println("male = ", yao) // 2
  }

• iota注意點:

  每一行遞增1
  

  package main
  import "fmt"
  func main() {
  const (
  male = iota // 這裡出現了iota
  female // 這裡會自動遞增
  yao
  )
  fmt.Println("male = ", male) // 0
  fmt.Println("male = ", female) // 1
  fmt.Println("male = ", yao) // 2
  }

  • 在同一個常量組中,如果iota被中斷, 那麼必須顯示恢復

  package main
  import "fmt"
  func main() {
  const (
  male = iota 
  female = 666 // 這裡被中斷, 如果沒有顯示恢復, 那麼下面沒有賦值的常量都和上一行一樣
  yao
  )
  fmt.Println("male = ", male) // 0
  fmt.Println("male = ", female) // 666
  fmt.Println("male = ", yao) // 666
  }

  package main
  import "fmt"
  func main() {
  const (
  male = iota 
  female = 666 // 這裡被中斷
  yao = iota // 這裡顯示恢復, 會從當前常量組第一次出現iota的地方開始,每一行遞增1, 當前是第3行,所以值就是2
  )
  fmt.Println("male = ", male) // 0
  fmt.Println("male = ", female) // 666
  fmt.Println("male = ", yao) // 2
  }

  • iota也支援常量組+多重賦值, 在同一行的iota值相同

  package main
  import "fmt"
  func main() {
  const (
  a, b = iota, iota
  c, d = iota, iota
  )
  fmt.Println("a = ", a) // 0
  fmt.Println("b = ", b) // 0
  fmt.Println("c = ", c) // 1
  fmt.Println("d = ", d) // 1
  }

  • iota自增預設資料型別為int型別, 也可以顯示指定型別

  package main
  import "fmt"
  func main() {
  const (
  male float32 = iota // 顯示指定型別,後續自增都會按照指定型別自增
  female
  yao
  )
  fmt.Printf("%f\n", male) // 0.0
  fmt.Printf("%f\n", female) // 1.0
  fmt.Printf("%f\n", yao) // 2.0
  fmt.Println("male = ", reflect.TypeOf(female)) // float32
  }