项目地址: https://github.com/Zhouchaowen/golang-tutorial 感谢 star

变量与常量

变量和常量简单来说就是给内存中某一个地址起一个名字, 然后用这个地址存储某个特定类型的值。

定义函数变量
定义指针变量

数据类型分类：

布尔类型：bool。
整数类型：int8、uint8、int16、uint16、int32、uint32、int64、uint64、int、uint、 uintptr。
浮点数类型: float32、float64。
复数类型：complex64、complex128。
字符串类型：string。
字符类型：byte。
数组类型：[size]T。
自定义类型：struct。
函数类型：func。
指针持有者类型：[]T(切片)、map[T]T。

数据类型占用大小：

bool
string

uint        either 32 or 64 bits
int         same size as uint
uintptr     an unsigned integer large enough to store the uninterpreted bits of
            a pointer value
uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers
            (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE-754 32-bit floating-point numbers
float64     the set of all IEEE-754 64-bit floating-point numbers

complex64   the set of all complex numbers with float32 real and imaginary parts
complex128  the set of all complex numbers with float64 real and imaginary parts

byte        alias for uint8
rune        alias for int32 (represents a Unicode code point)

在Golang中, 通过var关键字定义变量, 如下格式有多种：

var variableName int            // 定义int类型的变量,初始化为零值
variableName := 1              // 定义int类型的变量,初始化为 1

// 其它方式
var variableName int = 1
var variableName = 1

其中最常用的两种为var variableName T和variableName := Value（简短声明）。变量可以定义在函数外, 当做该package下的全局变量, 也可以定义在函数内当, 做该函数内的局部变量。

package main

import (
    "fmt"
    "unsafe"
)

/*
    通过 var 定义变量
    var variableName T            // 初始化为零值
    var variableName T = Value    // 初始化为Value
    var variableName = Value    // 初始化为Value
    variableName := Value        // 初始化为Value
*/

// var 语句可以声明全局变量
// 全局变量: 函数外声明的变量,全局变量作用域可以在当前的整个包甚至外部包(被导出后)使用
var aa int64

// 可以在 var() 中定义多个全局变量
var (
    bb int8
    cc int16
    dd bool
    ee string
)

func Steps1() {
    // var 语句用于声明一个变量列表,默认值为对应类型零值,
    // 并且声明变量后不使用该变量的话将会抛出错误(该规则适用于函数内定义的变量)

    // 如下 var a int 定义了一个 int 类型的局部变量 a (局部变量：函数内声明的变量,作用域只在函数体内),
    // 这意味着 a 只能在 main 函数内使用（函数的参数和返回值也是局部变量）

    var a int         // 整型 uint8,int8,uint16,int16,uint32,int32,uint64,int64,uintptr
    var b float32     // 浮点型 float64
    var c bool        // 布尔型
    var d string      // 字符串
    var e byte        // 等同于 uint8
    var f rune        // 等同于 int32,表示一个 Unicode 码点
    var g interface{} // 接口型 类似于java中的Object 可以存储任意类型的值

    // 多变量声明 通过 , 隔开
    var h, i string

    // 没有明确初始值的变量声明编译时会被赋予 零值
    // 不同类型的零值:
    //    数值类型为   0
    //    布尔类型为   false
    //    字符串类型为 ""（空字符串）
    //       接口类型为   nil

    // 打印对应零值
    fmt.Println("\tint zero value: ", a)
    fmt.Println("\tint64 zero value: ", aa)
    fmt.Println("\tfloat32 zero value: ", b)
    fmt.Println("\tbool zero value: ", c)
    fmt.Println("\tstring zero value: ", d)
    fmt.Println("\tbyte zero value: ", e)
    fmt.Println("\trune zero value: ", f)
    fmt.Println("\tinterface zero value: ", g)

    fmt.Println("\tstring zero value: ", h)
    fmt.Println("\tstring zero value: ", i)
}

func main() {
    fmt.Println("Steps1():")
    Steps1()
}

在Golang中通过 = 对变量进行赋值, = 可以在变量初始化时赋值也可以在变量定义后赋值。还可以通过上文提到的简洁赋值 :=, := 表示定义变量并赋值, 可以替代Var。

需要注意的是，如果您在定义变量时不指定类型，Go编译器会自动推断其类型, 如下var b = 2会自动推导b为int型。

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

// var 语句声明全局变量并赋值
var aa int64 = 3

// Steps1 声明变量并赋值
func Steps1() {
    // 声明局部变量并赋初始值
    var a int = 1

    // 如果初始化值已存在,则可以省略类型,Go编译器会自动推导类型
    var b = 2       // 自动推导为int型
    var c = 3.2     // 自动推导为float64型
    var d = "hello" // 自动推导为string型

    // 在函数中,简洁赋值语句 := 可在类型明确的地方代替 var 声明,但 := 结构不能在函数外使用,也就是说不能用于声明全局变量
    e := true

    var f byte = 'a'
    var g rune = '\u72d7' // \u72d7 = 狗

    var h interface{} = "golang"
    var i interface{} = true
    var j, k = 1, "Golang Tutorial" // 多变量声明并赋值

    // 打印变量的 value, 通过 reflect.TypeOf 函数获取变量对应类型
    fmt.Printf("\ta value:%d  a type:%s\n", a, reflect.TypeOf(a))
    fmt.Printf("\taa value:%d  aa type:%s\n", aa, reflect.TypeOf(aa))
    fmt.Printf("\tb value:%d  b type:%s\n", b, reflect.TypeOf(b))
    fmt.Printf("\tc value:%f  c type:%s\n", c, reflect.TypeOf(c))
    fmt.Printf("\td value:%s  d type:%s\n", d, reflect.TypeOf(d))
    fmt.Printf("\te value:%t  e type:%s\n", e, reflect.TypeOf(e))
    fmt.Printf("\tf value:%c  f type:%s\n", f, reflect.TypeOf(f))
    fmt.Printf("\tg value:%c  g type:%s\n", g, reflect.TypeOf(g))
    fmt.Printf("\th value:%s  h type:%s\n", h, reflect.TypeOf(h))
    fmt.Printf("\ti value:%t  i type:%s\n", i, reflect.TypeOf(i))
    fmt.Printf("\tj value:%d  j type:%s\n", j, reflect.TypeOf(j))
    fmt.Printf("\tk value:%s  k type:%s\n", k, reflect.TypeOf(k))
}

func main() {
    fmt.Println("Steps1():")
    Steps1()    
}

如上代码中描述了不同类型的声明方式，其中的interface类型可以存储任意类型的值，具体原因是在 Go 的 runtime 中，interface 是用两个指针来实现的(eface)。其中一个指针指向实际类型信息的指针(_ytpe)，另一个指针指向实际存储数据的指针(data)。

// interface{} 运行时的结构
type eface struct {
    _type *_type
    data  unsafe.Pointer
}

1-1.package

具体来说，当一个接口变量被赋值时，Go 会在运行时分配一个包含两个指针的结构体(eface)，其中第一个指针指向一个表示实际类型的指针(Type Prt)，第二个指针指向实际存储值的指针(Data Prt)。需要注意的是，这里的类型指的是动态类型，即变量的实际类型而非声明时的类型。

var i interface{} = true
fmt.Printf("i value:%t  i type:%s\n", i, reflect.TypeOf(i))
// i value:true  i type:bool

i = "tutorial"
fmt.Printf("i value:%s  i type:%s\n", i, reflect.TypeOf(i))
// i value:tutorial  i type:string

这段代码中，定义了一个空接口变量 i，并先后将其赋值为 true 和 "tutorial"。由于 i 是一个空接口变量，它可以容纳任何类型的值。在这种情况下，i 的类型会根据所赋的值进行自动推导。

在第一个赋值代码中，i 被赋值为 true，因此 i 的类型被推导为 bool 类型。在第二个赋值代码中，i 被赋值为 "tutorial"，因此 i 的类型被推导为 string 类型。

在 fmt.Printf() 函数中，使用了格式化打印 i 的值和类型。因此，在第一次打印时，i 的值为 true，类型为 bool；赋值为tutorial后再打印，i 的值为 "tutorial"，类型为 string。

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

// Steps3 interface被动态赋值
func Steps3() {
    var i interface{} = true
    fmt.Printf("\ti value:%t  i type:%s\n", i, reflect.TypeOf(i))

    // i 被重新赋值, 类型转换为string
    i = "tutorial"
    fmt.Printf("\ti value:%s  i type:%s\n", i, reflect.TypeOf(i))
}

// Steps4 证明interface底层是由type和data组成
func Steps4() {
    /*
        interface底层由两部分组成  _type ptr, data ptr
        type eface struct {
            _type *_type
            data  unsafe.Pointer
        }
    */

    var i interface{} = true
    fmt.Printf("\ti value:%t  i type:%s\n", i, reflect.TypeOf(i))

    fmt.Printf("\ti size:%d\n", unsafe.Sizeof(i))
    fmt.Printf("\ti addr:%p\n", &i)
    fmt.Printf("\ti type pointer value 0x%x\n", *(*uintptr)(unsafe.Pointer(&i)))
    fmt.Printf("\ti data pointer value 0x%x\n", *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&i)) + uintptr(8))))
    fmt.Printf("\ti data pointer *value %t\n", *(*bool)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&i)) + uintptr(8))))))

    fmt.Printf("\t---------------------------\n")
    // i 被重新赋值, 类型转换为string
    i = "tutorial"
    fmt.Printf("\ti value:%s  i type:%s\n", i, reflect.TypeOf(i))

    fmt.Printf("\ti size:%d\n", unsafe.Sizeof(i))
    fmt.Printf("\ti addr:%p\n", &i)
    fmt.Printf("\ti type pointer value 0x%x\n", *(*uintptr)(unsafe.Pointer(&i)))
    fmt.Printf("\ti data pointer value 0x%x\n", *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&i)) + uintptr(8))))
    fmt.Printf("\ti data pointer *value %s\n", *(*string)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&i)) + uintptr(8))))))

    // 等同如上
    type eface struct {
        _type *struct{} // *_type
        data  unsafe.Pointer
    }
    s := *(*eface)(unsafe.Pointer(&i))
    fmt.Printf("\ti %+v\n", s)
    fmt.Printf("\ti._type: %+v\n", s._type)
    fmt.Printf("\ti.data:  %+v\n", *(*string)(s.data))
}

