Go 语言快速入门

$ go version
go version go1.15.6 darwin/amd64

$ go env GOROOT
/usr/local/go
$ go env GOPATH
/Users/username/go

$ export GOROOT=/usr/local/go
$ export GOPATH=/Users/username/go

$ go env GOOS
windows
$ go env GOARCH
amd64

$ go tool dist list

$ export GOOS=windows GOARCH=amd64
$ go build hello.go

$ export GOOS= GOARCH=

$ go help build
- a
    force rebuilding of packages that are already up-to-date.
- n
    print the commands but do not run them.
...

$ go build -x hello.go
WORK=/var/folders/28/1z5z1j7d7zq7z1z7z1z7z1z7z1z7z1z/T/go-build1234567890
mkdir -p $WORK/b001/
cat >$WORK/b001/_gomod_.go << 'EOF' ## internal
packagefile command-line-arguments=/Users/username/Libraries/Caches/go-build/12/34567890abcdefg
packagefile fmt=/usr/local/go/src/fmt.a
packagefile runtime=/usr/local/go/src/runtime.a
...
...
...
packagefile runtime=/usr/local/go/src/path.a
modinfo "0w\xaf\x1f\x.."
EOF
mkdir -p $WORK/b001/exe/
cd .
/usr/local/go/pkg/tool/darwin_amd64/compile -o $WORK/b001/exe/hello -trimpath $WORK -p main -complete -buildid 1234567890abcdefg -D _/Users/username/Libraries/Caches/go-build -I $WORK/b001 -pack ./hello.go
/usr/local/go/pkg/tool/darwin_amd64/link -o $WORK/b001/exe/a.out -L $WORK/b001 -extld=clang -buildmode=exe -buildid=1234567890abcdefg $WORK/b001/exe/hello
mv $WORK/b001/exe/a.out hello

$ mkdir hello
$ cd hello
$ go mod init hello
go: creating new go.mod: module hello

module hello
 
go 1.15

package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, World!")
}

$ go run hello.go
Hello, World!

$ go build
$ ./hello
Hello, World!

// 这是单行注释
 
/*
这是多行注释
*/

package main
 
import "fmt"
 
func main() {
    a := `"hello
    world"`
    fmt.Println(a)
}

"hello
    world"

package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    for i, arg := range os.Args {
        fmt.Printf("arg[%d]: %s\n", i, arg)
    }
}

arg[0]: /var/folders/28/1z5z1j7d7zq7z1z7z1z7z1z7z1z7z1z/T/go-build1234567890/b001/exe/main
arg[1]: hello
arg[2]: world

package main
 
import (
    "flag"
    "fmt"
)
 
func main() {
    var name = flag.String("name", "everyone", "The greeting object.") // 参数名，默认值，参数说明
    flag.Parse()  // 解析参数
    fmt.Println("Hello, ", *name) // *name 表示获取 name 的值, 如果直接使用 name 会输出指针地址
}

Hello, world

var 变量名 变量类型

var a int
var b string
var c bool
a = 1
b = "hello"
c = true
var d int = 2
// Go 具有类型推导，可以不指定类型
var d = 2 // int
var e string = "world"
var f bool = false
// 类型推导
var g = 3 // int
// 简短声明
h:= 4 // int
// 避免对已声明的变量进行重复声明
h:= 5 // 报错

fmt.Print("a=%v, b=%v, c=%v\n", a, b, c)
fmt.Print("d=%v, e=%v, f=%v\n", d, e, f)
fmt.Print("g=%v, h=%v\n", g, h)

var a, b, c int
a, b, c = 1, 2, 3
var d, e, f int = 4, 5, 6
var g, h, i = 7, 8, 9
j, k, l := 10, 11, 12

var (
    a int = 1
    b string = "hello"
    c bool = true
)

const 常量名 常量类型 = 常量值

const a int = 1
const b string = "hello"
const c bool = true

const (
    a int = 1
    b string = "hello"
    c bool = true
)

const (
    a = iota  // 0
    b // 1
    c // 2
)

