标签：结构   变量   格式化   基本   bash   Go语言   []   value   wap   

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

Go语言基础（二）

标签：结构   变量   格式化   基本   bash   Go语言   []   value   wap   

原文地址：https://www.cnblogs.com/fanghao/p/9746999.html