func main() {
    fmt.Println("Steps3():")
    Steps3()
    fmt.Println("Steps4():")
    Steps4()
}

在Golang中可以将相近类型的数据进行强转, 格式为variableName2 := T(variableName1)。需要注意的是，不是所有类型之间都可以进行转换。例如，您不能将一个字符串转换为一个整数或浮点型等。

b := float64(a)
var b float64 = float64(a)

当进行类型转换时，必须确保类型转换是安全的，如果转换失败，则会引发一个运行时错误导致程序崩溃。

package main

import (
    "fmt"
    "reflect"
)

/*
    类型转换
    var variableName2 T = T(variableName1)
    variableName2 := T(variableName1)
*/

func Steps1() {
    var a int = 1

    // 表达式 T(v) 将值 v 转换为类型 T

    // 如下将 int 类型的值转换为 float64 类型的值, float64(a) 将值 a 转换为 float64 类型并赋值给 b
    var b float64 = float64(a)

    // 简洁形式 uint(b) 将值 b 转换为 uint 类型并赋值给 c
    c := uint(b)

    fmt.Printf("\ta value:%d  a type:%s\n", a, reflect.TypeOf(a))
    fmt.Printf("\tb value:%f  b type:%s\n", b, reflect.TypeOf(b))
    fmt.Printf("\tc value:%d  c type:%s\n", c, reflect.TypeOf(c))

    //var d = bool(c) // panic 不能将 c (uint 类型的变量)转换为 bool 类型
}