const (
    a = iota  // 0
    b // 1
    c = 100 // 100
    d = iota // 3
    e // 4
)

const (
    a = iota  // 0
    b // 1
    c = 100 // 100
    d // 100， 未显式赋值，将使用最近的赋值
    e = 200 // 200
    f // 200
)

cosnt {
    INIT = iota
    START
    STOP
    PAUSE
    FINISH
}

const (
    MONDAY = iota
    TUESDAY
    WEDNESDAY
    THURSDAY
    FRIDAY
    SATURDAY
    SUNDAY
)

const (
    _ = iota
    MONDAY
    TUESDAY
    WEDNESDAY
    THURSDAY
    FRIDAY
    SATURDAY
    SUNDAY
)

const (
    MONDAY = iota + 1
    TUESDAY
    WEDNESDAY
    THURSDAY
    FRIDAY
    SATURDAY
    SUNDAY
)

var 变量名 变量类型

// demo/note/note.go
package note
 
var Note string = "hello"

// demo/main.go
 
import (
    "demo/note"
    "fmt"
)
 
func main() {
    fmt.Println(note.Note)
}

func main() {
    var a int
}

var a int8 = 1
var b uint8 = 2
var c int16 = 3
var d int = 4

var a int = 0b1010 // 二进制
var b int = 0O12 // 八进制
var c int = 10 // 十进制
var d int = 0xA // 十六进制

// 低精度转高精度
var a int8 = 1
var b int16 = int16(a)
var c int32 = int32(b)
var d int64 = int64(c)
var e int = int(d)
// 高精度转低精度
var f int = 1
var g int64 = int64(f)
var h int32 = int32(g)
var i int16 = int16(h)
var j int8 = int8(i)

var a float32 = 1.1
var b float64 = 2.2

import "math/big"
 
func main() {
    a := 3.14
    b := 3.14
    result := big.NewFloat(a).Cmp(big.NewFloat(b))
 
    if result == 0 {
        fmt.Println("a == b")
    } else if result == 1 {
        fmt.Println("a > b")
    } else {
        fmt.Println("a < b")
    }
}

var a byte = 'a'
var b rune = 'b'
// 格式化打印字符
fmt.Printf("%c\n", a)
// 直接打印字符
fmt.Println(b)
// 强制转换为字符串
fmt.Println(string(a))

var a bool = true
var b bool = false

var a string = "hello"
var b string = "world"

package main
 
import {
  "fmt"
}
 
func main{
  s:= "字符串"
 
  len:= len(s)
  fmt.Println(len) // 9
 
  for i:= 0; i < len; i++ {
    fmt.Printf("%c\n", s[i])
  }
}

9
E5 AD 97 E7 AC A6 E4 B8 B2

package main
 
import {
  "fmt"
}
 
func main{
  s:= "字符串"
 
  fmt.Println(utf8.RuneCountInString(s)) // 3
 
  for _, r:= range s {
      fmt.Printf("%T, %X\n", r, r)
  }
}

3
int32, 5B57
int32, 7B26
int32, 4E32

var a complex64 = 1 + 2i
var b complex128 = 3 + 4i

import "reflect"
 
func main() {
    var a int = 1
    var b string = "hello"
    var c bool = true
    var d float32 = 1.1
    var e float64 = 2.2
    var f byte = 'a'
    var g rune = 'b'
    var h complex64 = 1 + 2i
    var i complex128 = 3 + 4i
 
    fmt.Println(reflect.TypeOf(a))
    fmt.Println(reflect.TypeOf(b))
    fmt.Println(reflect.TypeOf(c))
    fmt.Println(reflect.TypeOf(d))
    fmt.Println(reflect.TypeOf(e))
    fmt.Println(reflect.TypeOf(f))
    fmt.Println(reflect.TypeOf(g))
    fmt.Println(reflect.TypeOf(h))
    fmt.Println(reflect.TypeOf(i))
}

var 数组名 [数组长度]数组类型

package main
 
import "fmt"
 
