Go语言学习之路（一）

已于 2022-08-24 17:34:26 修改
阅读量937 收藏 5
点赞数
分类专栏： Go 文章标签： golang go
于 2022-04-13 19:20:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39578545/article/details/124139278
版权

Go语言学习之路

Go语言简介

Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。

Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。

对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。它提供了海量并行的支持，这对于游戏服务端的开发而言是再好不过了。

第一个Go程序：
go安装地址：https://golang.google.cn/dl/
接下来我们来编写第一个 Go 程序 hello.go（Go 语言源文件的扩展是 .go），代码如下：

hello.go文件

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

要执行 Go 语言代码可以使用 go run 命令。

$ go run hello.go 
Hello, World!

此外我们还可以使用 go build 命令来生成二进制文件：
$ go build hello.go 
$ ls
hello    hello.go
$ ./hello 
Hello, World!

Go语言结构

Go 语言的基础组成有以下几个部分：

  • 包声明
  • 引入包
  • 函数
  • 变量
  • 语句 & 表达式
  • 注释
package main  // 包声明

import "fmt"  // 引用包

func main() {  // 函数必须包含。 需要注意的是 { 不能单独放在一行
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")  
}
  • 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；
  • 当标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
文件结构:

Test
--helloworld.go

myMath
--myMath1.go
--myMath2.go

// helloworld.go
package main

import (
"fmt"
"./myMath"
)

func main(){
    fmt.Println("Hello World!")
    fmt.Println(mathClass.Add(1,1))
    fmt.Println(mathClass.Sub(1,1))
}

// myMath1.go
package mathClass
func Add(x,y int) int {
    return x + y
}

// myMath2.go
package mathClass
func Sub(x,y int) int {
    return x - y
}

格式化字符串：
fmt.Sprintf 格式化字符串并赋值给新串：

package main

import (
    "fmt"
)

func main() {
   // %d 表示整型数字，%s 表示字符串
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}

Go语言变量
声明变量的一般形式是使用 var 关键字：

var identifier type

可以一次声明多个变量：
var identifier1, identifier2 type

intVal := 1 相等于：
var intVal int 
intVal =1 

package main
import "fmt"
func main() {
    var a string = "Runoob"  // a1 := "Ruoob"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)
}

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
  • 如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。
  • 如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，a declared but not used。
  • 在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。但是全局变量是允许声明后不使用的。

Go语言常量
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

  • 显式类型定义： const b string = “abc”
  • 隐式类型定义： const b = “abc”

Go语言运算符
在这里插入图片描述
在这里插入图片描述

   /*  & 和 * 运算符实例 */
   ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);

Go语言循环语句
Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。
和 C 语言的 for 一样：

for init; condition; post { }

init： 一般为赋值表达式，给控制变量赋初值；
condition： 关系表达式或逻辑表达式，循环控制条件；
post： 一般为赋值表达式，给控制变量增量或减量。

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

计算 1 到 10 的数字之和：

package main

import "fmt"

func main() {
        sum := 0
        for i := 0; i <= 10; i++ {
                sum += i
        }
        fmt.Println(sum)
}

init 和 post 参数是可选的，我们可以直接省略它，类似 While 语句。

package main

import "fmt"

func main() {
        sum := 1
        for ; sum <= 10; {
                sum += sum
        }
        fmt.Println(sum)

        // 这样写也可以，更像 While 语句形式
        for sum <= 10{
                sum += sum
        }
        fmt.Println(sum)
}

无限循环：要停止无限循环，可以在命令窗口按下ctrl-c 。

package main

import "fmt"

func main() {
        sum := 0
        for {
            sum++ // 无限循环下去
        }
        fmt.Println(sum) // 无法输出
}

For-each range 循环
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

package main
import "fmt"