func main() {
    fmt.Println("Steps1():")
    Steps1()
}

另外，由于类型转换可能导致精度损失或溢出，因此在进行类型转换时应特别小心。

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

func Steps2() {
    d := uint8(255) // 将常量值 255 转换为 uint8 类型并赋值给 d
    fmt.Printf("d value:%d  d type:%s\n", d, reflect.TypeOf(d))

    // 注意：类型转换不能超过转换类型的范围
    //e := uint8(256) // 编译错误, 常量256超出了uint8最大存储限制, 不能转换

    // 转换时,超过转换的类型范围时将导致数据溢出
    var f uint16 = 256
    g := uint8(f) // uint8最大为255, 溢出后从0开始, 所以g等于0
    ff := f + 1
    h := uint8(ff) // 如上可知h等于1

    // uint16   uint8
    // 2 byte   1 byte
    // 16 bit   8 bit

    // 00000001 00000000    f
    //          00000000    g
    // 00000001 00000001    ff
    //          00000001    h

    fmt.Printf("\tf  sizeof:%dbyte  binary value:%016b f  value:%d   f type:%s\n", unsafe.Sizeof(f), f, f, reflect.TypeOf(f))
    fmt.Printf("\tg  sizeof:%dbyte  binary value:%016b g  value:%d     g type:%s\n", unsafe.Sizeof(g), g, g, reflect.TypeOf(g))
    fmt.Printf("\tff sizeof:%dbyte  binary value:%016b ff value:%d  ff type:%s\n", unsafe.Sizeof(ff), ff, ff, reflect.TypeOf(ff))
    fmt.Printf("\th  sizeof:%dbyte  binary value:%016b h  value:%d     h type:%s\n", unsafe.Sizeof(h), h, h, reflect.TypeOf(h))
}