func main() {
    a := [3]int{1, 2, 3}
    // 或
    var b [3]int
    b = [3]int{4, 5, 6}
    // 或
    var c [3]int = [3]int{7, 8, 9}
}

package main
 
import "fmt"
 
func main() {
    a := [3]int{1, 2, 3}
    fmt.Println(a[0]) // 1
    fmt.Println(a[1]) // 2
    fmt.Println(a[2]) // 3
}

package main
 
import "fmt"
 
func modify(a [3]int) {
    a[0] = 4
    fmt.Println(a) // [4 2 3]
}
 
func main() {
    a := [3]int{1, 2, 3}
    modify(a)
    fmt.Println(a) // [1 2 3]
}

package main
 
import "fmt"
 
func main() {
    a := [3]int{1, 2, 3}
    a[0] = 4
    fmt.Println(a) // [4 2 3]
}

var a int = 1
var b *int = &a

package main
 
import "fmt"
 
func main() {
    var a = 65336
    fmt.Println("值类型 a 的值为：", a)
 
    var b = 65336
    var c = &b
    fmt.Println("指针类型 c 的值为：", c)
}

值类型 a 的值为： 65336
指针类型 c 的值为： 0xc0000b6010

func tryChange(account Account) {
    account.Modify()
}

func tryChange(account *Account) {
    account.Modify()
}

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

     +-------+-------+-------+
Slice| array |  len  |  cap  |
     +-------+-------+-------+
          |
          v
     +-------+-------+-------+-------+-------+-------+
Array|   1   |   2   |   3   |   4   |   5   |   6   |
     +-------+-------+-------+-------+-------+-------+

var 切片名 []切片类型

s:= make([]int, 5, 10)
 
fmt.Println(len(s)) // 5
fmt.Println(cap(s)) // 10

s:= make([]int, 5, 10)
 
s[0] = 1
s[1] = 2
 
for i:= 0; i < len(s); i++ {
  fmt.Println(s[i])
}

1
2
0
0
0

s:= make([]int, 5, 10)
 
s[0] = 1
s[1] = 2
 
for _, v:= range s {
  fmt.Println(v)
}

s:= make([]int, 5, 10)
 
for i:= 0; i < 10; i++ {
  s[i] = i
}
 
fmt.Println(s)

panic: runtime error: index out of range [5] with length 5

s:= make([]int, 5, 10)
 
for i:= 0; i < len(s); i++ {
  s[i] = i
}
 
s = append(s, 5, 6, 7, 8, 9)

s:= make([]int, 5, 10)
 
for i:= 0; i < len(s); i++ {
  s[i] = i
}
 
a:= append(s, 5, 6, 7, 8, 9)
 
fmt.Println(s) // [0 1 2 3 4]
fmt.Println(a) // [0 1 2 3 4 5 6 7 8 9]

s:= make([]int, 5, 10)
 
for i:= 0; i < len(s); i++ {
  s[i] = i
}
 
fmt.Println(len(s)) // 5
 
s = append(s, 5, 6, 7, 8, 9)
 
fmt.Println(len(s)) // 10
 
fmt.Println(cap(s)) // 10
 
// 打印指针
fmt.Printf("%p\n", s) // 0xc0000b6010
 
// 继续追加
s = append(s, 10)
 
fmt.Println(len(s)) // 11
 
fmt.Println(cap(s)) // 20
 
// 打印指针
fmt.Printf("%p\n", s) // 0xc0000b60b0

a:= [5]int{1, 2, 3, 4, 5}
 
s:= a[1:3]
 
m:= a[:3]
 
n:= a[1:]
 
k:= a[:]
 
fmt.Println(s) // [2 3]
fmt.Println(m) // [1 2 3]
fmt.Println(n) // [2 3 4 5]
fmt.Println(k) // [1 2 3 4 5]

fmt.Printf("%p\n", a) // 0xc0000b6010
fmt.Printf("%p\n", s) // 0xc0000b6018
fmt.Printf("%p\n", m) // 0xc0000b6010
fmt.Printf("%p\n", n) // 0xc0000b6018
fmt.Printf("%p\n", k) // 0xc0000b6010

