1.第一个go语言程序
package main //声明所属的包
import ( //
"fmt"
)
func main(){
fmt.Println("hello world")
}
go run ./hello.go #执行当前文件
输出:hello world
也可以构建可执行程序,然后执行可执行程序得到输出
go build ./hello.go
/hello.exe
输出结果:hello world
-
第一行代码package main定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包,如:package main。package main表示一个可独立执行的程序,每个 Go 应用程序都包含一个名为 main 的包。
-
下一行**import “fmt”**告诉 Go 编译器这个程序需要使用 fmt 包(的函数,或其他元素),fmt 包实现了格式化 IO(输入/输出)的函数。
-
下一行func main()是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的,一般来说都是在启动后第一个执行的函数(如果有 init() 函数则会先执行该函数)。
注意:这里面go语言的语法,定义函数的时候,‘{’ 必须和函数名在同一行,不能另起一行。
2.天生的并发基因
func gofunc(i int) {
fmt.Println("goroutine", i, "......")
}
func main() {
fmt.Println("begin func")
for i := 0; i < 10000; i++ {
go gofunc(i)
}
time.Sleep(time.Second)
}
3.变量声明
第一种,指定变量类型,声明后若不赋值,使用默认值为0
func godata() {
var a int
fmt.Printf("a=%d", a)
}
$go run data.go
a=0
第二种,根据初始值自行判定变量类型
func godata() {
var b = "hello go"
fmt.Printf("the type of b if %T,b=%s", b, b)
}
$go run ./hello.go
the type of b if string,b=hello go
第三种,省略var,注意:=左侧的变量不应该是已经声明过的,否则会导致编译错误【变量的生命周期为函数体类】
func godata() {
c := 3.14
fmt.Printf("the type of c is %T,c=%f", c, c)
}
$go run ./hello.go
the type of c is float64,c=3.140000
3.1多变量声明
var x, y int
var ( //这种分解的写法,一般用于全局变量
a int
b bool
)
var c, d int = 1, 2
var e, f = 122, "hello go"
func mult_func() {
//这种不带声明格式变量,生命周期在函数体内
g, h := 123, "我是一个字符类型的变量"
fmt.Println(x, y, a, b, c, d, e, f, g, h)
}
$go run ./hello.go
0 0 0 false 1 2 122 hello go 123 我是一个字符类型的变量
4.常量和iota
常量的定义格式 const identifier [type] = value;其中可以省略变量类型type,让编译器可以根据变量的值推导其类型
显示声明类型定义:
const str string="hello go"
隐式类型定义
const b="hello go"
func const_data() {
const length int = 20
const width int = 10
var area int
area = length * width
const a = "面积的大小为:"
fmt.Println(a, area)
}
$go run ./hello.go
面积的大小为: 200
常量可以使用len(),cap(),unsafe.Sizeof()常量计算表达式的值
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)
func main(){
fmt.Println(a,b,c)
}
$go run ./hello.go
abc 3 16
字符串类型在 go 里是个结构体, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节,所以字符串类型大小为 16 个字节。
1.优雅的iota变量
每一行的iota都会累加1,第一行的iota的默认值是0;同时,下一行的变量会继承上一行的计算方式
const (
xx = 10 + iota
yy
zz = 2 * iota
ww
)
const (
a, b = iota + 1, iota + 2
c, d
e, f
g, h = iota + 3, iota + 4
i, k
)
func print() {
fmt.Println("xx=", xx, "yy=", yy, "zz=", zz, "ww=", ww)
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", i, "k=", k)
}