func main() {
        strings := []string{"google", "runoob"}
        for i, s := range strings {
                fmt.Println(i, s)
        }


        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

以上实例运行输出结果为:

0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

Go语言函数

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int = 200
   var ret int

   /* 调用函数并返回最大值 */
   ret = max(a, b)

   fmt.Printf( "最大值是 : %d\n", ret )
}

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
   /* 定义局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result
}

函数返回多个值

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

以上实例执行结果为：
Runoob Google

语言函数引用传递值
引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

引用传递指针参数传递到函数内，以下是交换函数 swap() 使用了引用传递：
允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可。

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int= 200

   fmt.Printf("交换前，a 的值 : %d\n", a )
   fmt.Printf("交换前，b 的值 : %d\n", b )

   /* 调用 swap() 函数
   * &a 指向 a 指针，a 变量的地址
   * &b 指向 b 指针，b 变量的地址
   */
   swap(&a, &b)

   fmt.Printf("交换后，a 的值 : %d\n", a )
   fmt.Printf("交换后，b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}

以上代码执行结果为：

交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100

Go语言数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

var balance [10] float32
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果数组长度不确定，可以使用 … 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

1:2  3:7

访问数组元素

var salary float32 = balance[9]

package main

import "fmt"

func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int

   /* 为数组 n 初始化元素 */        
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }

   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

Go语言指针

什么是指针？
一个指针变量指向了一个值的内存地址。
类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：

var var_name *var-type

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。以下是有效的指针声明：
var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

如何使用指针？
指针使用流程：

  • 定义指针变量。
  • 为指针变量赋值。
  • 访问指针变量中指向地址的值。

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。

package main
import "fmt"
func main() {
   var  ptr *int
   fmt.Printf("ptr 的值为 : %x\n", ptr  )
}

输出结果：ptr 的值为 : 0

空指针判断：

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */

整型指针数组
在这里插入图片描述

指向指针的指针
如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址：

指向指针的指针变量声明格式如下：

var ptr **int;  // 访问指向指针的指针变量值需要使用两个 * 号

package main

import "fmt"

func main() {

   var a int
   var ptr *int
   var pptr **int

   a = 3000

   /* 指针 ptr 地址 */
   ptr = &a

   /* 指向指针 ptr 地址 */
   pptr = &ptr

   /* 获取 pptr 的值 */
   fmt.Printf("变量 a = %d\n", a )
   fmt.Printf("指针变量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}

以上实例执行输出结果为：
变量 a = 3000
指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000

Go语言结构体

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

定义结构体：
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：
variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}


func main() {

    // 创建一个新的结构体
    fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})

    // 也可以使用 key => value 格式
    fmt.Println(Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407})

    // 忽略的字段为 0 或 空
   fmt.Println(Books{title: "Go 语言", author: "www.runoob.com"})
}

输出结果为：
{Go 语言 www.runoob.com Go 语言教程 6495407}
{Go 语言 www.runoob.com Go 语言教程 6495407}
{Go 语言 www.runoob.com  0}

访问结构体成员：
如果要访问结构体成员，需要使用点号 . 操作符，格式为：

结构体.成员名

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* 打印 Book2 信息 */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

结构体作为函数参数

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   printBook(Book1)

   /* 打印 Book2 信息 */
   printBook(Book2)
}

func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title)
   fmt.Printf( "Book author : %s\n", book.author)
   fmt.Printf( "Book subject : %s\n", book.subject)
   fmt.Printf( "Book book_id : %d\n", book.book_id)
}

结构体指针

   /* 打印 Book2 信息 */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title)
   fmt.Printf( "Book author : %s\n", book.author)
   fmt.Printf( "Book subject : %s\n", book.subject)
   fmt.Printf( "Book book_id : %d\n", book.book_id)
}

Go语言切片（slice）
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片
你可以声明一个未指定大小的数组来定义切片：

var identifier []type

切片不需要说明长度。
或使用 make() 函数来创建切片:

var slice1 []type = make([]type, len)
也可以简写为
slice1 := make([]type, len)


s :=[] int {1,2,3 } 
直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。

也可以指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)