s:= make([]int, 5, 10)
 
for i:= 0; i < len(s); i++ {
  s[i] = i
}
 
m:= s[1:3]
 
n:= s[:3]
 
fmt.Println(m) // [1 2]
fmt.Println(n) // [0 1 2]

s := []int{1, 2, 3, 4, 5}
 
m := s[1:3]
 
m[0] = 6
 
fmt.Println(s) // [1 6 3 4 5]
fmt.Println(m) // [6 3]

var mapName map[keyType]valueType

mapName := make(map[keyType]valueType)

mapName[key] = value

var m map[string]int
 
m["one"] = 1
m["two"] = 2

for key, value := range mapName {
    fmt.Println(key, value)
}

charCountMap := make(map[string]int)
 
charCountMap["a"] = 1
charCountMap["b"] = 2
 
fmt.Println(charCountMap["a"]) // 1
fmt.Println(charCountMap["c"]) // 0

value, ok := charCountMap["c"]
 
if ok {
    fmt.Println(value)
} else {
    fmt.Println("key not found")
}

delete(mapName, key)

type hmap struct {
    count int // 元素个数
    flags uint8
    B     uint8 // 桶的数量，意味着有 2^B 个桶
    noverflow uint16  // 溢出桶的数量
    hash0 uint32  // 随机数种子
 
    buckets    unsafe.Pointer // Map 底层是一个桶的数组，buckets 指向第一个桶的指针
    oldbuckets unsafe.Pointer // 扩容时，buckets 指向旧的桶数组
    nevacuate  uintptr // 扩容时，已经迁移的桶的数量(迁移进度)
    extra      *mapextra
}

type bmap struct {
    tophash [bucketCnt]uint8
}

type bmap struct {
    tophash [bucketCnt]uint8
    // 以下字段在编译期追加
    // keys    [8]keytype
    // values  [8]valuetype
    // overflow *[]*bmap
    // pad     uintptr
}

        +----------------------------+
tophash |64|15|17|135|156|171|201|138|
        +----------------------------+
        |            key0            |
        +----------------------------+
        |            key1            |
        +----------------------------+
        |            key2            |
        +----------------------------+
        |            ....            |
        +----------------------------+
        |            key7            |
        +----------------------------+
        |           value0           |
        +----------------------------+
        |           ......           |
        +----------------------------+
        |           value7           |
        +----------------------------+
overflow|             nil            |
        +----------------------------+

00001111 | 0000111101101100100011110010100100010010110010101010 | 0000

ch := make(chan int)

ch := make(chan int, 100)

ch <- i

i := <-ch

count := 5
 
ch := make(chan int, count)
 
for i := 0; i < count; i++ {
    ch <- i
}
 
for i := 0; i < count; i++ {
    fmt.Println(<-ch)
}

0
1
2
3
4

type newType existType

type newType struct {
    field1 type1
    field2 type2
    ...
}

type Person struct {
    name string
    age int
}

struct Person {
    char name[20];
    int age;
};

type Person {
    name: string;
    age: number;
}

package main
 
import "fmt"
 
type Person struct {
    Name string
    Age int
}
 
func main() {
    var p1 = Person{
        Name: "张三",
        Age: 18,
    }
    fmt.Println(p1)
}

var p1 = Person{}
p1.Name = "张三"
p1.Age = 18

var p2 = new(Person)

if 条件 {
    // do something
} else if 条件 {
    // do something
} else {
    // do something
}

switch 变量 {
case 值1:
    // do something
case 值2:
    // do something
default:
    // do something
}

switch 变量 {
case 值1:
    // do something
    fallthrough
case 值2:
    // do something
default:
    // do something
}

switch 变量 {
case 值1, 值2:
    // do something
default:
    // do something
}

switch {
case a > 0:
    // do something
case a < 0:
    // do something
default:
    // do something
}

for {
    // do something
}

for {
    fmt.Println("Hello, World!")
}

for {
    fmt.Println("Hello, World!")
    break
}

for 条件 {
    // do something
}