func main() {
    fmt.Println("Steps2():")
    Steps2()
}

如上代码中展示了类型转换时的溢出问题，代码片段如下：

// 转换时, 超过转换的类型范围时将导致数据溢出
var f uint16 = 256
g := uint8(f) // uint8最大为255, 溢出后从0开始, 所以g等于0
ff := f + 1
h := uint8(ff) // 如上可知h等于1


 1111 1111    255 2^7
10000 0000 +1 256 2^8
10000 0001 +2 257 2^8+2^0

其中uint16类型的f转换为uint8类型的g,由于f存储的值为256超过uint8最大可存储值，导致数据溢出。转换时会从uint16起始位置截取uint8占用的位数(8位), 然后赋值给g, 如下图展示：

uint16类型的ff转换为uint8类型的h，如下图展示：

不同类型进行计算时需要转换为相同类型，注意精度丢失：

package main

import (
    "fmt"
    "reflect"
)

func Steps3() {
    j := 10    // 自动推导为int型
    l := 100.1 // 自动推导为float64型

    // 在Go中不同类型的数据不能直接计算，需进行类型转换
    p := float64(j) * l

    fmt.Printf("\t p value:%.2f  p type:%s\n", p, reflect.TypeOf(p))

    pp := j * int(l)
    fmt.Printf("\tpp value:%d     p type:%s\n", pp, reflect.TypeOf(pp))
}

func main() {
    fmt.Println("Steps3():")
    Steps3()
}

注意：如果要在类型之间进行转换，但不确定是否能够安全地进行转换，可以使用类型断言。类型断言可以判断一个接口类型(interface{})的值是否属于指定类型。如果是，则返回转换后的值，否则返回一个错误。（该知识点将在Interface{}章节讲解）

在Golang中通过const定义常量, 格式为const constantName = value或const constantName T = value, 其中 constantName 表示常量的名称，T 表示常量的类型（可以省略，省略后类型会根据值自动推导），value 表示常量的值。

const constantName = valueA
const constantName T = value

常量可以定义在函数外当做该包下的全局常量, 也可以定义在函数内当做该函数内的局部常量。注意：常量定义的时候必须赋值，定义后值不能被修改。

package main

import (
    "fmt"
    "math"
    "reflect"
)

/*
    1.声明局部常量
    2.声明全局变量
    3.iota赋值
*/

/*
    const NameOfVariable [type] = value  type 可以省略让编译器推导
    const constantName = value
    const constantName T = value
*/

// 常量定义的时候必须赋值，定义后值不能被修改

const PI = 3.14
const NAME = "Golang-tutorial"
const OK bool = true

// 可以通过 const() 定义多个常量
const (
    MaxUint8  = math.MaxUint8
    MaxUint16 = math.MaxUint16
)

// iota 定义常量, iota的值是const语句块里的行索引,行索引从0开始
const (
    One   = iota // 第一行 One值等于 0
    Two          // 第二行 Two值等于 1
    Three        // 第三行 Three值等于 2
)

func main() {
    // 函数内也可以定义常量(局部常量)
    const World = "World"
    fmt.Println("Hello", World)

    fmt.Printf("MaxUint8 value:%d  MaxUint8 type:%s\n", MaxUint8, reflect.TypeOf(MaxUint8))
    fmt.Printf("MaxUint16 value:%d  MaxUint16 type:%s\n", MaxUint16, reflect.TypeOf(MaxUint16))

    fmt.Printf("One value:%d  One type:%s\n", One, reflect.TypeOf(One))
    fmt.Printf("Two value:%d  Two type:%s\n", Two, reflect.TypeOf(Two))
    fmt.Printf("Three value:%d  Three type:%s\n", Three, reflect.TypeOf(Three))

    //MaxUint8 = math.MaxUint32 // 修改常量值将会报错
}

