目录导包工程管理变量变量声明格式化输出基本数据类型强制类型转换接收键盘输入常量常量声明iota枚举运算符算术运算符赋值运算符关系运算符逻辑运算符条件语句if语句switch语句循环语句函数函数定...
目录
导包工程管理
变量
变量声明
格式化输出
基本数据类型
强制类型转换
接收键盘输入
常量
常量声明
iota 枚举
运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
条件语句
if 语句
switch 语句
循环语句
函数
函数定义
参数列表
函数返回值
函数类型
匿名函数
递归函数
导包
示例：工程结构如下
GOPATH 设置为工程根目录（E:\GO_PROJECT）
test1.go：
package package_test
import "fmt"
/*
定义函数
*/
func Func1（） {
fmt.Println（"test1 func1"）
}
test2.go：
package package_test
import "fmt"
func Func2（） {
fmt.Println（"test2 func2"）
}
testmain.go：
package main
import "dir1/dir2" // 导入的是【目录名】
func main（） {
package_test.Func1（） // 调用的是【包名】
}
运行：
// 方式一 go bulid testmain.go // 编译（生成可执行文件） ./ testmain // 运行（可执行文件） //方式二 go run testmain.go // 编译+运行
导包结论：
一个 GO 程序中一定要有 main 包和 main 函数，这是 GO 程序执行的入口。
编译器会根据指定的相对路径去搜索包然后导入，这个相对路径是从 GOROOT 或 GOPATH（workspace）下的 src 下开始搜索：
GOROOT项目 GOPATH
全局 GOPATH
golang 和 Java 的区别是，在 GO 中 import 的是目录，而不是包名；并且 GO 没有强制要求包名和目录名需要一致，即包和目录是两个不同的概念。
import 导入的是源文件所在的目录名，而不是定义的包名。
在代码中引用包内的成员时，使用定义的包名而不是目录名。
在习惯上将包名和目录名保证一致，但这并不是强制规定。
在同一级目录中，所有源文件只能使用相同的包名。
同一包名下的变量名、函数名等不能重复。
多个目录下的相同包名，彼此无关。
包中的成员（如函数）以名称⾸字母⼤⼩写，决定其访问权限：
⾸字母⼤写，可被包外访问（即public）⾸字母⼩写，仅包内成员可以访问（即
private）工程管理
为了更好的管理项目中的文件，GO 要求将文件都要放在相应的目录中，具体规定了以下目录：
src 目录：以代码包的形式组织并保存 GO 源码文件（比如 .go 文件、.c 文件、.h 文件、.s 文件等）pkg 目录：用于存放经由 go install 命令构建安装后的代码包（包含 GO 库源码文件）的 ".a" 归档文件。bin 目录：与 pkg 目录类似，在通过 go install 命令完成安装后，保存由 GO 命令源javascript码文件生成的可执行文件。以上目录称为工作区（Workspace），工作区其实就是一个对应于特定工程的目录。
src 目录用于包含所有的源代码，是 GO 命令行工具一个强制的规则；而 pkg 和 bin 则无需手动创建，GO 命令行工具在构建过程中会自动创建这些目录。
变量
变量声明
变量名必须以字母或下划线开头，后面可以跟任意数量的字母、数字或下划线。变量的三种声明&初始化方式如下：
// 方式一：先声明（有默认值），后赋值 var a int a = 10 var b, c string b = "b" c = "c" // 方式二：声明+赋值 var a int = 10 // 方式三：自动推导类型（注意：这种方式只能在函数内使用） a := 10 b, c := 11, 12 b, c = c, b // 值交换 // 匿名变量 _, i, _, j = 1, 2, 3, 4
格式化输出
基本数据类型
值的字面量（literal）是指代码中值的文字表示。一个值可能存在多种字面量表示。
表示基本类型值的文本称为基本字面量。基本字面量也被称为字面量常量或未命名常量。
示例：
func main() {
var ch byte = 97 // 声明字符类型
fmt.Printf("ch=%c", ch) // 输出 a
}
这里定义了 ch 是一个字符类型，赋值却是一个整数 97，打印的结果是小写字符 'a'。
原因是：计算机不能直接存储字符类型，只能转成数字存储，那为什么小写字符 'a' 对应的整数是 97 呢？因为计算机是根据 ASCII 码来存储的。
强制类型转换
package main
import "fmt"
func main() {
chinese := 97
math := 99
english := 96
fmt.Printf("总分是 %d，平均分(整数)是 %d, 平均分(浮点数)是 %f", chinese+math+english, (chinese+math+english)/3, float32(chinese+math+english)/3)
// 总分是 292，平均分(整数)是 97, 平均分(浮点数)是 97.333336
}
注意：
GO 语言中不允许隐式转换，所有类型转换必须显式声明（强制转换），而且转换只能发生在两种相互兼容的类型之间
var ch byte = 'c'
// var a int = ch // cannot use ch (type byte) as type int in assignment
var b int = int(ch) // 数据类型名(待转换的值)
int 转 float 强制转换：多小数float 转 int 强制转换：丢精度
接收键盘输入
package main
import fmt
func main（） {
var age int
fmt.Println（"请输入年龄："）
fmt.Scanf（"%d", &age） // 将接收的值赋给age变量
fmt.Printf（"age=%d", age）
}
常量
常量声明
func main() {
// 变量：程序运行期间，值可以改变，声明使用var
// 常量：程序运行期间，值不可以改变，声明使用const
const a int = 11
// a = 12 // error：常量不可以修改
const b = 12 // 自动推导类型（常量不可以使用:=）
}
iota 枚举
iota 常量生成器：用于生成一组递增的整型常量，减去了每行都要写一遍初始化表达式的繁琐。
func main() {
// 在一个 const 声明语句中，在第一个声明的常量所在的行，iota 将会被置为 0，然后在每一个有常量声明的行递增 1
const (
a = iota // 0
b = iota // 1
c = iota // 2
)
const d = iota // iota 遇到const，会被置为 0
// 可以只写一个iota
const (
e = iota // 0
f // 1
g
)
// 同一行值一样
const (
h = iota // 0
i, j, k = iota, iota, iota // 1
l = iota // 2
)
}
运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
如果 a 为真，则 !a 为假&&与a && b如果 a 和 b 都为真，则结果为真，否则为假||或a || b如果 a 和 b 有一个为真，则结果为真，二者都为假时，结果为假
条件语句
if 语句
package main
import "fmt"
func main() {
var score int
fmt.Println("请输入成绩：")
fmt.Scanf("%d", &score)
// if 语句支持一个初始化语句+判断条件
if good_score := 90; score >= good_score {
fmt.Println("优秀")
} else if soso_score := 60; score >= soso_score {
fmt.Println("及格")
} else {
fmt.Println("需要努力")
}
}
switch 语句
注意：case 后面默认自带 break，如果想执行完成某个 case 后继续执行后面的 case，可以使用 fallthrough 关键字。
func main() {
bonus := 5000
var score string
finish := true
fmt.Println("请输入年终评级：")
switch fmt.Scanf("%s", &score); score {
case "A":
bonus += 1000
case "B":
bonus += 5000
case "C":
case "D":
bonus -= 1000
default:
finish = false
fmt.Println("输入有误，请输入正确的评级")
}
if finish {
fmt.Printf("您的年终奖为：%d", bonus)
}
}
循环语句
GO 中的 3 种循环方式：
package main
import "fmt"
func main() {
// 第1种方式
for i := 0; i < 5; i++ {
fmt.Printf("i=%d\n", i)
}
// 第2种方式：类似while循环
num := 1
for num < 5 {
fmt.Printf("num=%d\n", num)
num++
}
// 第3种方式
for {
fmt.Println("死循环")
}
}
函数
函数定义
函数就是将一堆代码进行封装，以便重用的一种机制。
func 函数名(){
函数体
}
参数列表
import "fmt"
func MyFunc(a int, b int, args ...int) { // 注意：不定长参数必须放在参数列表最后
fmt.Println("定长参数为：", a, b)
for i, data := range args { // 若不需要编号，则可使用 for _, data := range args
fmt.Println("编号为：", i)
fmt.Println("数据为：", data)
}
}
func main() {
MyFunc(1, 2, 3, 4, 5)
}
打印结果：
定长参数为： 1 2
编号为： 0
数据为： 3
编号为： 1
数据为： 4
编号为： 2
数据为： 5
函数返回值
// 定义返回值类型
func Add(a int, b int) int {
return a + b
}
// 给返回值命名
func Sub(a int, b int) (sub int) {
sub = a - b
return sub // 也可以只写 return
}
// 返回多个值
func Sub(a, b, c int) {
a, b, c = 1, 2, 3
return a, b, c // 也可以只写 return
}
函数类型
在 GO 语言中还有另外一种定义使用函数的方式，就是函数类型。
所谓的函数类型，就是将函数作为一种类型可以用来定义变量，基本使用如下：
func Test(a, b int) int {
return a + b
}
// 定义函数类型：即需要传递两个整型参数，有一个整型返回值的函数类型
type FuncType func(a int, b int) int // type关键字后面跟着类型的名字（FunType）
func main() {
var result FuncType // 类型是FuncType类型，即函数类型
result = Test
s := result(1, 2)
fmt.Printf("s=%d", s)
}
匿名函数
所谓匿名函数就是没有名字的函数。匿名函数最主要的功能就是实现了闭包。
package main
import "fmt"
func main() {
num := 9
// 使用方式一：定义匿名函数并赋值给变量
f1 := func() {
// 在匿名函数中可以直接访问main()中定义的局部变量
// 并且在匿名函数中对变量的值进行了修改，最终会影响到整个main()函数中定义的变量值
num++
fmt.Println("匿名函数：", num)
}
f1() // 10
fmt.Println("main函数：", num) // 10
// 使用方式二：通过函数类型
type FuncType func() // 没有参数，没有返回值
var f2 FuncType = f1
f2()
// 使用方式三：直接调用
func(a, b int) {
fmt.Println("a + b =", a+b)
}(3, 6)
// 有参有返回值的匿名函数
min, max := func(a, b int) (min, max int) {
if a > b {
return b, a
} else {
return a, b
}
}(12, 13)
fmt.Printf("min=%d, max=%d\n", min, max)
}
递归函数
示例：阶乘
func Test(num int) int {
if num == 1 {
return 1
}
return num * Test(num-1)
}
func main() {
var num int
fmt.Println("请输入需要阶乘的数：")
fmt.Scanf("%d", &num)
fmt.Printf("%d的阶乘结果为：%d", num, Test(num))
}
以上就是一文详解Golang中的基础语法的详细内容，更多关于Golang基础语法的资料请关注我们其它相关文章！
