Go语言基础（二）
跟着上篇，继续看Go基础
一、变量作用域
与C类似，有全局变量、局部变量、形参之分
package main
import "fmt"
// 全局变量
var c = 20
func main() {
// 局部变量
a := 10
b := 20
fmt.Println("a = ", a)
fmt.Println("a + b = ", sum(a, b))
fmt.Println("c = ", c)
}
// 形参
func sum(a int, b int) int{
a ++
c ++ // 修改全局变量
fmt.Println("in sum() a = ", a)
return a + b
}运行结果：
a = 10
in sum() a = 11
a + b = 31
c = 21二、数组
与C基本一致
package main
import "fmt"
func avg(a []int) float64{
var s = 0.0 // 默认是float64
n := len(a)
// 类C数组的访问
for i := 0; i < n; i++ {
s += float64(a[i])
}
return s / float64(n)
}
func main() {
var balance = []int{5, 4, 3, 2, 1}
// 数组传递和C语言一样
result := avg(balance)
fmt.Println("average of balance = ", result)
// foreach遍历
for index, element := range balance{
fmt.Println(index, element)
}
}运行结果：
average of balance = 3
0 5
1 4
2 3
3 2
4 1三、指针
和C语言一致，操作符为&和*，且支持多级指针
package main
import "fmt"
func main() {
a := 10
b := 20
swap(&a, &b)
fmt.Println("a = ", a)
fmt.Println("b = ", b)
}
func swap(x *int, y *int) {
*x, *y = *y, *x
}运行结果：
a = 20
b = 10四、结构体
结构体和C的struct一致，由于Go没有显式的class，结构体还承载了面向对象的特性，比较灵活
package main
import "fmt"
type Person struct {
name string
age int
}
// 函数方法
func (person *Person) say() {
fmt.Println("name: ", person.name,
"age: ", person.age)
}
func (person *Person) grow() {
// 传指针的情况会修改对象本身
// 如果参数不是对象指针，则改变的是对象的副本
fmt.Println(person.name, "grow...")
person.age ++
}
func printPerson(person *Person) {
fmt.Println("name: ", person.name,
"age: ", person.age)
}
func main() {
// 初始方法一
var p1 Person
p1.name = "Jack"
p1.age = 20
// 初始方法二
var p2 = Person{"Mike", 21}
// 初始方法三，key-value形式
var p3 = Person{
name: "Tom",
age: 30,
}
printPerson(&p1)
// 模拟对象
p2.say()
p2.grow()
p2.say()
p3.say()
}运行结果：
name: Jack age: 20
name: Mike age: 21
Mike grow...
name: Mike age: 22
name: Tom age: 30五、切片
切片的用法和Python相似，但灵活性没那么高，不过比C的数组强大很多
package main
import "fmt"
func main() {
nums := []int {0, 1, 2, 3, 4, 5, 6, 7, 8}
// 原始切片
fmt.Println(nums)
// 切片
fmt.Println(nums[1:4])
fmt.Println(nums[:3])
fmt.Println(nums[2:])
// 添加元素
nums = append(nums, 9)
// 一次添加多个
nums = append(nums, 10, 11, 12)
// 浅拷贝，会修改b[0]的值
nums2 := nums[:]
nums2[0] = -1
fmt.Println("nums2: ",nums2)
fmt.Println("nums: ",nums)
// 深拷贝用法
nums3 := make([]int, len(nums))
copy(nums3, nums)
nums3[0] = -2
fmt.Println("nums3: ", nums3)
fmt.Println("nums: ", nums)
}运行结果：
[0 1 2 3 4 5 6 7 8]
[1 2 3]
[0 1 2]
[2 3 4 5 6 7 8]
nums2: [-1 1 2 3 4 5 6 7 8 9 10 11 12]
nums: [-1 1 2 3 4 5 6 7 8 9 10 11 12]
nums3: [-2 1 2 3 4 5 6 7 8 9 10 11 12]
nums: [-1 1 2 3 4 5 6 7 8 9 10 11 12]六、Range用法
foreach遍历
package main
import "fmt"
func main() {
// 普通foreach对字符串的遍历
// c的值为字符的unicode编号
for i, c := range "abc" {
fmt.Println(i, c)
}
// key-value遍历
dict := map[int]string{
1: "apple",
2: "banana",
}
for k, v := range dict {
// 格式化输出
fmt.Printf("%d -> %s\n", k, v)
}
}运行结果：
0 97
1 98
2 99
1 -> apple
2 -> banana七、哈希表
和Python的dict用法一致
package main
import "fmt"
func main() {
countryCapitalMap := make(map[string]string)
// 插入元素
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "New Delhi"
// 查询
fmt.Println(countryCapitalMap["Italy"])
// 删除
delete(countryCapitalMap, "Italy")
// exist == false
capital, exist := countryCapitalMap["Italy"]
if exist {
fmt.Println(capital)
} else {
fmt.Println("Not exist")
}
}运行结果：
Rome
Not exist八、面向接口
Go语言的接口和Java概念类似，把同一类操作的方法放在一起，表示某一类功能
package main
import "fmt"
type Phone interface {
call()
}
// 定义结构体
type NokiaPhone struct{}
type IPhone struct{}
// 实现call方法
func (nokiaPhone NokiaPhone) call() {
fmt.Println("NokiaPhone Call")
}
// 实现call方法
func (iPhone IPhone) call() {
fmt.Println("IPhone Call")
}
func main() {
var phone Phone
// 面向接口编程
phone = new(NokiaPhone)
phone.call()
phone = new(IPhone)
phone.call()
}运行结果：
NokiaPhone Call
IPhone Call