在上面的示例中，我们声明了三个常量：PI, NAME 和 OK。PI 的类型为 float64，其值为 3.14, NAME 的类型为 string，其值为 "Golang-tutorial", OK的类型为 bool, 其值为 true。

定义函数变量

在Golang中，函数可以像普通类型一样被声明和使用。这意味着可以将一个函数赋值给一个变量, 也可以将一个函数作为另一个函数的参数或返回值。(函数定义将在下一章讲解)

// 将一个匿名函数赋值给变量 printConsole
var printConsole = func(){
  fmt.Println("golang tutorial")
}

// 将一个带参数的匿名函数赋值给变量 add
var add = func(x, y int) int {
  return x + y
}

// 将一个带参数的匿名函数当做参数
func compute(x, y int, handler func(x, y int) int) int {}

// 将一个匿名函数当做返回值
func genNum() func() int {}

使用实例：

package main

import (
    "fmt"
    "math/rand"
)

/*
    定义函数变量
    var variableName = func
*/

// compute有名函数接收2个int型参数和一个匿名函数(该匿名函数接收2个int类型参数返回一个int类型值)
func compute(x, y int, handler func(x, y int) int) int {
    x = x * 10
    y = y * 10
    result := handler(x, y) // 调用匿名函数 handler
    return result
    //return handler(x, y) //可以直接这样调用
}

func genNum() func() int {
    return func() int {
        return rand.Intn(999999)
    }
}

// 函数也可以当做类型,可以像其它值一样传递
func main() {
    var printConsole = func() {
        fmt.Println("golang tutorial")
    }
    printConsole()

    // 1 将一个匿名函数赋值给变量 add
    var add = func(x, y int) int {
        return x + y
    }
    result := add(1, 2) // 调用函数变量
    fmt.Println("add result", result)

    // 2
    Multi := func(x, y int) int {
        return x * y
    }
    result = compute(1, 2, Multi) // 调用函数compute并传递2个int参数和函数变量参数Multi
    fmt.Println("Multi result", result)

    num := genNum()
    fmt.Println("genNum result", num())
    fmt.Println("genNum result", num())
    fmt.Println("genNum result", num())
}

/*
func(x, y int) int {
        return x + y
} // 被叫做匿名函数，下一小节介绍。
*/

在上面的示例中第1部分，我们声明了一个名为 add 的函数变量，它接受两个整数作为参数并返回它们的和。然后调用 add 变量，将其作为一个普通的函数来计算 1 和 2 的和，最后将结果输出到控制台上。

在上面的示例中第2部分，我们定义了一个函数变量Multi，它接受两个整数作为参数并返回它们的乘积。然后，我们定义了一个函数 compute，它接受两个整数，以及一个函数作为参数。compute 函数将传入的两个整数参数+10后作为参数传递给handler。最后，我们在 main 函数调用 compute 函数，将两个整数和 Multi函数作为参数传递给它，然后将结果输出到控制台上。

定义指针变量

在Golang中通过var定义指针变量, 格式有多种选择常用的三种

var variableName *T 定义一个指针变量, 默认值为nil。
variableName := &Value 通过简单语句定义一个指针变量并赋默认值(&Value代表取Value值的地址)。
variableName := new(T) 通过内置函数new()初始化指针变量，会默认分配一个地址,并存储对应类型的零值。

指针变量还可以与 nil 进行比较，以检查它们是否指向了某个地址。如果一个指针变量为 nil，则表示它没有指向地址。

package main

import "fmt"

/*
    通过 var 定义指针变量
    var variableName *T
    var variableName *T = &Value
    var variableName = &Value
    variableName := &Value
*/

// Steps1 定义指针变量
func Steps1() {
    // 定义一个 int 类型的指针变量, 默认值零值为nil
    var a *int     // uint8,int8,uint16,int16,uint32,int32,uint64,int64,uintptr
    var b *float32 // float64
    var c *bool
    var d *string // 定义一个 string 的指针类型
    var e *byte   // 定义一个 byte 的指针类型
    var f *rune
    var g *interface{}

    fmt.Println("\t*int zero value: ", a)
    fmt.Println("\t*float32 zero value: ", b)
    fmt.Println("\t*bool zero value: ", c)
    fmt.Println("\t*string zero value: ", d)
    fmt.Println("\t*byte zero value: ", e)
    fmt.Println("\t*rune zero value: ", f)
    fmt.Println("\t*rune zero value: ", g)
}

func main() {
    fmt.Println("Steps1():")
    Steps1()
}

