Constants

Go 的常數類型

  • boolean constants ，布林常數。
  • rune constants ，表示字元的常數。
  • integer constants ，整數常數
  • floating-point constants ，浮點數常數
  • complex constants ，複數常數
  • string constants ，字串常數

這些常數都可以用實字（literal）表示，實字又分成下面幾種：

  • rune literal ， Rune 實字

  • integer literal ，整數實字

  • floating-point literal ，浮點數實字

  • imaginary literal ，虛數實字

  • string literal ，字串實字

  • 常數有可能是已定義型態（typed）或是未定型態（untyped），實字常數、 true 、 false 、 iota 都屬於未定型態。

  • 常數運算式裡的運算元都是未定型態時，運算完的結果也會是未定型態。example：

1
2
3
10        // 10, Untyped integer constant.
10 + 20   // 30, Untyped integer constant.
10 / 20   // 0,  Untyped integer constant.
  • 但如果有一個型態是確定的，那運算完的結果也會是確定的，如：
1
2
3
int32(10)           // 10,  type int32
int32(10) + 20      // 30,  type int32
float64(10) / 20    // 0.5, type float64

Boolean constants

  • 布林常數是內建的常數，就只有兩個： true 和 false
1
2
3
4
5
// true and false are the two untyped boolean values.
const (
	true  = 0 == 0 // Untyped bool.
	false = 0 != 0 // Untyped bool.
)

Rune constants

  • Rune 常數使用 Rune 實字（rune literal）來表示，它其實是代表一個 Unicode 的整數。可以使用單引號 ' 括住 Unicode 字元，或是 byte 值來表示，如下面的範例是輸出 a 的三種方法，與輸出 中 的三種方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"
)

func main() {
	fmt.Println(string('a'))
	fmt.Println(string('\141'))
	fmt.Println(string('\x61'))
	fmt.Println(string('中'))
	fmt.Println(string('\u4e2d'))
	fmt.Println(string('\U00004e2d'))
	fmt.Println(string('\n'))
}

string() 函式為強制轉型字串

  • Byte 值的表示方法：

    • 直接給字元 a
    • \ 開頭為八進制，後面必須是 3 個八進位的字元（[0-9]{3}）
    • \x 開頭為十六進制表示，後面必須是 2 個十六進位的字元（[0-9a-f]{2}）

  • Unicode 表示方法：

    • 直接給字元 中
    • \u 開頭，後面必須是 4 個十六進位的字元（[0-9a-f]{4}）
    • \U 開頭，後面必須是 8 個十六進位的字元（[0-9a-f]{8}）
    • 跳脫字元： \ 後面接 a b f n r t v \ ' " 。

Integer constants

  • 數字常數使用數字實字（integer literal）表示。數字實字有三種表示法：
    • 十進位，跟大部分的程式碼一樣，為非 0 開頭的連續數字（[1-9][0-9]+）
    • 八進位， 0 開頭，後面接八進位數字（0[0-9]+）
    • 十六進位， 0 開頭，後面接八進位數字（0[x|X][0-9a-fA-F]+）

Floating-point constants

  • 浮點數常數使用浮點數實字（floating-point literal）表示，浮點數使用的兩種表示法：小數點與科學符號：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
	"fmt"
)

func main() {
	// 10.0
	fmt.Println(10.)
	fmt.Println(10.0)
	fmt.Println(010.0)
	fmt.Println(10.e+0)
	fmt.Println(1E1)

	// 0.1
	fmt.Println(.1e+0)
	fmt.Println(.1E0)
	fmt.Println(.1)

	// 10.1
	fmt.Println(10.1)
	fmt.Println(1.01E1)
}

Complex constants

  • 複數常數為數字實字加虛數實字（imaginary literal）組合而成。
  • 虛數實字的表示法為：
    • 十進位 + 小寫 i ，如 10i
    • 浮點數 + 小寫 i ，如 1E1i
1
2
3
4
5
6
7
8
9
10
11

package main

import (
	"fmt"
)

func main() {
	fmt.Println(10 + 10i)
	fmt.Println(1E1 + 1E1i)
}

String constants

  • 字串常數使用字串實字（string literal）表示。如果是純字串，可以使用 ` 括要表示的字串，如：
1
2
3
4
5
6
7
8
9
package main

import (
	"fmt"
)

func main() {
	fmt.Println(`\n`)
}
  • 這樣就會輸出 \n 兩個字元
  • 如果需要轉譯 rune 常數為字元的話，可以用雙引號 " 括要表示的字串，如：
1
2
3
4
5
6
7
8
9
package main

import (
	"fmt"
)

func main() {
	fmt.Println("這是\u4e2d\u6587")
}
  • 這樣就會輸出 這是中文