var i int = 0
 
for i < 10 {
    fmt.Println(i)
    i++
}

for 初始语句; 条件; 结束语句 {
    // do something
}

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

for i := 0; i < 10; i++ {
    if i == 5 {
        continue
    }
    fmt.Println(i)
}

for index, value := range array {
    // do something
}

for _, value := range array {
    // do something
}

label:
    // do something
goto label

var i int = 0
 
label:
    fmt.Println(i)
    i++
    if i < 10 {
        goto label
    }

for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
        if j == 5 {
            goto breakTag
        }
    }
}
 
breakTag:
    fmt.Println("done")

$ go mod init hello
go: creating new go.mod: module hello

module hello
 
go 1.15

package main
 
import "github.com/astaxie/beego"
 
func main() {
    beego.Run()
}

$ go get github.com/astaxie/beego

require {
    ...
    github.com/astaxie/beego v1.12.3
}

// /demo/main.go
package main
 
import "fmt"
 
func main() {
    printHello()
}
 
// /demo/hello.go
package main
 
import "fmt"
 
func printHello() {
    fmt.Println("Hello, World!")
}

$ go run demo
Hello, World!

// demo/note/note.go
package note
 
import "fmt"
 
func PrintHello() {
    fmt.Println("Hello, World!")
}

// demo/main.go
package main
 
import "demo/note"  // 导入 note 包的所在文件夹
 
func main() {
    note.PrintHello() // 这里的 note 是导入的包名，不一定和文件夹名一致
}

// demo/main.go
 
import (
    "fmt"
    m "demo/note"  // 使用 m 作为别名
)
 
func main() {
    m.PrintHello()
}

// demo/note/note.go
package note
 
import "fmt"
 
func init() {
    fmt.Println("note 包被导入")
}
 
func PrintHello() {
    fmt.Println("Hello, World!")
}

// demo/main.go
 
import (
    "fmt"
    "demo/note"
)
 
func main() {
    fmt.Println("Hello, World!")
}

note 包被导入
Hello, World!

// demo/main.go
 
import (
    "fmt"
    _ "demo/note"  // 使用 _ 代替包名
)
 
func main() {
    fmt.Println("Hello, World!")
}

func 函数名(参数列表) (返回值列表) {
    // do something
}

func add(a int, b int) int {
    return a + b
}

func add(a, b int) int {
    return a + b
}
 
func main() {
    fmt.Println(add(1, 2))
}

// 求和并求差
func sumAndSub(a, b int) (int, int) {
    return a + b, a - b
}
 
func main() {
    sum, sub := sumAndSub(1, 2)
    fmt.Println(sum, sub)
}

func main() {
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(1, 2))
}

package main
 
import "fmt"
 
func changeElement(arr [5]int) {
    arr[0] = 10
}
 
func changeElementByPointer(arr *[5]int) {
    arr[0] = 10
}
 
func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    changeElement(arr)
    fmt.Println("changeElement:", arr) // [1 2 3 4 5]
 
    changeElementByPointer(&arr)
    fmt.Println("changeElementByPointer:", arr) // [10 2 3 4 5]
}

package main
 
import "fmt"
 
func changeElement(arr [5]int) [5]int {
    arr[0] = 10
    return arr
}
 
func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    arr = changeElement(arr)
    fmt.Println(arr) // [10 2 3 4 5]
}

func maxAndMin(arr []int) (int, int) {
    max, min := arr[0], arr[0]
    for _, v := range arr {
        if v > max {
            max = v
        }
        if v < min {
            min = v
        }
    }
    return max, min
}
 
func main() {
    arr := []int{1, 2, 3, 4, 5}
    max, min := maxAndMin(arr)
    fmt.Println(max, min)
}

func main() {
    max, _ := maxAndMin(arr)
    fmt.Println(max)
}

func maxAndMin(arr []int) (max int, min int) {  // 这里声明了返回值的变量名
    max, min = arr[0], arr[0]
    for _, v := range arr {
        if v > max {
            max = v
        }
        if v < min {
            min = v
        }
    }
    return  // 这里不需要再写返回值
}

