程序结构
1 命名
Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个命名规则：
- 必须以一个字母(Unicode字母)或下划线开头，后面可以跟任意数量的字母、数字或下划线。
- 区分大小写。大写字母和小写字母是不同的：heapSort和Heapsort是两个不同的名字
- 不能是go关键字(25个)
- 不能是预定义的名字
- 名字是否在函数内部
- 名字的开头字母是否大小写，是否定义在函数体外部
- 简短命名
- 驼峰式命名
Go语言中关键字:
break default func interface select case
defer go map struct chan else goto package
switch const fallthrough if range type
continue for import return var
Go语言中预定义的名字:
内建常量: true false iota nil
内建类型: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64
uintptr float32 float64 complex128 complex64
bool byte rune string error
内建函数: make len cap new append copy close
delete complex real imag panic recover
2 声明
Go语言主要有四种类型的声明语句：var、const、type和func，分别对应变量、常量、类型和函数实体对象的声明
一个Go语言程序对应一个或多个以.go为文件后缀名的源文件，每个源文件以包的声明语句开始，说明该源文件是属于哪个包。包声明语句之后是import语句导入依赖的其它包，然后是包一级的类型、变量、常量、函数的声明语句，包一级的各种类型的声明语句的顺序 无关紧要(函数内部的名字则必须先声明之后才能使用)。例如，下面的例子中声明 了一个常量、一个函数和两个变量：
// 声明源文件属于main包
package main
// 导入fmt依赖包
import "fmt"
// 常量
const boilingF = 212.0
func main() {
// 变量
var f = boilingF
var c = (f - 32) * 5 / 9
// 打印计算结果
fmt.Println("boiling point = %g°F or %g°C\n", f, c)
}
3 注释
// 为单行注释
/*
多行
注释
*/
// 声明源文件属于哪main包
package main
// 导入依赖包
import "fmt"
/*
多行注释
*/
func main() {
// 单行注释
fmt.Println("Hello World!")
}
4 变量
var声明语句可以创建一个特定类型的变量，然后给变量附加一个名字，并且设置变量的初始 值。变量声明的一般语法如下：
var 变量名字 类型 = 表达式
var 变量名字 = 表达式 //省略类型信息，将由初始化表达式来推导类型信息
var 变量名字 类型 //省略初始化表达式，将用零值初始化。
//数值类型变量对应的零值是0
//布尔类型变量对应的零值是false
//字符串类型对应的零值是空字符串
//接口或引用类型（包括slice、指针、map、chan和函数）变量对应的零值是 nil
//数组或结构体等聚合类型对应的零值是每个元素或字段都是对应该类型的零值。
示例:
package main
import "fmt"
/*
包级别定义变量，可以使用或不使用。
函数级别定义变量必须使用
初始化表达式可以是字面量或任意的表达式。
在包级别声明的变量会在main入口函数执行前完成初始化，
局部变量将在声明语句被执行到的时候完成初始化。
*/
var name string = "outname"
func main() {
//定义一个string类型的变量,使用零值初始化
var username string
fmt.Println(username)
var username1 string
username1 = "小明"
fmt.Println(username1)
var username2 string = "小白"
fmt.Println(username2)
//定义多个同类型变量，使用逗号隔开
var username3, username4 string = "name3", "name4"
fmt.Println(username3, username4)
//定义多个不同类型变量，使用()
var (
username5 string
age5 int
)
fmt.Println(username5, age5)
//可以省略数据类型
var (
username6 = "name6"
age6 = 18
)
fmt.Println(username6, age6)
var username7, age7 = "name7", 18
fmt.Println(username7, age7)
//简短声明变量，只能在函数内使用;变量的类型根据表达式来自动推导
//简短变量声明语句中必须至少要声明一个新的变量
ua := 8
fmt.Println(ua)
loveGo := false
fmt.Println(loveGo)
username7, age7, loveGo = "un7", 81, false
fmt.Println(username7, age7, loveGo)
//变量值交换
age6, age7 = age7, age6
fmt.Println(age6, age7)
}
5 常量
常量知识点:
- 常量表达式的值在编译期计算，而不是在运行期。每种常量的潜在类型都是基础类型： bool、string或数字。
- 常量的值不可修改
- 常量间的所有算术运算、逻辑运算和比较运算的结果也是常量
- 一个常量的声明也可以包含一个类型和一个值，如果没有显式指明类型，将由右边的表达式推断类型
- 批量定义常量，如果后面和前面的类型值相同，可省略类型和值
- iota常量生成器(枚举)
package main
import "fmt"
//函数外定义常量
const Hello = "world"
func main() {
fmt.Println(Hello)
//声明常量后是不可更改的
const USERNAME string = "WPFS"
fmt.Println(USERNAME)
//省略声明类型
const AGE = 19
fmt.Println(AGE)
//同时定义多个同类型常量
const USER1, USER2 string = "W1", "W2"
fmt.Println(USER1, USER2)
//同时定义多个不同类型常量
const (
USER3 string = "W3"
USER3ID int = 3
)
fmt.Println(USER3, USER3ID)
//常量定义中，如果后面和前面的类型值相同，可省略类型和值
const (
C7 int = 1
C8
C9
C10 float64 = 3.14
C11
C12
C13 string = "wpf"
C14
C15
)
fmt.Println(C7, C8, C9, C10, C11, C12, C13, C14, C15)
//枚举，const+iota 必须写在括号内, int类型从0开始
//在const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一
const(
E1 int = iota
E2
E3
)
fmt.Println(E1,E2,E3)
const(
E4 int = iota
E5
E6
)
fmt.Println(E4,E5,E6)
const (
H1 int = (iota + 1) * 100
H2
H3
)
fmt.Println(H1, H2, H3)
const (
M1 = iota + 100
M2
M3
)
fmt.Println(M1, M2, M3)
}
6 作用域
package main
import "fmt"
func main() {
//作用域: 定义标识符可以使用的范围
//在Go中用{}来定义作用域的范围
//使用原则: 子语句块可以使用父语句块中的标识符，父不能使用子的
//子语句块可以定义与父相同名称的变量
outer := 1
{
inner := 2
fmt.Println(inner)
fmt.Println(outer)
{
inner2 := 3
outer := 4
fmt.Println(inner)
fmt.Println(outer)
fmt.Println(inner2)
}
}
fmt.Println(outer)
}
7 debug排错
package main
import "fmt"
func main() {
var age = 30
age = age + 2
fmt.Println("明年:", age)
age = age + 1
fmt.Println("后年:", age)
fmt.Print("11111")
fmt.Print("22222")
fmt.Printf("\n%T,%s,%T,%d", "WPFS", "WPFS", 1, 1)
}