s := arr[:] 
初始化切片 s，是数组 arr 的引用。

s := arr[startIndex:endIndex] 
将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。

s := arr[startIndex:] 
默认 endIndex 时将表示一直到arr的最后一个元素。

s := arr[:endIndex] 
默认 startIndex 时将表示从 arr 的第一个元素开始。

s1 := s[startIndex:endIndex] 
通过切片 s 初始化切片 s1。

s :=make([]int,len,cap) 
通过内置函数 make() 初始化切片s，[]int 标识为其元素类型为 int 的切片。

len() 和 cap() 函数
切片是可索引的，并且可以由 len() 方法获取长度。
切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}


以上实例运行输出结果为:
len=3 cap=5 slice=[0 0 0]

空切片
一个切片在未初始化之前默认为 nil，长度为 0

var numbers []int

append() 和 copy() 函数

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)  
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

以上代码执行输出结果为：

len=0 cap=0 slice=[]
len=1 cap=1 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=6 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]

Go语言范围（Range）

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

package main
import "fmt"
func main() {
    //这是我们使用range去求一个slice的和。使用数组跟这个很类似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)
    //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的键值对上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

运行输出结果：

sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111

Go语言Map（集合）

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

定义 Map
可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

下面实例演示了创建和使用map:

package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

    /*查看元素在集合中是否存在 */. 
    /* ok是布尔值，即使缺少也是可以运行的 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) {
        fmt.Println("American 的首都是", capital)
    } else {
        fmt.Println("American 的首都不存在")
    }
}

以上实例运行结果为：

France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
India  首都是 新德里
American 的首都不存在

delete() 函数
delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：

ackage main

import "fmt"

func main() {
        /* 创建map */
        countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}

        fmt.Println("原始地图")

        /* 打印地图 */
        for country := range countryCapitalMap {
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        }

        /*删除元素*/ delete(countryCapitalMap, "France")
        fmt.Println("法国条目被删除")

        fmt.Println("删除元素后地图")

        /*打印地图*/
        for country := range countryCapitalMap {
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        }
}

以上实例运行结果为：

原始地图
France 首都是 Paris
Italy 首都是 Rome
Japan 首都是 Tokyo
India 首都是 New delhi
法国条目被删除
删除元素后地图
Italy 首都是 Rome
Japan 首都是 Tokyo
India 首都是 New delhi

Go语言接口

Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

实例

package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}

在上面的例子中，我们定义了一个接口Phone，接口里面有一个方法call()。然后我们在main函数里面定义了一个Phone类型变量，并分别为之赋值为NokiaPhone和IPhone。然后调用call()方法，输出结果如下：

I am Nokia, I can call you!
I am iPhone, I can call you!

Go错误处理

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
error类型是一个接口类型，这是它自身的定义：

type error interface {
    Error() string
}
一个Error()的方法，即用字符串返回对应的错误信息。

最常用的error相关方法是2种：
1、创建error - fmt.Errorf，它是针对Error()方法返回的字符串进行加工，如附带一些参数信息
2、使用error - 由于我们将error的输出结果定义为字符串，所以使用error时，一旦涉及到细节，就只能使用一些String的方法了。

函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

在下面的例子中，我们在调用Sqrt的时候传递的一个负数，然后就得到了non-nil的error对象，将此对象与nil比较，结果为true，所以fmt.Println(fmt包在处理error时会调用Error方法)被调用，以输出错误，请看下面调用的示例代码：

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

完整例子

1、通过导入errors包

package main
import (
  "fmt"
  "errors"
)


func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    return 1,nil
}

func main () {
  result, err:= Sqrt(-1)

  if err != nil {
     fmt.Println(err)
     fmt.Println(result)
  }
}

2、自定义接口并实现

package main
import (
  "fmt"
)

type error interface {
    Error() string
}
type NoError struct{
}