func add(a, b int) int {
    return a + b
}
 
func main() {
    addFunc := add  // 将 add 函数赋值给 addFunc 变量，变量就具有了函数的功能
    fmt.Println(addFunc(1, 2))  // 3
}

package main
 
import "fmt"
 
func add(a, b int) int {
    return a + b
}
 
func sub(a, b int) int {
    return a - b
}
 
func mul(a, b int) int {
    return a * b
}
 
func div(a, b int) int {
    return a / b
}
 
func operate(op string, a, b int) (res int) {
    switch op {
      case "+":
          res = add(a, b)
      case "-":
          res = sub(a, b)
      case "*":
          res = mul(a, b)
      case "/":
          res = div(a, b)
    }
    return
}

package main
 
import "fmt"
 
var operateFuncs make(map[string]func(x, y int) int)  // 定义一个 map，key 为 string，value 为函数(func(x, y int) int)
 
func init() {
    operateFuncs["+"] = add
    operateFuncs["-"] = sub
    operateFuncs["*"] = mul
    operateFuncs["/"] = div
    operateFuncs["%"] = mod
}
 
func add(a, b int) int {
    return a + b
}
 
func sub(a, b int) int {
    return a - b
}
 
func mul(a, b int) int {
    return a * b
}
 
func div(a, b int) int {
    return a / b
}
 
func mod(a, b int) int {
    return a % b
}
 
func operate(op string, a, b int) int {
    if f, ok := operateFuncs[op]; ok {
        return f(a, b)
    }
    return 0
}
 
func main() {
    fmt.Println(operate("+", 1, 2))  // 3
    fmt.Println(operate("-", 1, 2))  // -1
    fmt.Println(operate("*", 1, 2))  // 2
    fmt.Println(operate("/", 1, 2))  // 0
    fmt.Println(operate("%", 1, 2))  // 1
}

func main() {
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(1, 2))
}

func invoke(f func()) {
    fmt.Println("before")
    f()
    fmt.Println("after")
}
 
func main() {
    invoke(func() {
        fmt.Println("invoke")
    })
}
 
// before
// invoke
// after

func main() {
    i := 0
    add := func() {
        i++
    }
    add()
    fmt.Println(i)  // 1
}

func getAnonymouseFunc() func() {
    i := 0
    return func() {
        i++
        fmt.Println(i)
    }
}
 
func main() {
    add := getAnonymouseFunc()
    add()  // 1
    add()  // 2
}

func counter() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}
 
func main() {
    c := counter()
    fmt.Println(c())  // 1
    fmt.Println(c())  // 2
    fmt.Println(c())  // 3
}

package main
 
import "fmt"
 
type add func(a, b int) int
 
func addFunc(a, b int) int {
    return a + b
}
 
func main() {
    var f add = addFunc
    fmt.Println(f(1, 2))
}

type F1 func(int, int) int

func A1(c,d int) int {
    return c+d
}

a1 := F1(A1)
a2 := F1(A1)

fmt.Println(a1(1,2)) // 3
 
fmt.Println(a2(3,4)) // 7

type F1 func(a,b int) int
 
func (f F1) show(a,b,c int) {
    fmt.Println("Show Called")
}
 
func (f F1) calc(a,b,c int) int {
    f(a,b)
}

package main
 
import "fmt"
 
type F1 func(a,b int) int
 
func (f F1) show(a,b,c int) {
    fmt.Println("Show Called")
}
 
func (f F1) calc(a,b,c int) int {
    f(a,b)
    fmt.Println("Calc Called")
}
 
func A1(c,d int) int {
    return c+d
}
 
func main() {
    // 因为 A1 遵循 F1 的签名，所以可以强制转换
    a1 := F1(A1)
    // 变量 a1 是 F1 类型的，那么就自动拥有了 F1 类型的方法
    a1.show(1,2,3)
    a1.calc(1,2,3)
}

func add(a, b int) int {
    return a + b
}
 
func sub(a, b int) int {
    return a - b
}
 
