GO语言程序结构

Go语言是编译型的语言
package main //声明 包名
import “fmt” //声明 包
“os”
const boilingF = 212.0 //常量
func main() { //函数
var f = boilingF //变量
s := []int{1,2,3} //s[0] = 1
}
执行语句：go run main.go
编译生成二进制文件：go build main.go + ./main = go run main.go

关键字：break，go，else，if，var，return，switch，continue，import，const，map，package，type，struct，range，for等

变量(var)
声明形式：var name type = expression
i,j := 1,2 //:=表示声明，=表示赋值
i,j = j,i //交换i和j的值
以下几种声明变量的方式是等价的
s := “” //定义并赋值，显示的初始化说明初始化变量的重要性
var s string //隐式的初始化说明初始化变量不重要
var s = “”
var s string =""
var a,b,c = true,2.3,“four” //bool,float,string
var (
i = 100
j = “Tom”
k = 9.99
)

案例：
var i,j,k = 10,“Tom”,9.99
var ( i = 100 j = “Tom~” k = 9.99 )
fmt.Println(“i =”, i,“j =”, j,“k =”,k)
var (
s1 = “hello”
s2 = " world!"
)
var s3 = s1 + s2
fmt.Println("s3 = ",s3)

基本数据类型


查看变量类型：
Printf是格式化，%T是任何值的类型，需要加\n是因为Printf没有自动换行，Println有自动换行

指针：变量是存储值的地方，指针的值就是变量的地址§，一个指针指向变量值所保存的位置，&x(x的地址)获取一个指向变量的指针
x := 1 //定义并赋值
p := &x //p是整型指针，类型是*int，指向变量 x 指针的指向
fmt.Println(*p) //“1”
*p = 2 //等于 x = 2 改变了p所指向变量的值，但指针的值p没有变化，也就是指针的指向没有改变
fmt,Println(x） //结果"2"

常量(const)：true，false，nil，iota
类型(type)：int，int8，int16，int32，int64，unit…unit64，float32，float64，bool，byte，string，error等

函数(func)：make，len，cap，new，copy，close，delete，complex，real，imag
new函数
使用new创建的变量和取其地址的普通局部变量没有不同，只是不需要声明一个虚拟的名字
表达式new(T)创建一个未命名的T类型变量，初始化为T类型的零值，并返回其地址(地址类型为*T)
p := new(int) //*int类型的指针p，指向未命名的int型变量
fmt.Println(*p) //输出0
*p = 2 //把未命名的int变量设置为2
fmt.Println(*p) //输出2
编译器可以选使用堆或栈上的空间来分配内存。在有逃逸情况时使用堆空间，没有逃逸情况使用栈。
var p *int
func f() {
var x int
x = 1
p = &x
}
变量x一定使用堆空间，f函数返回后还可以通过指针p访问，尽管x被声明为一个局部变量，p是全局的指针变量，此时我们说x从f逃逸
func g() {
y := new(int)
y = 1
}
g函数返回时，y变量变得不可访问，内存可以回收，因为y没有从g函数中逃逸

类型声明
type name underlying-type
type Celsius float64
type FAh float64
即使使用相同的底层类型，他们也不是相同的类型，所以不能用作算术表达式或者合并
var c Celsius
var f FAh
fmt.Println(c == 0) //true
fmt.Println(f== 0) //true
fmt.Println(c == f ) //false
fmt.Println(c == Celsius(f)) //true 强转把变量f转换到Celsius类型

包
fmt包进行格式化
os包提供一些函数和变量
os.Args是一个字符串slice，可以理解成一个动态数组s，s[i]访问单个元素，通过s[m : n]访问连续子区间，数组长度len(s)，len是函数，os.Args[1 :len(os.Args)]
Go中所有索引都是左闭右开区间s[m : n]表示从第m到n-1个元素的slice，如果m缺失默认0，n缺失默认len(s)，所以可以简写为os.Args[1 : ]

for
for是Go里唯一循环语句
形式：for initialization；condition；post {
//语句
}
如果没有 initialization和post语句，分号可以省略，就变成了传统的while循环
for condition { //传统的while
}
三部分都是可以省略的
for { //传统的无限循环
}