指针变量的赋值

在 Golang 中可以通过取地址符 & 来获取一个变量的内存地址，并将其赋值给指针变量

package main

import "fmt"

// 注释 ①
var b = 100

// Steps2 指针变量赋值与取值
func Steps2() {
    // 定义了一个指针变量 a, 指针变量只能存储地址
    var a *int

    fmt.Println("\ta value:", a) // 打印 a 变量存储的地址值
    fmt.Println("\ta addr:", &a) // 打印 a 变量自己的地址值

    // 取空指针变量存储地址上的值会导致 panic: runtime error: invalid memory address or nil pointer dereference
    //fmt.Println("a value:", *a) // *a 代表取出 a 变量存储的地址, 并获取该地址上存储的值

    fmt.Println("\tb value:", b)  // 打印 b 的值
    fmt.Println("\tb addr :", &b) // 打印 b 的地址

    // 注释 ② & 表示取 b 变量的地址并赋值给 a, 改动 a 就相当于改动 b
    a = &b
    fmt.Println("\ta value:", a)             // 打印 a 变量存储的地址值
    fmt.Println("\ta value over value:", *a) // *a 代表取出 a 变量存储的地址, 并获取该地址上存储的值

    *a = 2                       // *a 取出 a 变量存储的地址，并修该地址上存储的值(赋值为 2)
    fmt.Println("\ta value:", a) // 打印 a 存储的地址值
    fmt.Println("\ta value over value:", *a)
    fmt.Println("\tb value:", b) // 打印 b 的值

    c := &a
    // Go指针不支持算术运算, 下面这两行编译不通过。
    // c++
    // c = (&a) + 8
    _ = c

    // Go指针不支持算术运算, 可以通过 unsafe.Pointer 打破这个限制
}

func main() {
    fmt.Println("Steps2():")
    Steps2()
}

在上面的代码中，注释① 我们定义了一个整数变量 b，并将其初始化为 100。注释② 我们使用取地址符 & 来获取变量 b 的内存地址，并将其赋值给指针变量 a。现在，指针变量 a 指向了变量 b 的内存地址，打印a变量存储的地址和地址上的具体值。

*a 代表取出a变量存储的地址, 并获取该地址上存储的值

需要注意的是，指针变量只能指向相同类型的变量。例如，如果我们定义了一个整数类型的指针变量，那么它只能指向整数类型的变量，而不能指向字符串、浮点数或其他类型的变量。

通过内置函数new创建指针

使用 new 函数创建的指针变量默认值是零值，也就是说它们的值为 0、false、空字符或者空指针，具体取决于变量类型。

package main

import "fmt"

// Steps3 内置函数 new 创建指针
func Steps3() {
    // 通过内置函数 new 创建一个 int 的指针类型
    a := new(int)
    var b *int
    fmt.Println("\tnew(int) value: ", a)
    fmt.Println("\tnew(int) value over value: ", *a) // 值为 0
    fmt.Println("\t*int value: ", b)

    c := new(string)
    var d *string
    fmt.Println("\tnew(string) value: ", c)
    fmt.Println("\tnew(string) value over value: ", *c) // 值为 ""
    fmt.Println("\t*string value: ", d)
}

func main() {
    fmt.Println("Steps3():")
    Steps3()
}

空指针nil

在 Go 中，空指针非常有用，可以用于判断一个指针变量是否已经分配了内存空间。

package main

import "fmt"

// Steps4 判断指针是否为nil
func Steps4() {
    var ptr *int // 指向nil
    if ptr == nil {
        fmt.Println("\tptr is nil")
    }

    var a int = 42
    var ptr2 *int = &a // 指向a的地址内存空间
    if ptr2 != nil {
        fmt.Println("\tptr2 is not nil")
    }
}

func main() {
    fmt.Println("Steps4():")
    Steps4()
}

在上面的代码中，我们首先定义了一个指针变量 ptr，并检查它是否为 nil。由于它没有指向任何变量(地址)，因此应该输出 "ptr is nil"。然后，我们定义了一个整数变量 a，并使用 &a 获取它的内存地址，并将其赋值给指针变量 ptr2。由于 ptr2 指向了变量 a，因此应该输出 "ptr2 is not nil"。

需要注意的是，使用指针变量可能会产生空指针异常。如果我们在访问指针变量所指向的变量之前没有检查指针变量是否为 nil，则可能会出现空指针异常，导致程序崩溃。因此，在使用指针变量之前，应该先检查它是否为 nil，以避免出现空指针异常。

