Go之基础语法
一、变量定义
方式一：先定义变量名，在定义类型。
var a int
方式二： 可以为变量赋初值
var a int = 4
方式三：定义多个变量
var a, b int = 3, 4
方式四：Go可以自动识别类型
var a = "hello"
var a, b, c = 3, true, "hello"
方式五：数据类型可以省略
a := 12 // 一个变量
a, b, c, d := 3, true, "hello" // 多个变量
方式六：一个var定义一组
var (
a = 3
b = true
c = "hello"
)
方式七：包内变量
var num int = 10
var num_1 = 34
// num_2 = 45 包内不可以这样子定义
var (
num_3 = 5
num_4 = true
num_5 = "666"
)
func main() {
fmt.Print(num)
fmt.Print(num_1)
fmt.Print(num_3)
fmt.Print(num_4)
fmt.Print(num_5)
}
二、变量类型
2.1. 布尔型
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2.2. 字符串
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
2.3. 数字类型
2.3.1. 整型
| 名称 | 空间 | 描述 | 范围 |
|---|---|---|---|
uint8 |
8bit |
无符号8位整型 | 0 ~ 255 |
uint16 |
16bit |
无符号16位整型 | 0 ~ 65535 |
uint32 |
32bit |
无符号32位整型 | 0 ~ 4294967295 |
uint64 |
64bit |
无符号64位整型 | 0 ~ 18446744073709551615 |
int8 |
7bit |
8位整形 | -128 ~ 127 |
int16 |
16bit |
16位整型 | -32768 ~ 32767 |
int32 |
32bit |
32位整型 | -2147483648 ~ 2147483647 |
int64 |
64bit |
64位整型 | -9223372036854775808 ~ 9223372036854775807 |
int |
系统决定 | 系统决定 | 32位系统为int32，64位系统为int64 |
2.3.2. 浮点型
| 名称 | 空间 | 描述 | 范围 | 精度 |
|---|---|---|---|---|
float32 |
32bit |
32位浮点数 | IEEE-754 1.401298464324817070923729583289916131280e-45 ~ 3.402823466385288598117041834516925440e+38 | 精度6位小数 |
float64 |
64bit |
64位浮点数 | IEEE-754 4.940656458412465441765687928682213723651e-324 ~ 1.797693134862315708145274237317043567981e+308 | 精度15位小数 |
2.3.3. 复数
| 名称 | 空间 | 描述 | 范围 |
|---|---|---|---|
complex64 |
64bit |
复数：float32实数和float32虚数 |
实数和虚数取值范围对应float32 |
complex128 |
128bit |
复数：float64实数和float64虚数 |
实数和虚数取值范围对应float64 |
2.3.4 字符型
| 名称 | 空间 | 描述 | 范围 |
|---|---|---|---|
byte |
8bit |
字符型，uint8别名 |
表示 UTF-8 字符串的单个字节的值，对应 ASCII 码的字符值 |
rune |
34bit |
字符型，uint32别名 |
表示 单个Unicode字符 |
2.3.5. 指针
| 名称 | 空间 | 描绘 | 范围 |
|---|---|---|---|
uintptr |
由系统决定 | 能存放指针地址即可 | 无符号整型 |
三、枚举和常量
3.1. 枚举
func enums() {
const (
cpp = 0
java = 1
php = 2
python = 3
golang = 4
)
fmt.Println(cpp, java, php, python, golang)
}
枚举有一个自增值，相当于这一组枚举值，默认从0开始自增
func enums() {
const (
cpp = iota
java
php
python
golang
)
fmt.Println(cpp, java, php, python, golang) // 0, 1, 2, 3, 4
}
可以跳过自增的值
func enums() {
const (
cpp = iota
_ // 会跳过1
php
python
golang
)
fmt.Println(cpp, php, python, golang) // 0, 2, 3, 4
}
iota作为自增值的种子，用作其他方面
func sizes () {
const (
b = 1 << (10 * iota)
kb
mb
gb
pb
)
fmt.Println(b, kb, mb, gb, pb) // 1 1024 1048576 1073741824 1099511627776
}
3.2. 常量
常量定义可以不定义类型
const username string = "tom"
const username = "tom"
常量作为数值类型的时候可以自己转换不需要我们做强制类型转化
func consts () {
const username string = "tom"
const a, b = 3, 5
// math.Sqrt 参数时需要float64的类型，但是a,b是我们没有顶义类型
var c = int(math.Sqrt(a * a + b * b))
fmt.Println(username, a, b, c)
}
四、条件语句
4.1. if语句
if条件是不需要加括号的
func main() {
// 读取文件内容
contents, err := ioutil.ReadFile("hello.txt")
if err != nil {
fmt.Print(err)
} else {
fmt.Println(string(contents))
}
}
if条件里面可以赋值，并且这个赋值的变脸作用于仅在if语句里面
func main() {
if contents, err := ioutil.ReadFile("hello.txt"); err != nil {
fmt.Print(err)
} else {
fmt.Println(string(contents))
}
}
4.2. switch语句
switch语句是不需要添加break
func arithmetic(a, b int, opera string) int {
var result int
switch opera {
case "+":
result = a + b
case "-":
result = a - b
case "x":
result = a * b
case "/":
result = a / b
default:
panic("为知操作符:" + opera)
}
return result
}
func main() {
fmt.Println(arithmetic(9, 7, "+")) // 16
fmt.Println(arithmetic(9, 7, "-")) // 2
fmt.Println(arithmetic(9, 7, "x")) // 63
fmt.Println(arithmetic(9, 7, "/")) // 1
fmt.Println(arithmetic(9, 7, "&")) // panic: 为知操作符:&
}
switch后可以没有表达式
func grade(score int) string {
result := ""
switch {
case score < 0 || score > 100:
panic(fmt.Sprintln("分数范围不正确")) // panic会直接中断程序
case score < 60:
result = "及格"
case score < 70:
result = "良好"
case score < 80:
result = "优秀"
case score < 90:
result = "突出"
}
return result
}
func main() {
fmt.Println(
grade(0),
grade(59),
grade(69),
grade(79),
grade(89),
grade(99),
grade(100),
)
}
五、循环
for循环不需要括号
func add() int {
sum := 0
for i := 1; i <= 100; i++ {
sum += i
}
return sum
}
func main() {
fmt.Println(add())
}
for的条件里面可以省略初始条件
func less(num int) {
for ; num > 0; num-- {
fmt.Println(num)
}
}
func main() {
// 给定一个数减到0
less(10)
}
for的条件里面可以省略初始条件、结束条件
func less1(num int) {
for num > 0 {
num--
fmt.Println(num)
}
}
func main() {
less1(10)
}
for可以作为死循环
func forever() {
for {
fmt.Println("66666")
}
}
func main() {
forever()
}
六、函数
6.1. 函数定义
func function_name( [parameter list] ) [return_types] {
函数体
}
上面我们已经使用很多个关于函数的例子，在举一个例子
func max(a, b int) int {
if a > b {
return a
} else {
return b
}
}
6.2. 函数调用
可以再其他函数中调用或者在main函数中调用
func max(a, b int) int {
if a > b {
return a
} else {
return b
}
}
func main() {
fmt.Println(max(4, 6))
}
6.3. 返回多个值
func res_to(a, b string) (string, string) {
return b, a
}
func main() {
a, b := res_to("hello", "world")
fmt.Println(a, b)
}
还有更加简单的写法
func div(a, b int) (q, r int) {
q = q / b
r = a % b
return // 自动返回
}
func main() {
q, r := div(10, 6)
fmt.Println(q, r)
}
我们有时候对于多返回值我们只希望使用一个：用下划线代表不使用的返回值
func div(a, b int) (q, r int) {
q = q / b
r = a % b
return // 自动返回
}
func main() {
q, _ := div(10, 6)
fmt.Println(q)
}
6.4. 可变参数列表
func sumParams(values ... int) int {
sum := 0
for i := range values {
sum += values[i]
}
return sum
}
func main() {
fmt.Println(sumParams(1, 2, 3, 4, 5, 6))
}
6.5. 函数可以做为参数使用
func max(a, b int) int {
if a > b {
return a
} else {
return b
}
}
func apply(opera func(int, int) int, a, b int) int {
return opera(a, b)
}
func main() {
fmt.Println(apply(max, 10, 50))
}
七、指针
7.1. 指针定义
var num int = 23
var pr *int = &num
*pr = 45
fmt.Println(num)
7.2. 指针在函数中的使用
Go语言函数只有值传递。修改函数参数，是无法修改原值的
func swap(a, b int) {
b, a = a, b
}
func main() {
a, b := 4, 3
fmt.Println(a, b) // 4, 3
swap(a, b)
fmt.Println(a, b) // 4, 3
}
如何修改就需要使用指针
func swap(a, b *int) {
*b, *a = *a, *b
}
func main() {
a, b := 4, 3
fmt.Println(a, b) // 4, 3
swap(&a, &b)
fmt.Println(a, b) // 3, 4
}
