變數（Variable）是儲存值的位置，變數宣告可以給予識別名稱（Identifier）、型態與初始值，在 Go 中寫下的 10、3.14、true、"Justin" 等稱之為常數（Constant），常數宣告可給予這些常數識別名稱。

基本變數宣告

要在 Go 中進行變數宣告有多種形式，使用 var 是最基本的方式。例如，宣告一個 x 變數，型態為 int，初始值為 10：

var x int = 10

這麼一來，從 x 這個位置開始，儲存了 int 長度的值 10，在宣告變數時，型態是寫在名稱之後。你也可以同時建立多個變數並指定初值：

var x, y, z int = 10, 20, 30

這樣的話，x、y、z 的型態都是 int，值分別是 10、20、30。如果宣告多個變數時，想要指定不同的型態，可以使用批量宣告：

var (
    x int = 10
    y string = "Justin"
    z bool = true
)

如果宣告變數時指定了型態，但未指定初值，那麼編輯器會提供預設初值，例如：

var (
    a bool        
    b int32
    c float32
    d string
    e complex128
)

在上面的宣告中，a、b、c、d、e 的值分別會是 false、0、0.0、"" 與 0 + 0i。在 Go 中，宣告了變數，程式中卻沒有取用的動作，那麼會發生 declared and not used 的編譯錯誤。

自動推斷型態

在 Go 中宣告變數並指定值時，可以不用提供型態，由編譯器自動推斷型態，例如：

var x = 10

上頭的 x 型態會是 int，而底下的宣告：

var x, y, z = 10, 3.14, "Justin"

x、y、z 的型態分別會是 int、float64 與 string，批量宣告時也可以自動推斷型態，例如：

var (
    x = 10        // int 型態
    y = 3.14      // float32 型態
    z = "Justin"  // string 型態
)

短變數宣告

在函式中，想要定義變數值的場合，可以使用短變數宣告，例如：

x := 10
y := 3.14
z := "Justin"

如果 x 是首次定義，就等於是宣告變數並指定值。上例也可以寫成一行：

x, y, z := 10, 3.14, "Justin"

由於 Go 的函式外，每個語法都必須以關鍵字開始，因此短變數宣告不能在函式外使用。

var 宣告的變數名稱不可重複，然而，短變數宣告時，若同一行內有新宣告了另一變數，就可以重複宣告已存在的變數，例如，以下是合法的，因為使用 := 時有一個新的 y 變數：

var x = 10
x, y :=  20, 30

此時，並沒有建立一個新的 x 變數，只是將新值指定給 x 而已。

由於短變數宣告可以同時宣告變數並指定值，因此對於底下這類需求：

package main

import "fmt"

func main() {
    var x = true
    if x {
        fmt.Println(x)
    }
}

在上例，x 的範圍是整個 main，若改為底下，範圍就只會是 if 區塊：

package main

import "fmt"

func main() {
    if x := true; x {
        fmt.Println(x)
    }
}

類似地，for 之類的語法，也常運用短變數宣告。

（在數學上 A := B 的寫法，涵義是藉由 B 來定義 A，例如數學上若已經定義 x 以及 f(x)，x := f(x) 表示用舊的 x 定義新的 x，這反而像是程式語言中的 x = f(x) 指定的概念，當然，數學上的符號與程式語言中的符號是有出入的，Go 在這邊只是借用了 := 來作為另一種變數宣告符號。）

調換變數值

在 Go 中，要調換兩變數的值很簡單，例如底下的程式執行過後，x 會是 20，而 y 會是 10：

var x = 10
var y = 20
x, y = y, x

基本常數宣告

如一開始談到的，在 Go 中寫下的 10、3.14、true、"Justin" 等稱之為常數（Constant），常數宣告可給予這些常數識別名稱，要給予名稱時使用的是 const 關鍵字，例如：

const x = 10

正如〈認識預定義型態〉中談過的，10 會是一個整數常數，不過型態未定，如果要定義一個常數的型態，可以使用 int32()、int64() 之類的函式進行型態轉換，或者是在使用 const 宣告常數名稱時指定型態，例如：