Golang中常用占位符为%d、%f、%s、%T、%+v

package main

import (
   "fmt"
)

// 占位符
func main() {
   var a byte = 255            // byte = uint8 rune = int32
   fmt.Printf("%v:%T\n", a, a) // 255:uint8

   var b int = 380
   // 不足位数前面补0
   fmt.Printf("%05d:%T\n", b, b)  // 00380:int
   fmt.Printf("%010d:%T\n", b, b) // 0000000380:int

   var c int = 88
   // 十进制 -> 二进制
   fmt.Printf("%b:%T\n", c, c) // 1011000:int
   // 十进制 -> 十六进制
   fmt.Printf("%x:%T\n", c, c) // 58:int

   var d string = "Golang"
   fmt.Printf("%s:%T\n", d, d) // Golang:string

   var e float64 = 3.14
   fmt.Printf("%f:%T\n", e, e) // 3.140000:float64
}

/*
[常用]
   %d    十进制表示
   %s    字符串或切片的无解译字节
   %f    有小数点而无指数，例如 123.456

   %v    相应值的默认格式。在打印结构体时，“加号”标记（%+v）会添加字段名
   %#v    相应值的 Go 语法表示
   %T    相应值的类型的 Go 语法表示
   %%    字面上的百分号，并非值的占位符

[布尔]

　　%t    单词 true 或 false。

[整数]

　　%b    二进制表示
　　%c    相应 Unicode 码点所表示的字符
　　%d    十进制表示
　　%o    八进制表示
　　%q    单引号围绕的字符字面值，由 Go 语法安全地转义
　　%x    十六进制表示，字母形式为小写 a-f
　　%X    十六进制表示，字母形式为大写 A-F
　　%U    Unicode 格式：U+1234，等同于 "U+%04X"

[浮点数及其复合构成]

　　%b    无小数部分的，指数为二的幂的科学计数法，与 strconv.FormatFloat 的 'b' 转换格式一致。例如 -123456p-78
　　%e    科学计数法，例如 -1234.456e+78
　　%E    科学计数法，例如 -1234.456E+78
　　%f    有小数点而无指数，例如 123.456
　　%g    根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的 0）输出
　　%G    根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的 0）输出

[字符串与字节切片]

　　%s    字符串或切片的无解译字节
　　%q    双引号围绕的字符串，由 Go 语法安全地转义
　　%x    十六进制，小写字母，每字节两个字符
　　%X    十六进制，大写字母，每字节两个字符

[指针]

　　%p    十六进制表示，前缀 0x

[其它标记]

　　+    总打印数值的正负号；对于 %q（%+q）保证只输出 ASCII 编码的字符。
　　-    在右侧而非左侧填充空格（左对齐该区域）
　　#    备用格式：为八进制添加前导 0（%#o），为十六进制添加前导 0x（%#x）或
　　0X（%#X），为 %p（%#p）去掉前导 0x；如果可能的话，%q（%#q）会打印原始（即反引号围绕的）字符串；如果是可打印字符，%U（%#U）会写出该字符的 Unicode 编码形式（如字符 x 会被打印成 U+0078 'x'）。
　　' '    （空格）为数值中省略的正负号留出空白（% d）；
         以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开：fmt.Printf("% x\n", "Hello")
// 参考 http://www.manongjc.com/detail/25-pmahqixdhaombky.html
*/

Go 语言中支持的运算符包括以下几种：

算术运算符：用于执行基本的算术操作，包括加减乘除和取余数。

+：加法
-：减法
*：乘法
/：除法
%：取余数

package main

import "fmt"

func Steps1() {
    x := 10
    y := 3
    a := x + y                 // 13
    fmt.Printf("\t%d \n", a)
    a = x - y                 // 7
    fmt.Printf("\t%d \n", a)
    a = x * y                 // 30
    fmt.Printf("\t%d \n", a)
    a = x / y                 // 3
    fmt.Printf("\t%d \n", a)
    a = x % y                 // 1
    fmt.Printf("\t%d \n", a)
}

func main() {
    fmt.Println("Steps1():")
    Steps1()
}

关系运算符：用于比较两个值之间的关系，返回一个布尔值（true 或 false）。

==：等于
!=：不等于
<：小于
>：大于
<=：小于等于
>=：大于等于

package main

import "fmt"