func (noerror NoError) Error() string {
    return "you are error"
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        var err error
        err = new(NoError)
        return f, err
        //`定义变量的时候没有开辟内存，当err = new(NoError) 会定义`
    }
    return 1,nil
}

func main () {
  result, err := Sqrt(-1)

  if err != nil {
     fmt.Println(err)
     fmt.Println(result)
  }
}

package main

import (
    "fmt"
)

// 定义一个 DivideError 结构
type DivideError struct {
    dividee int
    divider int
}

// 实现 `error` 接口
func (de *DivideError) Error() string {
    strFormat := `
    Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0
`
    return fmt.Sprintf(strFormat, de.dividee)
}

// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
    if varDivider == 0 {
            dData := DivideError{
                    dividee: varDividee,
                    divider: varDivider,
            }
            errorMsg = dData.Error()
            return
    } else {
            return varDividee / varDivider, ""
    }

}

func main() {

    // 正常情况
    if result, errorMsg := Divide(100, 10); errorMsg == "" {
            fmt.Println("100/10 = ", result)
    }
    // 当除数为零的时候会返回错误信息
    if _, errorMsg := Divide(100, 0); errorMsg != "" {
            fmt.Println("errorMsg is: ", errorMsg)
    }

}

100/10 =  10
errorMsg is:  
    Cannot proceed, the divider is zero.
    dividee: 100
    divider: 0

具体的例子：
在这里插入图片描述

在这里插入图片描述

错误实现
1、对程序来说，error要包含错误细节：如错误类型、错误码等，方便在模块间传递
2、对人来说，error要包含代码信息：如相关的调用参数、运行信息，方便查问题。

stack与wrap包装

第一种风格：单独处理
在这里插入图片描述

第二种风格：集中处理
在这里插入图片描述

第三种风格：函数式编程
在这里插入图片描述

在这里插入图片描述

  • ContinueOnError表示遇到了error只记录下来，但整个流程继续往下跑。
  • BreakOnError表示遇到了error就直接break，不再跑接下来的MyFunc
  • 函数式编程最直观的一个特点是 延迟执行，也就是在引用MyFunc处不运行，在ContinueOnError或BreakOnError里才是真正执行的地方。

关注点1 - 数据结构
样例中的 []MyFunc是一个切片，可以简单地理解为串行执行，也就是MyFunc执行完一个，再执行下一个。

关注点2 - 执行逻辑
以ContinueOnError或BreakOnError为例，它们都是对各种MyFunc的处理逻辑。

Go并发通道

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。

goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

goroutine 语法格式：

go 函数名( 参数列表 )
go f(x, y, z)

开启一个新的 goroutine:
f(x, y, z)

Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。

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() {
        go say("world")
        say("hello")
}

执行以上代码，你会看到输出的 hello 和 world 是没有固定先后顺序。因为它们是两个 goroutine 在执行：

world
hello
hello
world
world
hello
hello
world
world
hello

通道（channel）
通道（channel）是用来传递数据的一个数据结构。
通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

以下实例通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结果的和：

package main

import "fmt"

func sum(s []int, c chan int) {
        sum := 0
        for _, v := range s {
                sum += v
        }
        c <- sum // 把 sum 发送到通道 c
}

func main() {
        s := []int{7, 2, 8, -9, 4, 0}

        c := make(chan int)
        go sum(s[:len(s)/2], c)
        go sum(s[len(s)/2:], c)
        x, y := <-c, <-c // 从通道 c 中接收

        fmt.Println(x, y, x+y)
}

输出结果为：
-5 17 12

通道缓冲区
通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：

ch := make(chan int, 100)

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

package main

import "fmt"

func main() {
    // 这里我们定义了一个可以存储整数类型的带缓冲通道
        // 缓冲区大小为2
        ch := make(chan int, 2)

        // 因为 ch 是带缓冲的通道，我们可以同时发送两个数据
        // 而不用立刻需要去同步读取数据
        ch <- 1
        ch <- 2

        // 获取这两个数据
        fmt.Println(<-ch)
        fmt.Println(<-ch)
}
执行输出结果为：
1
2

