golang：基础语法学习

包名

每个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() <