1.布尔类型

var b bool = true。
1）布尔型的值只可以是常量 true 或者 false。
2）两个类型相同的值可以使用相等 == 或者不等 != 运算符来进行比较并获得一个布尔型的值。
3）在格式化输出时，你可以使用 %t 来表示你要输出的值为布尔型。
4）对于布尔值的好的命名能够很好地提升代码的可读性，例如以 is 或者 Is 开头的 isSorted、isFinished、isVisible，使用这样的命名能够在阅读代码的获得阅读正常语句一样的良好体验，例如标准库中的 unicode.IsDigit(ch)

2.数字类型

整数：
int、uint 和 uintptr。

  • int 和 uint 在 32 位操作系统上，它们均使用 32 位（4 个字节），在 64 位操作系统上，它们均使用 64 位（8 个字节）。
  • uintptr 的长度被设定为足够存放一个指针即可。
  • int8（-128 -> 127）
  • int16（-32768 -> 32767）
  • int32（-2,147,483,648 -> 2,147,483,647）
  • int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

无符号整数：

  • uint8（0 -> 255）
  • uint16（0 -> 65,535）
  • uint32（0 -> 4,294,967,295）
  • uint64（0 -> 18,446,744,073,709,551,615）

浮点型（IEEE-754 标准）：

  • float32（+- 1e-45 -> +- 3.4 * 1e38）
  • float64（+- 5 _1e-324 -> 107 _1e308）

int 型是计算最快的一种类型。
整型的零值为 0，浮点型的零值为 0.0。
以通过增加前缀 0 来表示 8 进制数（如：077），增加前缀 0x 来表示 16 进制数（如：0xFF），以及使用 e 来表示 10 的连乘（如： 1e3 = 1000，或者 6.022e23 = 6.022 x 1e23）。
可以使用 a := uint64(0) 来同时完成类型转换和赋值操作，这样 a 的类型就是 uint64。
格式化输出
%d 用于格式化整数（%x 和 %X 用于格式化 16 进制表示的数字）
%g 用于格式化浮点型（%f 输出浮点数，%e 输出科学计数表示法）
%0d 用于规定输出定长的整数，其中开头的数字 0 是必须的fmt.Printf("%3d", num)
%n.mg
数值转换

3.复数

complex64 (32 位实数和虚数)
complex128 (64 位实数和虚数)

4.字符型

严格来说，这并不是 Go 语言的一个类型，字符只是整数的特殊用例。byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII 编码的字符来说，完全没有问题。例如：var ch byte = ‘A’
在 ASCII 码表中，A 的值是 65，而使用 16 进制表示则为 41，所以下面的写法是等效的：
var ch byte = 65 或 var ch byte = '\x41'

带有 ++ 和 — 的只能作为语句，而非表达式，因此 n = i++ 这种写法是无效的，其它像 f(i++) 或者 a[i]=b[i++] 这些可以用于 C、C++ 和 Java 中的写法在 Go 中也是不允许的。
在运算时 溢出 不会产生错误，Go 会简单地将超出位数抛弃。如果你需要范围无限大的整数或者有理数（意味着只被限制于计算机内存），你可以使用标准库中的 big 包，该包提供了类似 big.Int 和 big.Rat 这样的类型

5.位运算

位运算只能用于整数类型的变量，且需当它们拥有等长位模式时。（需要用到时再去查资料学习）

6.运算符优先级

由上至下代表优先级由高到低
优先级 运算符
7 ^ !
6 * / % << >> & &^
5 + - | ^
4 == != < <= >= >
3 <-
2 &&
1 ||

7.类型别名

当你在使用某个类型时，你可以给它起另一个名字，然后你就可以在你的代码中使用新的名字（用于简化名称或解决名称冲突）。
在 type TZ int 中，TZ 就是 int 类型的新名称（用于表示程序中的时区），然后就可以使用 TZ 来操作 int 类型的数据。

8.随机数

rand 包实现了伪随机数的生成.
func New(src Source) Rand
func (r Rand) ExpFloat64() float64
func (r Rand) Float32() float32
func (r Rand) Float64() float64
func (r Rand) Int() int
func (r Rand) Int31() int32
func (r Rand) Int31n(n int32) int32
func (r Rand) Int63() int64
func (r Rand) Int63n(n int64) int64
func (r Rand) Intn(n int) int
func (r Rand) NormFloat64() float64
func (r Rand) Perm(n int) []int
Perm returns, as a slice of n ints, a pseudo-random permutation of the integers in the half-open interval [0,n).
func (r Rand) Read(p []byte) (n int, err error)
Read generates len(p) random bytes and writes them into p. It always returns len(p) and a nil error. Read should not be called concurrently with any other Rand method.
func (r Rand) Seed(seed int64)
Seed uses the provided seed value to initialize the generator to a deterministic state. Seed should not be called concurrently with any other Rand method.
func (r Rand) Shuffle(n int, swap func(i, j int))
Shuffle pseudo-randomizes the order of elements. n is the number of elements. Shuffle panics if n < 0. swap swaps the elements with indexes i and j.
func (r Rand) Uint32() uint32
func (r *Rand) Uint64() uint64

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "time"
  7. )
  9. func main() {
  10.     for i := 0; i < 10; i++ {
  11.         a := rand.Int()
  12.         fmt.Printf("%d ", a)
  13.     }
  15.     fmt.Println("\n-------------")
  17.     for i := 0; i < 5; i++ {
  18.         r := rand.Intn(8)
  19.         fmt.Printf("%d ", r)
  20.     }
  22.     fmt.Println()
  23.     timens := int64(time.Now().Nanosecond())
  24.     fmt.Println(timens)
  25.     rand.Seed(timens)
  26.     for i := 0; i < 10; i++ {
  27.         fmt.Printf("%2.2f / ", 100*rand.Float32())
  28.     }
  30. }