const x int32 = 10

這邊的 10 就是 int32 型態了，注意，這邊的 x 並不是一個變數，而是一個識別名稱罷了，因此，會說 x 常數的型態是 int32，而不能說 x 變數的型態是 int32。

如果有多個常數要宣告，也可以批量宣告，例如：

const (
    x = 10
    y = 3.14
    z = "Justin"
)

再次地，x、y、z 分別是未定型態的整數、浮點數與字串常數（而不是 int、float64、string 這三個 Go 中定義的型態），如果你想要讓他們為已定義型態的整數、浮點數與字串常數，可以在宣告時指定型態：

const (
    x int = 10
    y float32 = 3.14
    z string = "Justin"
)

由於常數並非變數，因此，宣告了常數並不一定要用到，底下的程式不會發生錯誤：

package main

import "fmt"

func main() {
    const (
        x = 10
        y = 3.14
        z = "Justin"
    )

    fmt.Println(x)
    fmt.Println(y)
}

常數運算式

由於常數可以是未定型態，因此一個有趣的地方就是，像 2 + 3.0、15 / 4、15 / 4.0 這樣的常數運算式，該怎麼在編譯時期決定它們的值？答案是根據運算式中的常數運算元是整數、rune（單引號括住的常數）、浮點數或複數來決定，如果運算式中包括了越後面的常數，就會用它來決定。

因此，2 + 3.0 會是未定型態的浮點數 5.0，15 / 4 會是未定型態的整數 3，然而，15 / 4.0，會是浮點數型態的 3.75，在規格書的〈Constant expressions〉中，列出了說明以及一些範例，例如：

const a = 2 + 3.0          // a == 5.0   (untyped floating-point constant)
const b = 15 / 4           // b == 3     (untyped integer constant)
const c = 15 / 4.0         // c == 3.75  (untyped floating-point constant)
const Θ float64 = 3/2      // Θ == 1.0   (type float64, 3/2 is integer division)
const Π float64 = 3/2.     // Π == 1.5   (type float64, 3/2. is float division)
const d = 1 << 3.0         // d == 8     (untyped integer constant)
const e = 1.0 << 3         // e == 8     (untyped integer constant)
const f = int32(1) << 33   // illegal    (constant 8589934592 overflows int32)
const g = float64(2) >> 1  // illegal    (float64(2) is a typed floating-point constant)
const h = "foo" > "bar"    // h == true  (untyped boolean constant)
const j = true             // j == true  (untyped boolean constant)
const k = 'w' + 1          // k == 'x'   (untyped rune constant)
const l = "hi"             // l == "hi"  (untyped string constant)
const m = string(k)        // m == "x"   (type string)
const Σ = 1 - 0.707i       //            (untyped complex constant)
const Δ = Σ + 2.0e-4       //            (untyped complex constant)
const Φ = iota*1i - 1/1i   //            (untyped complex constant)

現在，應該能明白，〈認識預定義型態〉中 math.MaxInt64 若不加上 int64，何以會 overflow 的錯誤了。

附帶一提的是，在 Go 中，模組中定義的名稱若要能在模組外可見，必須是首字大寫，而對於像 math.MaxInt64 這類的公用常數，可以定義在一個 .go 檔案之中，例如 math.MaxInt64，就是定義在一個 const.go 之中。

使用 iota 列舉

如果要需要列舉一些常數時，可以使用 iota，它每遇到一次 const，就會重置為 0，若它在批量常數宣告中使用時，第一次出現時的預設值是 0，每出現一次就遞增 1，例如：

const (
    x = iota   // 0
    y = iota   // 1
    z = iota   // 2
 )

因為 const 批量宣告時，若後面的值沒寫出，會使用前一個值設定，例如：

const (
    x = 1
    y      // 1
    z      // 1
 )

因此，如果是連續的列舉，只要寫一次 iota 就可以了，這表示後續的值，也都使用 iota，結果就是：

const (
    x = iota   // 0
    y          // 1
    z          // 2
 )

其實也可以這麼寫來列舉常數，只是比較麻煩：

const x, y, z = iota, iota, iota