Go 遍历通道与关闭通道
Go 通过 range 关键字来实现遍历读取到的数据，类似于与数组或切片。格式如下：

v, ok := <-ch

如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。

package main

import (
        "fmt"
)

func fibonacci(n int, c chan int) {
        x, y := 0, 1
        for i := 0; i < n; i++ {
                c <- x
                x, y = y, x+y
        }
        close(c)
}

func main() {
        c := make(chan int, 10)
        go fibonacci(cap(c), c)
        // range 函数遍历每个从通道接收到的数据，因为 c 在发送完 10 个
        // 数据之后就关闭了通道，所以这里我们 range 函数在接收到 10 个数据
        // 之后就结束了。如果上面的 c 通道不关闭，那么 range 函数就不
        // 会结束，从而在接收第 11 个数据的时候就阻塞了。
        for i := range c {
                fmt.Println(i)
        }
}
执行输出结果为：

0
1
1
2
3
5
8
13
21
34

Go与Python区别

经常用python写一些运维工具，在python写运维工具的过程中，发现有这几个问题：

  • 写时一时爽，维护火葬场。稍微复杂一点的脚本，或者读别人写的脚本实在太痛苦了，各种参数，各种dict里面的格式，猜的难受，很多时候只能靠print出来看一下。
  • 部署困难，python的强大在于各种丰富的库，部署时，缺少这些库导致无法运行，苦逼

尝试了用go编写运维工具，发现正好可以解决这些问题

  • 静态编译语言，强制类型检查。少用点interface{}，维护、阅读起来很方便，不用猜
  • 静态链接，自带交叉编译功能，基本能做到一次编译，拷贝过去就能运行
