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