go语言入门学习

短命女 2023-01-13 06:15 90阅读 0赞

### 文章目录 ###

*  简介
 *  go 数据类型
 *   *  数据类型基本介绍
     *  类型强制转换
     *  类型断言
     *  go 数组和切片数组
     *  go 指针
     *  go 结构体和接口
     *  Map 类型
     *  error 错误类型
     *  chan 通道
 *  go 运算符
 *   *  算术运算符
     *  关系远算符号
     *  逻辑运算符
     *  位运算符
     *  赋值运算符
 *  go 变量和常量
 *   *  go 变量
     *  go 常量
 *  go 函数
 *  go 选择语句
 *  go 循环语句
 *  go 并发
 *   *  go 关键字
     *  channel 通道
 *  go 注释
 *  go 语言练习

# 简介 #

GO 一门开源的编程语言，07 年开发的，09 年开源，12 年出了 go 1 稳定版

go 专门被设计成应用于（搭载了 Web 服务器/存储集群/类似用户的巨型中央服务器）的系统编程语言，在高性能的分布式系统领域来说，go 比其他语言有着更高的开发效率，提供了海量并行支持，对于游戏服务端而言是非常合适的

这里有几个很好的 golang 的学习网址：

*  [https://tour.go-zh.org/welcome/1][https_tour.go-zh.org_welcome_1] （中文版）教你编写代码的形式来一步步带你入门 go
 *  [https://github.com/Unknwon/the-way-to-go\_ZH\_CN][https_github.com_Unknwon_the-way-to-go_ZH_CN] github中电子书《go语言入门指南》
 *  [https://books.studygolang.com/gopl-zh/][https_books.studygolang.com_gopl-zh] 在线阅读《go语言圣经》
 *  [https://gobyexample.com][https_gobyexample.com] 英文版本go的样例

# go 数据类型 #

## 数据类型基本介绍 ##

*  布尔型 bool
    
        // 取值 true 或者 false
        bool
 *  字符型 byte/rune  
    go 不像 java 中特别指定字符类型
    
        // byte 代表 ascll 中一个字符，等价于 uint8
        byte
        // rune 识别 unicode 编码的字符，中文一个字也是一个字符，等价于 int32
        rune
 *  整型 int
    
        // 一般情况 int 优先，8 字节
        int
        // 无符号
        uint8		uint16	uint32	uint64
        // 有符号
        int8		int16		int32		int64
        // 其他
        uintptr	byte
 *  浮点型 float
    
        // 浮点数
        float32		float64
 *  复数类型
    
        // 实数和虚数
        complex64	complex128
 *  字符串型
    
        // 字符串
        string
 *  错误型
    
        // 错误
        error
 *  复合类型
    
     *  指针类型
        
            *int
            
            **int
     *  数组类型
        
            [3][5]int
     *  切片类型
        
            []int
     *  Map 类型
        
            map[string]string
     *  通道类型
        
            // 协程之间传输数据
            chan int
     *  结构化类型
        
            type Person struct {
                    
              x,y	float32
            }
     *  接口类型
        
            type IPerson interface {
                    
              Born(buf []byte)(n int, err error)
            }

## 类型强制转换 ##

go 语言不像 java 可以做到不同类型数据运算时候做到自动数据转换，go 是没法做到的，它必须手动强制数据类型转换后再去做运算，但是为什么是不支持自动类型转换呢？

// 类型转换
    var a int = 2
    var b float32 = float32(a)

## 类型断言 ##

## go 数组和切片数组 ##

数组声明和初始化举例

// var 指定数组并初始化
    var arr = [3]int{
        1, 2, 3}
    
    // 指定数组并初始化
    arr := [3]int{
        1, 2, 3}
    
    // 不确定数组长度，用...来代替
    var arr2 = [...]float32{
        1.0, 2.0, 3.0}
    arr3 := [...]float32{
        1.0, 2.0, 3.0}
    
    // 声明数组
    var arr [10]int
    
    // 二维数组
    var arr1 [3][4]int
    var arr2 = [1][2]int{
        
      {
        3, 3}
      {
        4, 4}
    }
    
    // 创建空数组
    arr := [][]string{
        }

函数中的数组

// 指明数组的大小
    func fun1(arr []int) {
        
      
    }
    
    // 没有指明数组大小
    func fun2(arr [2]int) {
        
      
    }

切片数组（动态数组），可以追加元素，追加时容量可以变大。切片无需说明长度

// 声明切片数组：声明一个未指定大小的数组定义切片，并且 a 切片数组在没有初始化之前 a 是 nil，a 的长度和容量都是 0
    var a []int
    
    // 创建切片：make 函数创建切片，下面 make 函数第二个参数代表长度
    var a = make([]int, 5)
    b := make([]int, 5)
    
    // 创建切片：下面 make 第二个参数是数组长度，第三个参数是数组的容量
    c := make([]int, 5, 6)
    
    // 数组的地址值赋值，有多种形式 s := arr[startIndex:endIndex]，s := arr[startIndex:]，s := arr[:endIndex]
    var arr []int = [3]int {
        1, 2, 3}
    s := arr[:]
    
    // 创建空切片，并进行 append 追加元素
    var arr1 []int
    arr1 = append(arr1, 2, 3, 6)
    
    // 将 arr1 copy 到 arr2（内容的拷贝）
    arr2 := make([]int, len(arr1), cap(arr1)*2)
    copy(arr2, arr1)
    fmt.Println(arr2)

make，len，cap 函数的使用

var arr = make([]int, 5, 6)
    fmt.Printf("%d, %d, %v", len(arr), cap(arr), arr);

## go 指针 ##

// 变量的地址值
    var a int = 10
    fmt.Println(&a)
    
    // 指针使用
    var a int = 10
    var b *int
    b = &a
    fmt.Println(a)
    fmt.Println(*b)
    
    // 空指针 a 就是 nil，而 *a 的值是 0
    var a *int
    
    // 数组指针
    var arr [3]*int
    
    // 指向指针的指针
    var a **int
    
    // 函数中指针类型传参
    func fun(x *int, y *int) {
        
      
    }

## go 结构体和接口 ##

结构体

// 结构体
    type Person struct {
        
      name string
      age int
      address string
    }
    func main() {
        
      // 初始化接口体的几种方式
      fmt.Println(Person("liming", 12, "北京市"))
      fmt.Println(Person(name:"liming", age:12, address:"北京市"))
      fmt.Println(Person(name:"liming", age:12))
      
      // 另一种初始化方式
      var person Person
      person.name = "liming"
      person.age = 12
      person.address = "北京市"
      fmt.Println(person.name)
    }
    func fun1(person1 Person) {
        
      
    }
    func fun2(person2 *Person) {
        
      
    }

接口

// Person 接口
    type Person interface {
        
      call()
    }
    
    // 结构体
    type Student struct {
        
      
    }
    
    // 实现接口的方法
    func(student Student) call() {
        
      fmt.Println("我是学生")
    }

## Map 类型 ##

无序的键值对集合，Map 是无序的，无法决定它的返回顺序，使用哈希表来实现

// 声明 map，并给 map 赋值，然后遍历 map，查看元素在集合中是否存在，map1 一开始是 nil
    var map1 map[string]string
    map2 := make(map[string]string)
    map3 := map[string]string{
        "c":"ccc", "d":"ddd"}
    map1["a"] = "aaa"
    map1["b"] = "bbb"
    for ch := range map1 {
        
      fmt.Println(map1[ch])
    }
    value, ok := map1["a"]
    if (ok) {
        
      
    } else {
        
      
    }
    
    // delete 函数
    delete(map3, "c")

## error 错误类型 ##

go 语言通过内置的错误接口提供了非常简单的错误处理机制，error 类型是一个接口类型

type error interface {
        
      Error() string
    }

我们可以在最后的返回值中返回 error 信息

func function() (int, error) {
        
      return 5, errors.New("错误信息")
    }
    
    func main() {
        
      result, err := function()
    }

## chan 通道 ##

具体讲解可以看下方的 **channel 通道**

# go 运算符 #

运算优先级类似 java

## 算术运算符 ##

加减乘除，求余，自增，自减和 java 一样

## 关系远算符号 ##

`== != > < >= <=`这些和 java 都是一样的

## 逻辑运算符 ##

`&& || !`这些和 java 都是一样的

## 位运算符 ##

`& | ^ << >>`

## 赋值运算符 ##

`= += -= *= /= %= <<= >>= &= ^= |=`和 java 一样

# go 变量和常量 #

## go 变量 ##

声明变量用 var，示例如下

// 声明一个变量
    var param string
    
    // 声明多个变量（非全局变量）
    var param1, param2 int
    param1, param2 = 1, 2
    var param1, param2 = 1, 2
    // 声明多个变量（全局变量）
    var(
    	param1 string
      param2 int
    )
    
    // 自行判断变量
    var param = true
    
    // var 和 := 等同
    var param int
    param1 := 1

方法中指定变量没有初始值则有默认值

*  数值对应 0
 *  string 对应 “”
 *  bool 对应 false
 *  数组，指针，map，通道，error，方法等类型则是对应 nil

值类型和引用类型

*  值类型：变量直接指向内存中的值（int，float，bool，string），也就是说等号将值给一个变量时候是将内存中的值进行了拷贝，&param 就行获取内存地址，值类型变量存储在栈内存中，
 *  引用类型：变量存储值的地址值

## go 常量 ##

常量示例

// 局部
    const LENGTH = 1
    const WIDTH, CIRCLE = 1, 2
    
    // 全局
    const(
    	a = "aaa"
      b = 1
    )
    
    // 特殊常量 iota，const 语句块中表示行索引，每当遇到新的 iota 时候重新计数行索引
    // 下面 a 结果是 0，b 结果是 1，c 结果是 2
    const(
    	a = iota
      b
      c
    )

# go 函数 #

go 语言最少有一个 main

// 返回一个值
    func max(num1, num2 int) int {
        
      
    }
    
    // 返回多个值
    func swap(nums1, nums2 int) (int, int) {
        
      return nums2, nums1
    }
    func main() {
        
      a, b := swap(1, 2)
    }

函数闭包，go 支持匿名函数，可作为闭包，匿名函数优越在于可以使用函数内的变量，不必申明

func getSequence() func() int {
        
      return func() int {
        
        return 1
      }
    }

# go 选择语句 #

if else 和 java 一样，但是小括号是不用加的，并且 else 不可单独另作一行

switch 语句如下：

var a int = 1
    switch a {
        
      case 1: xxx
    	case 2: xxx
      default: xxx
    }
    
    switch {
        
      case true: xxx
    	default: xxx
    }

select 语句类似一个通信的 switch 语句，每个 case 都必须是一个通信操作，要么接收要么发送；select 随机执行一个可运行的 case，如果没有 case 运行，它将被阻塞

格式如下：

select {
        
      case xxx : yyy
    	default : yyy
    }

# go 循环语句 #

for 循环如下

// for 循环一种形式
    for i := 0; i < 10; i++ {
        
      
    }
    
    // for 类似 while
    for i < 10 {
        
      
    }
    
    // for 无限循环
    for {
        
      
    }
    
    // foreach range 用来遍历字符串数组等进行遍历，还可以用在键值对上，
    strings := []string{
        "aaa", "bbb"}
    for i,s := range strings {
        
      fmt.println(i, s);
    }
    
    kvs := map[string]int{
        "a":1, "b":2}
    for k,v := range kvs {
        
      fmt.Printf("%s, %d", k, v)
    }

另外 break，continue，goto 和 java 一样

# go 并发 #

## go 关键字 ##

go 语言支持并发，通过 go 关键字来开启 goroutine 即可，goroutine 是轻量级线程，其是由 golang 运行时进行管理的，下面举例说明

package main
    
    import (
    	"fmt"
      "time"
    )
    
    func say(s string) {
        
      for i := 0; i < 5; i++ {
        
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
      }
    }
    
    func main() {
        
      // 通过 g 关键字开启一个 goroutine 轻量级线程
      go say("aaa")
      say("bbb")
    }

## channel 通道 ##

通道关键字是 chan，可以在两个 goroutine 之间传递一个指定类型的值，`<-`可以用来指定通道方向，如果没有指定方向，则为双向通道，下方举例使用通道

package main
    
    import "fmt"
    
    func main() {
        
      var a int = 5
      // 创建一个通道
      b := make(chan int)
      // 把 a 给通道 b
      go function(a, b)
      a2 := <- b
      fmt.Println(a2)
    }
    
    func function(a int, b chan int) {
        
      b <- a
    }

chan 通道可以设置缓冲区大小，发送端发送的数据可以放在缓冲区中

如果通道不带缓冲区，发送方会阻塞，直到接收方从通道中接收了值

如果通道带有缓冲区，发送方会阻塞，直到发送的数据被拷贝到了缓冲区，如果缓冲区已经满了，则又会被阻塞，直到接收方开始消费缓冲区

package main
    
    import "fmt"
    
    func main() {
        
      // 设置缓冲区大小为 2
      ch := make(chan int, 2)
      ch <- 3
      ch <- 5
      // 获取通道中的两个数据，这里打印出 3
      fmt.Println(<-ch)
      // 这里打印出来 4
      fmt.Println(<-ch)
    }

通道关闭为 close(通道)，通道的遍历依然是通过 range

func main() {
        
      // 声明一个缓冲区大小为 3 的通道
      ch := make(chan int, 3)
      ch <- 3
      ch <- 1
      ch <- 9
      close(ch)
      for i := range ch {
        
        fmt.Println(i)
      }
    }

# go 注释 #

// 单行注视
    
    /* 
    	多行注释
    */

# go 语言练习 #

递归实现求斐波那契数列

package main
    
    import "fmt"
    
    func main() {
        
    	// n = 1 时候值为 1，n = 2 时值为 1，求 n = 10 时候值为多少？使用递归
    	fmt.Println(function(10))
    }
    
    /*
    	斐波那契函数
     */
    func function(n int) int {
        
    	if n <= 0 {
        
    		return 0
    	} else if n == 1 {
        
    		return 1
    	} else if n == 2 {
        
    		return 1
    	} else {
        
    		return function(n-1) + function(n-2)
    	}
    }

[https_tour.go-zh.org_welcome_1]: https://tour.go-zh.org/welcome/1
[https_github.com_Unknwon_the-way-to-go_ZH_CN]: https://github.com/Unknwon/the-way-to-go_ZH_CN
[https_books.studygolang.com_gopl-zh]: https://books.studygolang.com/gopl-zh/
[https_gobyexample.com]: https://gobyexample.com