果子哥丶
关注
专栏目录
Go语言学习之路
能力创造快乐！
06-18 1157
Go入门
Go语言学习
-
03-14 1225
Go语言学习 GO的优势 极简单的部署方式 可直接编译成机器码 不依赖其他库 直接运行即可部署 静态类型的语言 编译的时候检查出来隐藏的大多数问题 语言层面的并发 天生的基因支持 充分的利用多核 强大的标准库 runtime系统调度机制 高效的GC垃圾回收(3色标记和混合写屏障) 丰富的标准库(加解密 底层库 同步机制 网络通信 数据结构与算法等等) 简单易学 25个关键字 c...
Go语言教程（一看就会）
最新发布
bjjgff的博客
07-25 2403
Go语言是一门开源的编程语言，目的在于降低构建简单、可靠、高效软件的门槛。Go平衡了底层系统语言的能力，以及在现代语言中所见到的高级特性。
三、Go 语言基础语法
Fabio的博客
07-26 1527
Go 标记 Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个标记组成： fmt.Println("Hello, World!") 6 个标记是(每行一个)： 1. fmt 2. . 3. Println 4. ( 5. "Hello, World!" 6. ) 行分隔符 在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C...
go语言学习
leeld的博客
01-30 1166
go语言学习（二） 一、go程序开发注意事项 、go源文件以“.go”为扩展名； 、go应用程序的执行入口是main（）函数（和其他语言一样）； 、go语言严格区分大小写； 、go方法由一条条语句构成，每个语句后面不要加分号（go语言会在每行后自动加分号），这也体现出golang的简洁性； go编译器是一行一行进行编译的，因此我们一行就写一条语句，不能把多条语句放在同一行，否则报错； go的定义变量或者import的包如果没有使用到，代码不能编译通过； 大括号都是成对出现，缺一不可； .
Go语言学习笔记.pdf 共174页
04-11
Go语言学习笔记.pdf 共174页是一本关于Go语言的详细学习笔记，涵盖了Go语言的基础知识、函数、数组、Maps、Structs、接口、并发、程序结构、标准库等方面的内容。本笔记共分为三大部分：Go语言基础、标准库和扩展库...
Go语言圣经，golang学习入门到精通
09-07
Go语言，又称Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的语言。它旨在提高编程效率，简化并发编程，并强调简洁的编程哲学。Go语言的设计受到了多门经典编程语言的影响，如C语言、...
学习 Go 语言(Golang)
01-26
总之，“学习 Go 语言(Golang).pdf”这份文档应该是一个全面的指南，涵盖了从入门到进阶的所有关键知识点，帮助你快速掌握 Go 语言并能应用于实际开发中。通过系统学习，你将能够理解 Go 语言的核心理念，并具备使用...
GO 语言学习辅导共220页.pdf
04-13
《GO 语言学习辅导》是一本全面介绍Go语言的教程，共计220页，涵盖了从基础到进阶的各种主题。本教程旨在帮助初学者快速掌握Go语言，并深入理解其在网络编程中的应用。 第一章介绍了Go语言的安装与配置。首先，讲解...
Go语言学习笔记.pdf
12-30
Go语言是一种开源编程语言，具有简单易学、高性能、跨平台等特性，目前已经成为构建高效、可靠的应用程序的重要选择。Go语言在计算机编程领域的重要性不断提升，特别是在云平台、分布式系统和并发处理等领域。为了...
Go语言学习之路——Go语言简介
yufengzxj
06-30 441
Go 拥有 C/C++ 一样的高性能，Java 一样的超高效并发处理，Python/Perl 一样的有趣语法。现在就开始你的Go语言学习之旅吧！人生苦短，let’s Go.
GO语言学习之路
xiaoyanboke的博客
12-14 689
第一个GO程序 首先安装Go语言，配置环境变量等 编辑器：推荐使用VSCODE（免费），避免使用破解版软件 目录结构 bin：编译后的二进制文件 pkg：编译后的库文件 src：源码文件 –网站域名 ---------作者/机构 -------------------项目1 --------------------------------模块 .转自b站李文周老师视频go语言系列视频 如图新建目录，main.go作为程序入口 内容如下： package main import "fmt" func
GO 学习之路
极致，细节
09-11 469
Go 简介 Go（又称Golang）是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。 罗伯特·格瑞史莫，罗勃·派克（Rob Pike）及肯·汤普逊于2007年9月开始设计Go，稍后 Ian Lance Taylor、Russ Cox加入项目。 Go是基于Inferno操作系统所开发的。 Go于2009年11月正式宣布推出，成为开放源代码项目，支持Linux、Mac OS X、Windows等操作系统。 Go在2016...
go语言学习 一
Hanani_Jia的博客
01-18 668
Go语言学习 1.包 每个go语言程序都是由包来构成的，程序从main包开始运行， package main import (     "fmt"     "math/rand" ) func main() {     fmt.Println("My favorite number is", rand.Intn(10)) } 每个程序都是从main包开始运行的，这个程序我们引...
go 学习之路 (一)
Cherry_Lover的博客
01-15 241
GO是什么 这个模块等我能用go语言实现一些功能模块再来完成吧 安装集成开发环境 sdk + Goland安装包链接 安装过程及方法参考菜鸟教程 第一个go程序(hello.go) /*定义包名称main：每个源文件非注释行的第一行必须指明这个文件属于哪个包；且每个go应用程序都包含一个名为main的包*/ package main /*引入包：这个包包含了后面程序要用的函数或其他元素*/ im...
go语言学习【一】
qq_64191695的博客
01-23 977
Go语言基础知识 go语言既有c静态语言程序的运行速度，又能达到Python动态语言的快速开发。这是一门简洁高效的编程语言。 （一）Go语言的发展方向 golang学习方向： 区块链研发工程师 go服务器端 / 游戏软件工程师 golang分布式 / 云计算软件工程师 golang应用领域: 区块链应用开发 后端服务器应用 云计算 / 云服务后台应用 （二）Go语言的基本框架 1. 包 //go语言的每一个文件都要归属于一个包 package main //表明文件所在的包是main 2.引用包
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值