包名
每个go文件第一句是包名 package 包名
若想要当前main作为项目的入口,则包名必须为main,即package main
导包
使用import "包名"
// 导一个包
import "fmt"
// 导多个包 方式一
import(
"fmt"
"time"
)
// 导多个包 方式二
import "fmt"
import "time"
注意:导入的包必须要在程序中使用,如果没有用到则会报错。
三种特殊的导包方式
_:上面提到,如果导入的包在程序中没有用到,则会报错。但有时候,我们想要执行包下的init方法,而不需要调用该包,那么我们可以在前面添加_
符号,如下:
import (
// 在包名前面使用_
_ "helloworld/test1"
)
func main() {
// 方法中即使没有用到导入包,也不会报错
}
自定义别名:在包名前面可以自定义包的别名,调用的时候就使用别名调用即可。
import lena "helloworld/test1"
func main() {
//test1.Method4() // 原先的这种调用方法会报错
lena.Method3() // 利用别名调用包的方法
}
.:使用.
加在包名前面,可以将其他包的所有方法加入到当前包中,因此可以不通过包名,直接调用方法,如下:
// 原先是这样导入包
import "helloworld/test1"
func main() {
// 通过包名.方法名调用其他包的方法
test1.Method4()
}
// 在导包前面加入.
import . "helloworld/test1"
func main() {
//test1.Method4() // 原先的这种调用方法会报错
// 省略包名,可以直接调用其他包下的方法。
Method4()
}
注意:如果引入的多个包前面都添加了.
,可能不同包下有同名方法,那么会发生歧义。
执行顺序
从main包为入口。如果当前go文件有import
则一直向下执行,直到没有import的包下,然后往回开始执行这些文件的全局常量、全局变量、init()方法。如下图:
常量
使用关键词const
。定义的时候必须指明值,或者使用const进行多个常量声明时,前面的常量使用了iota
。
单个常量
func Const1() {
// 定义常量 只读
const a int = 1
fmt.Println("a =",a) // a = 1
//a=2 // 若试图更改常量值,会报错
}
func Const2() {
// 不指明类型
const b = "hello"
fmt.Println("b =",b) // b = hello
}
// 全局常量
const c = 3
func Const3() {
fmt.Println("c =",c) // c = 3
}
多个常量 枚举类型
func Const4() {
// 单行定义
const a,b="hello","world"
fmt.Println(a,b) // hello world
// 多行定义
const(
d=1
e="lena"
)
fmt.Println(d,e) // 1 lena
}
// 全局常量
const a,b="hello","lena"
func Const5() {
fmt.Println(a,b) // hello lena
}
// 枚举类型
const (
SPRING=1
SUMMER=2
AUTUMN=3
WINTER=4
)
func Const6() {
fmt.Println(SPRING) //1
fmt.Println(SUMMER) //2
fmt.Println(AUTUMN) //3
fmt.Println(WINTER) //4
}
iota
和const一起使用,用于给const常量自动赋值。每次出现的时候初始值都是0
func Iota1() {
// iota初始值是0
const a=iota
fmt.Println(a) // 0
//var a=iota //报错:iota只能配合const
}
func Iota2() {
// iota每次默认自增1
const (
a=iota
b
c
d
)
fmt.Println(a,b,c,d) // 0 1 2 3
}
func Iota3() {
// 不同const的iota互不干扰
const(
a=iota
b
)
fmt.Println(a,b) // 0 1
const (
c=iota
d
)
fmt.Println(c,d) // 0 1
}
func Iota4() {
// 同行iota的值相等 iota=0
const a, b = iota + 1, iota + 10
fmt.Println(a, b) // 1 10
const (
// iota=0,c=1,d=10
c, d = iota + 1, iota + 10
// iota=1,e=3,f=11
e, f = iota + 2, iota + 10
)
fmt.Println(c, d) // 1 10
fmt.Println(e, f) // 3 11
}
func Iota5(){
// iota规则延续第一个定义的规则
// 如果定义时一行定义了两个常量,接下来都要遵循这个规则,不能只定义一个
const(
// iota=0,g=0,c=0
g,h=iota*2,iota*4
// iota=1,i=1*2=2,j=1*4=4
i,j
// iota=2,l=2*2=4,m=2*4=8
l,m
//n // 只定义一个会报错
)
fmt.Println(g,h) // 0 0
fmt.Println(i,j) // 2 4
fmt.Println(l,m) // 4 8
}
func Iota6() {
const(
a=iota+5 // 5:0+5
k // 6:1+5
b=10 // 定义了常量会打断iota规则 后续的值如果没使用iota都是此常量
c // 10:跟着b的值
d=iota // 4:iota的规则已经被打破 当前iota与第一个相差4行 iota=4
g // 5:iota+1
)
fmt.Println(a,k,b,c,d,g) // 5 6 10 10 4 5
const(
e=1
f
)
fmt.Println(e,f) // 1 1
}
变量
单个变量声明
以下是四种方式定义变量,使用var
定义。
import "fmt"
// 定义变量
// 方式一:初始化 但不赋值
func Var1() {
// 先写名字 再写类型
var a int
// int型初始化默认是0
fmt.Println("a = ",a) // a = 0
}
// 方式二:初始化并赋值
func Var2() {
var b int = 10
fmt.Println("b = ",b) // b = 10
}
// 方式三:初始化时省略数据类型(自动匹配类型)
func Var3() {
var c = 10
fmt.Println("c = ",c) // c = 10
}
// 方式四:利用“:=”符号
func Var4() {
// 声明+赋值 必须是未被声明的变量
d:=10
fmt.Println("d = ",d) // d = 10
}
上面定义的都是局部变量,如果要定义全局变量,除了方法四都可以。
// 方法一
var ga int
// 方法二
var gb int = 10
// 方法三
var gb = 10
多个变量声明
多行定义多变量
// 局部变量
func Var5() {
var (
a int = 100
b int = 10
)
fmt.Println("a =",a,"b =",b) // a = 100 b = 10
}
// 全局变量
var (
ga int = 20
gb int = 10
)
func Var6() {
fmt.Println("ga =",ga,"gb =",gb) // ga = 20 gb = 10
}
单行定义多变量
// 局部变量
func Var7() <