基本语法
函数语法
go
package main //程序的包名
/*
import "fmt"
import "time"
*/
import (
"fmt"
"time"
)
//main函数
func main() { //函数的{ 一定是 和函数名在同一行的，否则编译错误
//golang中的表达式，加";", 和不加 都可以，建议是不加
fmt.Println(" hello Go!")
time.Sleep(1 * time.Second)
}变量声明
:= 只能够用在 函数体内来声明
%T 查看变量的类型
go
package main
/*
四种变量的声明方式
*/
import (
"fmt"
)
//声明全局变量 方法一、方法二、方法三是可以的
var gA int = 100
var gB = 200
//用方法四来声明全局变量
// := 只能够用在 函数体内来声明
//gC := 200
func main() {
//方法一：声明一个变量 默认的值是0
var a int
fmt.Println("a = ", a)
fmt.Printf("type of a = %T\n", a)
//方法二：声明一个变量，初始化一个值
var b int = 100
fmt.Println("b = ", b)
// %T 查看变量的类型
fmt.Printf("type of b = %T\n", b)
var bb string = "abcd"
fmt.Printf("bb = %s, type of bb = %T\n", bb, bb)
//方法三：在初始化的时候，可以省去数据类型，通过值自动匹配当前的变量的数据类型
var c = 100
fmt.Println("c = ", c)
fmt.Printf("type of c = %T\n", c)
var cc = "abcd"
fmt.Printf("cc = %s, type of cc = %T\n", cc, cc)
//方法四：(常用的方法) 省去var关键字，直接自动匹配
e := 100
fmt.Println("e = ", e)
fmt.Printf("type of e = %T\n", e)
f := "abcd"
fmt.Println("f = ", f)
fmt.Printf("type of f = %T\n", f)
g := 3.14
fmt.Println("g = ", g)
fmt.Printf("type of g = %T\n", g)
// =====
fmt.Println("gA = ", gA, ", gB = ", gB)
//fmt.Println("gC = ", gC)
// 声明多个变量
var xx, yy int = 100, 200
fmt.Println("xx = ", xx, ", yy = ", yy)
var kk, ll = 100, "Aceld"
fmt.Println("kk = ", kk, ", ll = ", ll)
//多行的多变量声明
var (
vv int = 100
jj bool = true
)
fmt.Println("vv = ", vv, ", jj = ", jj)
}总结
- 局部变量声明
| 方式 | 说明 | 示例 |
|---|---|---|
| 方法一 | 声明变量，默认值为零值 | var a int |
| 方法二 | 声明并指定类型和初始值 | var b int = 100 |
| 方法三 | 省略类型，由值自动推断 | var c = 100 |
| 方法四（常用） | 省略 var，短变量声明 | e := 100 |
- 全局变量声明
方法一、方法二、方法三可用于全局变量：
go
var gA int = 100
var gB = 200方法四（:=）不能用于全局变量，只能在函数体内使用。
- 多变量声明
单行写法：
go
var xx, yy int = 100, 200
var kk, ll = 100, "Aceld"多行写法：
go
var (
vv int = 100
jj bool = true
)常量与 iota
- 常量
go
const a int = 10
const (
a = 10
b = 20
)- iota
与 const 来表示枚举类型
go
package main
import "fmt"
//const 来定义枚举类型
const (
//可以在const() 添加一个关键字 iota， 每行的iota都会累加1, 第一行的iota的默认值是0
BEIJING = 10*iota //iota = 0
SHANGHAI //iota = 1
SHENZHEN //iota = 2
)
const (
a, b = iota+1, iota+2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
c, d // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
e, f // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4
g, h = iota * 2, iota *3 // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9
i, k // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)
func main() {
fmt.Println("BEIJIGN = ", BEIJING)
fmt.Println("SHANGHAI = ", SHANGHAI)
fmt.Println("SHENZHEN = ", SHENZHEN)
fmt.Println("a = ", a, "b = ", b)
fmt.Println("c = ", c, "d = ", d)
fmt.Println("e = ", e, "f = ", f)
fmt.Println("g = ", g, "h = ", h)
fmt.Println("i = ", i, "k = ", k)
}多返回值函数
go
package main
import "fmt"
//返回多个返回值，匿名的
func foo2(a string, b int) (int, int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
return 666, 777
}
//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
fmt.Println("---- foo3 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)
//r1 r2 属于foo3的形参， 初始化默认的值是0
//r1 r2 作用域空间 是foo3 整个函数体的{}空间
fmt.Println("r1 = ", r1)
fmt.Println("r2 = ", r2)
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}
// r1, r2 int 同一个类型
func foo4(a string, b int) (r1, r2 int) {
fmt.Println("---- foo4 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}
func main() {
c := foo1("abc", 555)
fmt.Println("c = ", c)
ret1, ret2 := foo2("haha", 999)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
ret1, ret2 = foo3("foo3", 333)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
ret1, ret2 = foo4("foo4", 444)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
}import
go
package main
import (
// 导入 lib1
"GolangStudy/5-init/lib1"
// 当前代码不使用 lib1 的函数，但是想执行 init，用_导入
_ "GolangStudy/5-init/lib1"
// 别名
mylib2 "GolangStudy/5-init/lib2"
// 把 lib2 的方法全部导入到当前文件， Lib2Test()，前面不需要命名 xxx.Lib2()
//. "GolangStudy/5-init/lib2"
)
func main() {
// 使用 lib1的函数，会先执行内部的 init 函数
lib1.lib1Test()
//lib2.Lib2Test()
mylib2.Lib2Test()
//Lib2Test()
}