Hello World

package main

import "fmt"

func main(){
    fmt.Println("hello world")
}

包

为了更好的组织代码提供的一个概念.把功能相关的文件组织在一个包中,方便使用和查找.

包的习惯用法:

1. 包名一般小写.
2. 包名一般和目录相同(虽然可以不同)
3. 包名不能包含 -
4. 包一般使用域名作为顶级包名.github.com/go-sql-driver/mysql

包的导入

import "包的路径"

单行导入

import "fmt"

import github.com/go-sql-driver/mysql

多行导入

import (
    "fmt"
    "time"
)

main 包

入口包.

go 语言中, 同时满足 main 包与 main() 函数, 才会被编译为可执行文件.

参考 Hello World 的代码.

main 包下方法调用

package main

import "fmt"

func main(){
    Hello()
    fmt.Println("hello world")
}

package main

import "fmt"

func Hello(){
    fmt.Println("Hello")
}

此时执行命令go run main.go 会报错

$ go run main.go
# command-line-arguments
.\main.go:15:2: undefined: Hello

应该使用命令 go run *.go

init() 函数

在导入包时会自动触发包内部的init()函数, 该函数没有参数也没有返回值.不能被其他函数调用.

//  执行导入包后执行 init 函数，然后执行 main 函数
package main

import "fmt"

var i int = 1

func init(){
    fmt.Println("main init:",i)
}
func main(){
    fmt.Println("hello world")
}

$ go run main.go
main init: 1
hello world

image.png

init() 执行顺序

main.go 依次 导入 a.go aa.go b.go

package main

import (
    "fmt"
    
    "github.com/go-study/a"
    "github.com/go-study/aa"
    "github.com/go-study/b"
)

var i int = 1

func init() {
    fmt.Println("main init:", i)
}

func main() {
    fmt.Println("hello world")
    a.A()
    aa.AA()
    b.B()
}

package aa

import "fmt"

func init() {
    fmt.Println("aa init")
}

func AA() {
    fmt.Println("AA")
}

package a

import "fmt"

func init() {
    fmt.Println("a init")
}

func A() {
    fmt.Println("A")
}

package b

import "fmt"

func init() {
    fmt.Println("b init")
}

func B() {
    fmt.Println("B")
}

输入结果

$ go run main.go
a init
aa init
b init
main init: 1
hello world
A
AA
B

init 执行顺序是根据 导入包的顺序.来执行 init() 函数

a.init() --> aa.init() --> b.init() -- main.init()

main.go 导入 a.go

a.go 导入 aa.go

aa.go 导入 b.go

package main

import (
    "fmt"

    "github.com/go-study/a"
)

var i int = 1

func init() {
    fmt.Println("main init:", i)
}

func main() {
    fmt.Println("hello world")
    a.A()
}

package a

import (
    "fmt"

    "github.com/go-study/aa"
)

func init() {
    fmt.Println("a init")
}

func A() {
    fmt.Println("A")
    aa.AA()
}

package aa

import (
    "fmt"

    "github.com/go-study/b"
)

func init() {
    fmt.Println("aa init")
}

func AA() {
    fmt.Println("AA")
    b.B()
}

package b

import "fmt"

func init() {
    fmt.Println("b init")
}

func B() {
    fmt.Println("B")
}

输出结果

b init
aa init
a init
main init: 1
hello world
A
AA
B

导入顺序

导入顺序

执行顺序

执行顺序

可见性

go 语言中并没有像 Java 中 public private 这类的权限修饰符. 而是将标识符首字母大写则对外可见.(包外)

package user

// 该 结构体 包外不可见.只能本包内使用.
// 一般 IDE 会提示警告.
type user struct {
    username string
}

// 该 结构体 包外可见.
type Person struct {
    // Name 字段包外可见
    Name string 
    // age 字段包外不可见
    age  uint8
}
// 该 方法 包外可见
func Add (a,b int) int{
    return a+b
}