【go基础】变量声明

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)
}