func Steps2() {
    x := 10
    y := 3
    b := x == y         // false
    fmt.Printf("\t%t \n", b)
    b = x != y             // true
    fmt.Printf("\t%t \n", b)
    b = x < y             // false
    fmt.Printf("\t%t \n", b)
    b = x > y             // true
    fmt.Printf("\t%t \n", b)
    b = x <= y             // false
    fmt.Printf("\t%t \n", b)
    b = x >= y             // true
    fmt.Printf("\t%t \n", b)
}

func main() {
    fmt.Println("Steps2():")
    Steps2()
}

逻辑运算符：用于执行布尔逻辑运算，返回一个布尔值（true 或 false）。
- &&：逻辑 AND
- ||：逻辑 OR
- !：逻辑 NOT

   package main

   import "fmt"

   func Steps3() {
       x := true
       y := false
       c := x && y         // false
       fmt.Printf("\t%t \n", c)
       c = x || y             // true
       fmt.Printf("\t%t \n", c)
       c = !x                     // false
       fmt.Printf("\t%t \n", c)
   }


   func main() {
       fmt.Println("Steps3():")
       Steps3()
   }

位运算符：用于对整数类型的值执行按位运算，返回一个整数类型的值。

&：按位 AND
|：按位 OR
^：按位 XOR
<<：左移
>>：右移

package main

import "fmt"

func Steps4() {
    x := 0b1010             // 十进制数 10
    fmt.Printf("\t%05b %d\n", x, x)
    y := 0b0011             // 十进制数 3
    fmt.Printf("\t%05b %d\n", y, y)
    d := x & y                 // 0b0010，十进制数 2
    fmt.Printf("\t%05b %d\n", d, d)
    d = x | y                 // 0b1011，十进制数 11
    fmt.Printf("\t%05b %d\n", d, d)
    d = x ^ y                 // 0b1001，十进制数 9
    fmt.Printf("\t%05b %d\n", d, d)
    d = x << 1                 // 0b10100，十进制数 20
    fmt.Printf("\t%05b %d\n", d, d)
    d = x >> 1                 // 0b0101，十进制数 5
    fmt.Printf("\t%05b %d\n", d, d)
}

func main() {
    fmt.Println("Steps4():")
    Steps4()
}

赋值运算符：用于给变量赋值。

=：简单的赋值
+=：加并赋值
-=：减并赋值
*=：乘并赋值
/=：除并赋值
%=：取余并赋值
&=：按位 AND 并赋值
|=：按位 OR 并赋值
^=：按位 XOR 并赋值
<<=：左移并赋值
>>=：右移并赋值

package main

import "fmt"

func Steps5() {
    x := 10
    x += 5                 // x = 15
    fmt.Printf("\t%d \n", x)
    x -= 3                 // x = 12
    fmt.Printf("\t%d \n", x)
    x *= 2                 // x = 24
    fmt.Printf("\t%d \n", x)
    x /= 3                 // x = 8
    fmt.Printf("\t%d \n", x)
    x %= 5                 // x = 3
    fmt.Printf("\t%d \n", x)
    x &= 0b101         // x = 00001，十进制数 1
    fmt.Printf("\t%05b %d\n", x, x)
    x |= 0b110         // x = 00111，十进制数 7
    fmt.Printf("\t%05b %d\n", x, x)
    x ^= 0b011         // x = 00100，十进制数 4
    fmt.Printf("\t%05b %d\n", x, x)
    x <<= 1             // x = 01000，十进制数 8
    fmt.Printf("\t%05b %d\n", x, x)
    x >>= 2             // x = 00010，十进制数 2
    fmt.Printf("\t%05b %d\n", x, x)
}

func main() {
    fmt.Println("Steps5():")
    Steps5()
}

其他运算符：包括取地址运算符、取值运算符、指针运算符等。

&：取地址运算符

x := 10
p := &x     // 取 x 的地址，并赋值给指针变量 p

*：取值运算符、指针运算符

x := 10
var p *int  // 声明一个指向整数类型的指针变量 p
p = &x      // 将 x 的地址赋值给 p
*p = 20     // 通过指针 p 修改 x 的值，即 x = 20

<-：通道接收运算符 (后面章节讲解)

ch := make(chan int, 10) // 创建一个缓冲大小为 10 的 int 类型的通道 ch
ch <- 10                 // 向通道 ch 写入数据 10
x := <-ch                // 从通道 ch 读取数据并赋值给 x
close(ch)                // 关闭通道 ch