func mul(a, b int) int {
    return a * b
}
 
func div(a, b int) int {
    return a / b
}

type BinaryOperationFunc func(a, b int) int

func (f BinaryOperationFunc) calc(a, b int) int {
    return f(a, b)
}

package main
 
import "fmt"
 
type BinaryOperationFunc func(a, b int) int
 
func (f BinaryOperationFunc) calc(a, b int) int {
    return f(a, b)
}
 
func add(a, b int) int {
    return a + b
}
 
func sub(a, b int) int {
    return a - b
}
 
func mul(a, b int) int {
    return a * b
}
 
func div(a, b int) int {
    return a / b
}
 
func main() {
    addFunc := BinaryOperationFunc(add)
    subFunc := BinaryOperationFunc(sub)
    mulFunc := BinaryOperationFunc(mul)
    divFunc := BinaryOperationFunc(div)
 
    fmt.Println(addFunc.calc(1, 2))  // 3
    fmt.Println(subFunc.calc(1, 2))  // -1
    fmt.Println(mulFunc.calc(1, 2))  // 2
    fmt.Println(divFunc.calc(1, 2))  // 0
}

func main() {
    defer fmt.Println("Hello, World!")
    fmt.Println("Hello, Go!")
}

Hello, Go!
Hello, World!

func main() {
    i := 0
    defer fmt.Println(i)
    i++
}

0

type error interface {
    Error() string  // Error 方法，返回异常信息
}

package main
 
import (
    "errors"
    "fmt"
)
 
func main() {
    err := errors.New("this is an error")
    fmt.Println(err)
}

func handleError() {
    panic(errors.New("this is an error"))
}
 
func main() {
 
    fmt.Println("start")
 
    handleError()
 
    fmt.Println("end")
}

start
panic: this is an error

goroutine 1 [running]:
main.handleError()
        /Users/jetzihan/Code/go/src/github.com/jetzihan/go-note/note/golang/error.go:8 +0x3b
main.main()
          /Users/jetzihan/Code/go/src/github.com/jetzihan/go-note/note/golang/error.go:13 +0x2d
exit status 2

func panic(v any)

package main
 
import (
    "fmt"
)
 
func main() {
    panic("this is an error")
}

package main
 
import (
    "fmt"
)
 
type MyError struct {
    Code int
    Msg  string
}
 
func handleError() {
    e := MyError{Code: 100, Msg: "this is an error"}
 
    panic(e)
}
 
func main() {
 
    fmt.Println("start")
 
    handleError()
 
    fmt.Println("end")
}

start

panic: (*main.MyError) 0xc0000b2000

goroutine 1 [running]:
main.handleError()
        /Users/jetzihan/Code/go/src/github.com/jetzihan/go-note/note/golang/error.go:10 +0x3b
main.main()
          /Users/jetzihan/Code/go/src/github.com/jetzihan/go-note/note/golang/error.go:15 +0x2d
exit status 2

package main
 
import (
    "fmt"
)
 
type MyError struct {
    Code int
    Msg  string
}
 
func (e MyError) Error() string {
    return fmt.Sprintf("Code: %d, Msg: %s", e.Code, e.Msg)
}
 
func handleError() {
    e := MyError{Code: 100, Msg: "this is an error"}
 
    panic(e)
}
 
func main() {
 
    fmt.Println("start")
 
    handleError()
 
    fmt.Println("end")
}

start

panic: Code: 100, Msg: this is an error

goroutine 1 [running]:
main.handleError()
        /Users/jetzihan/Code/go/src/github.com/jetzihan/go-note/note/golang/error.go:10 +0x3b
main.main()
          /Users/jetzihan/Code/go/src/github.com/jetzihan/go-note/note/golang/error.go:20 +0x2d
exit status 2

func recover() any

package main
 
import (
    "fmt"
)
 
func handleError() {
    panic("this is an error")
}
 
func main() {
 
    fmt.Println("start")
 
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("recover:", err)
        }
    }()
 
    handleError()
 
    fmt.Println("end")
}