Go语言基础

第一个Go程序

//声明main包，表明当前是一个可执行程序
package main
//导入内置fmt包
import "fmt"
//main函数,是程序的入口
func main()  {
	fmt.Println("hell go")
}

变量声明

     Go语言中的每一个变量都有自己的类型,并且变量必须经过声明才能开始使用,同一作用域内不支持重复声明,并且Go语言的变量声明后必须使用。

//声明变量
var 变量名 变量类型
var name string
var age int
var job bool

//批量声明变量
var (
	name string
	age int
	job bool
)

//与用户交互事例
package main
import "fmt"
func main() {
	var (
		name string
		age  int
		job  string
	)
	fmt.Printf("输入姓名: ")
	fmt.Scanln(&name)
	fmt.Printf("输入年龄: ")
	fmt.Scanln(&age)
	fmt.Printf("输入地址: ")
	fmt.Scanln(&job)
	fmt.Printf("您的姓名: %v\n您的年龄: %v\n您的地址: %v\n", name, age, job)
}
结果
输入姓名: 小明
输入年龄: 22
输入地址: 北京
您的姓名: 小明, 您的年龄: 22, 您的地址: 北京

变量初始化

　　整型和浮点型变量的默认值为 0
　　字符串变量的默认值为空字符串
　　布尔型变量默认为 false
　　切片、函数、指针变量的默认为 nil

在声明变量的时候为其指定初始值

var 变量名 类型 = 表达式
var name string = "haha"
var age int = 18

初始多个变量

var name,age = "hehe",20

类型推导
　　将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

var name  = "haha"
var age = 20

短变量声明(只能在函数内部使用)

package main
import "fmt"
func main() {
	m := 11
	n := 22
	fmt.Println(m, n)
}

匿名变量

　　匿名变量用一个下划线_表示(在使用多重赋值时,要忽略某个值),匿名变量不占用命名空间,不分配内存

多行注释

package main
import "fmt"
func main()  {
	fmt.Println("姓名\t年龄\t籍贯\t住址\njrey\t18\t北京\t河南")
/*
	fmt.Println("bob")
	fmt.Println("pack")
*/
}

打印多行字符
定义一个多行字符串时，就必须使用反引号字符

package main
import "fmt"
func main() {
	s1 := `D:\Adobe\Esl`
	s2 := `aaa
bbb
ccc`
	fmt.Println(s1)
	fmt.Println(s2)
}
结果
D:\Adobe\Esl
aaa
bbb
ccc

格式化代码
C:\Users\Administrator>gofmt -w E:\GoWorks\src\day1.go

 

注意事项

1. 函数外只能放(变量/常量/函数/类型)的声明
2. :=不能在函数外使用
3. _多用于站位,表示忽略此值

 执行go程序

go build xx.go
xx.exe
或者
go run xx.go

常量
　　常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

const p1 = 3.144
const e = 2.777

声明多个常量

const (
	p1 = 3.123
	e = 2.312
)

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。

package main
import "fmt"
const (
	p1 = 100
	p2
	p3
)

func main() {
	fmt.Printf("%d\n%d\n%d\n", p1, p2, p3)
}
结果
100
100
100

iota

　　iota是go语言的常量计数器，只能在常量的表达式中使用
　　iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(定义枚举有用)

const (
	n = iota
	p1 = 100
	e = iota
	d
	_	//跳过某值
	a
)
func main()  {
	fmt.Println(n)
	fmt.Println(p1)
	fmt.Println(e)
	fmt.Println(d)
	fmt.Println(a)
}
#结果
0
100
2
3
5


#多个iota定义一行
const (
	a,b = iota +1,iota +2
	c,d
	e,f
)
func main()  {
	fmt.Println(a,b)
	fmt.Println(c,d)
	fmt.Println(e,f)
}
结果
1 2
2 3
3 4