我的Go+语言初体验——Go语言总结篇（语法+实际问题解决方案）

Go语言简介：

Go 语言教程Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。 Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发
作为一个C语言之父发明的Go语言，它在未来各个领域运用广，其语法特征与C语言相近，更加灵活。

Goland

Goland是Jetbrains家族的系列商业版本ide
下载地址：Goland

LiteIDE

开源go语言IDE
源码地址：Github

下载地址：
LiteIDE

Eclipse：

安装插件：
下载goclips插件 https://github.com/GoClipse/goclipse/blob/latest/documentation/Installation.md#installation
配置插件
Windows->Reference->Go
(1)、配置 Go 的编译器

设置 Go 的一些基础信息

(2)、配置 Gocode（可选，代码补全），设置 Gocode 路径为之前生成的 gocode.exe 文件

设置 gocode 信息

(3)、配置 GDB（可选，做调试用），设置 GDB 路径为 MingW 安装目录下的 gdb.exe 文件

测试是否成功
新建一个 go 工程，再建立一个 hello.go。如下图：

新建项目编辑文件

调试如下（要在 console 中用输入命令来调试）：

快速进入Go语言语法学习：

Go语言条件语句

快速预览本文：Go语言独特的语句是select
条件语句运行结构

if语句

if 布尔表达式{
    
    
...
}

实例：

package main

import "fmt"

func main() {
    
    
   /* 定义局部变量 */
   var a int = 6
 
   /* 使用 if 语句判断布尔表达式 */
   if a < 10 {
    
    
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a小于10\n" )
   }
   fmt.Printf("a 的值为:%d\n", a)
}

if…else语句

if 布尔表达式 {
    
    
   /* 在布尔表达式为 true 时执行 */
} else {
    
    
  /* 在布尔表达式为 false 时执行 */
}

实例：

package main

import "fmt"

func main() {
    
    
   /* 局部变量定义 */
   var a int = 100;
   /* 判断布尔表达式 */
   if a < 10 {
    
    
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于10\n" );
   } else {
    
    
       /* 如果条件为 false 则执行以下语句 */
       fmt.Printf("a 不小于10\n" );
   }
   fmt.Printf("a 的值:%d\n", a);
}

if嵌套语句

if 布尔表达式 1 {
    
    
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
    
    
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

实例：

package main

import "fmt"

func main() {
    
    
   /* 定义局部变量 */
   var a int = 1
   var b int = 2
 
   /* 判断条件 */
   if a == 1 {
    
    
       /* if 条件语句为 true 执行 */
       if b == 2 {
    
    
          /* if 条件语句为 true 执行 */
          fmt.Printf("a 的值为1，b的值为2\n" );
       }
   }
   fmt.Printf("a 值为 : %d\n", a );
   fmt.Printf("b 值为 : %d\n", b );
}

switch语句

流程图：

switch var1 {
    
    
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

实例：

package main

import "fmt"

func main() {
    
    
   /* 定义局部变量 */
   var grade string = "B"
   var marks int = 90

   switch marks {
    
    
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

   switch {
    
    
      case grade == "A" :
         fmt.Printf("A!\n" )    
      case grade == "B", grade == "C" :
         fmt.Printf("B\n" )      
      case grade == "D" :
         fmt.Printf("C\n" )      
      case grade == "F":
         fmt.Printf("F\n" )
      default:
         fmt.Printf("fighting\n" );
   }
   fmt.Printf("your score: %s\n", grade );      
}

Go语言循环语句

循环语句流程图

for循环

for循环流程图

实例一：

package main

import "fmt"

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

实例二：

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)
}

实例三：for与range循环

package main
import "fmt"

func main() {
    
    
        strings := []string{
    
    "hello", "worl"}
        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)
        }  
}

select语句

伪代码：

select {
    
    
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

实例：

package main

import "fmt"

func main() {
    
    
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
    
    
      case a1 = <- b1:
         fmt.Printf("received ", a1, " from b1\n")
      case b2 <- a2:
         fmt.Printf("sent ", a2, " to b2\n")
      case a3, ok := (<-a3):  // same as: a3, ok := <-b3
         if ok {
    
    
            fmt.Printf("received ", a3, " from c3\n")
         } else {
    
    
            fmt.Printf("b3 is closed\n")
         }
      default:
         fmt.Printf("no communication\n")
   }    
}

Go语言函数

伪代码：

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

实例1：

func function(num1, num2 int) int {
    
    
   /* 声明局部变量 */
   var result int

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

函数调用

实例2:

package main

import "fmt"

func main() {
    
    
   /* 定义局部变量 */
   var a int = 100
   var b int = 100
   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
}

函数返回多个值

实例3：

package main

import "fmt"

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

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

Go语言函数参数——值传参

实例4：

/* 定义相互交换值的函数 */
func swap(x, y int) int {
    
    
   var temp int

   temp = x /* 保存 x 的值 */
   x = y    /* 将 y 值赋给 x */
   y = temp /* 将 temp 值赋给 y*/

   return temp;
}

Swap函数
实例5：

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, b)

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

/* 定义相互交换值的函数 */
func swap(x, y int) int {
    
    
   var temp int

   temp = x /* 保存 x 的值 */
   x = y    /* 将 y 值赋给 x */
   y = temp /* 将 temp 值赋给 y*/

   return temp;
}

Go 语言函数引用传递值

实例6：

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 */
}

Go 语言函数作为另外一个函数的实参

实例7：

package main
import "fmt"

// 声明一个函数类型
type cb func(int) int

func main() {
    
    
    testCallBack(1, callBack)
    testCallBack(2, func(x int) int {
    
    
        fmt.Printf("我是回调，x：%d\n", x)
        return x
    })
}

func testCallBack(x int, f cb) {
    
    
    f(x)
}

func callBack(x int) int {
    
    
    fmt.Printf("我是回调，x：%d\n", x)
    return x
}

Go语言闭包

闭包是匿名函数，可在动态编程中使用

package main

import "fmt"

func getSequence() func() int {
    
    
   i:=0
   return func() int {
    
    
      i+=1
     return i  
   }
}

func main(){
    
    
   /* nextNumber 为一个函数，函数 i 为 0 */
   nextNumber := getSequence()  

   /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   
   /* 创建新的函数 nextNumber1，并查看结果 */
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}

Go 语言函数方法

package main

import (
   "fmt"  
)

/* 定义结构体 */
type Circle struct {
    
    
  radius float64
}

func main() {
    
    
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("圆的面积 = ", c1.getArea())
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
    
    
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

Go语言变量作用域

函数内定义的变量称为局部变量
函数外定义的变量称为全局变量
函数定义中的变量称为形式参数

局部变量

package main

import "fmt"

func main() {
    
    
   /* 声明局部变量 */
   var a, b, c int

   /* 初始化参数 */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("结果： a = %d, b = %d and c = %d\n", a, b, c)
}

全局变量

package main

import "fmt"

/* 声明全局变量 */
var g int

func main() {
    
    

   /* 声明局部变量 */
   var a, b int

   /* 初始化参数 */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}

形式参数

package main

import "fmt"

/* 声明全局变量 */
var a int = 20;

func main() {
    
    
   /* main 函数中声明局部变量 */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("main()函数中 a = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("main()函数中 c = %d\n",  c);
}

/* 函数定义-两数相加 */
func sum(a, b int) int {
    
    
   fmt.Printf("sum() 函数中 a = %d\n",  a);
   fmt.Printf("sum() 函数中 b = %d\n",  b);

   return a + b;
}

初始化局部和全局变量

Go语言数组

声明数组

var variable_name [SIZE] variable_type

var balance [10] float32

初始化数组

几种go语言初始化数组的方式

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

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

访问数组元素

实例1

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] )
   }
}

实例2：

package main

import "fmt"

func main() {
    
    
   var i,j,k int
   // 声明数组的同时快速初始化数组
   balance := [5]float32{
    
    1000.0, 2.0, 3.4, 7.0, 50.0}

   /* 输出数组元素 */         ...
   for i = 0; i < 5; i++ {
    
    
      fmt.Printf("balance[%d] = %f\n", i, balance[i] )
   }
   
   balance2 := [...]float32{
    
    1000.0, 2.0, 3.4, 7.0, 50.0}
   /* 输出每个数组元素的值 */
   for j = 0; j < 5; j++ {
    
    
      fmt.Printf("balance2[%d] = %f\n", j, balance2[j] )
   }

   //  将索引为 1 和 3 的元素初始化
   balance3 := [5]float32{
    
    1:2.0,3:7.0}  
   for k = 0; k < 5; k++ {
    
    
      fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
   }
}

Go 语言指针

下面例子演示了变量在内存中地址：

package main

import "fmt"

func main() {
    
    
   var a int = 10  

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

什么是指针

一个指针变量指向了一个值的内存地址。

var var_name *var-type

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

如何使用指针

1.定义指针变量。
2.为指针变量赋值。
3.访问指针变量中指向地址的值
实例1：

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 )
}

Go 空指针

实例2：

package main

import "fmt"

func main() {
    
    
   var  ptr *int

   fmt.Printf("ptr 的值为 : %x\n", ptr  )
}

Go语言指针数组

实例1：*

package main

import "fmt"

const MAX int = 3

func main() {
    
    

   a := []int{
    
    10,100,200}
   var i int

   for i = 0; i < MAX; i++ {
    
    
      fmt.Printf("a[%d] = %d\n", i, a[i] )
   }
}

实例2：

package main

import "fmt"

const MAX int = 3

func main() {
    
    
   a := []int{
    
    10,100,200}
   var i int
   var ptr [MAX]*int;

   for  i = 0; i < MAX; i++ {
    
    
      ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
   }

   for  i = 0; i < MAX; i++ {
    
    
      fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
   }
}

Go 语言指针作为函数参数

实例程序：

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 )

   /* 调用函数用于交换值
   * &a 指向 a 变量的地址
   * &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 */
}

实例2：

package main

import "fmt"

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

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

/* 交换函数这样写更加简洁，也是 go 语言的特性，可以用下，c++ 和 c# 是不能这么干的 */
 
func swap(x *int, y *int){
    
    
    *x, *y = *y, *x
}

Go语言结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。Go语言结构体与C语言相似伪代码如下参考：

定义结构体

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

实例：

package main

import "fmt"

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


func main() {
    
    


    fmt.Println(Books{
    
    "hello", "hello", "Hello", 123456})


    fmt.Println(Books{
    
    title: "Go language", author: "hello world", subject: "Go ", book_id: 12345678})


   fmt.Println(Books{
    
    title: "Go language", author: "hello world"})
}

访问结构体成员

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 类型 */


   Book1.title = "Go language"
   Book1.author = "hello world"
   Book1.subject = "Go langugage"
   Book1.book_id = 100000


   Book2.title = "C"
   Book2.author = "hello world"
   Book2.subject = "C language"
   Book2.book_id = 200000


   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)


   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)
}

结构体指针

Go语言结构体指针定义伪码：

var struct_pointer *Books
struct_pointer = &Book1
struct_pointer.title

实例：

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 类型 */


   Book1.title = "Go"
   Book1.author = "hello world"
   Book1.subject = "Go language"
   Book1.book_id = 123456

   Book2.title = "C"
   Book2.author = "hello world"
   Book2.subject = "C language"
   Book2.book_id = 1234567


   printBook(&Book1)


   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 语言切片是对数组的抽象。

定义切片

声明切片：

var identifier []type
var slice1 []type = make([]type, len)
slice1 := make([]type, len)
make([]T, length, capacity)

切片初始化

s :=[] int {
    
    1,2,3 } 
s := arr[:] 
s := arr[startIndex:endIndex] 
s := arr[startIndex:] 
s := arr[:endIndex] 
s1 := s[startIndex:endIndex] 
s :=make([]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)
}

空(nil)切片

实例：

package main

import "fmt"

func main() {
    
    
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
    
    
      fmt.Printf("切片是空的")
   }
}

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

切片截取

实例：

package main

import "fmt"

func main() {
    
    
   /* 创建切片 */
   numbers := []int{
    
    0,1,2,3,4,5,6,7,8}  
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

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

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)
}

Go 语言范围(Range)

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。

实例：

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)
    }
}

Go 语言Map(集合)

定义 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)

实例：

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])
    }

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) {
    
    
        fmt.Println("American 的首都是", capital)
    } else {
    
    
        fmt.Println("American 的首都不存在")
    }
}

delete() 函数

package 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 ])
        }
}

Go 语言递归函数

伪代码：

func recursion() {
    
    
   recursion() /* 函数调用自身 */
}

func main() {
    
    
   recursion()
}

实现阶乘

实例：

package main

import "fmt"

func Factorial(n uint64)(result uint64) {
    
    
    if (n > 0) {
    
    
        result = n * Factorial(n-1)
        return result
    }
    return 1
}

func main() {
    
      
    var i int = 15
    fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
}

斐波那契数列

实例：

package main

import "fmt"

func fibonacci(n int) int {
    
    
  if n < 2 {
    
    
   return n
  }
  return fibonacci(n-2) + fibonacci(n-1)
}

func main() {
    
    
    var i int
    for i = 0; i < 10; i++ {
    
    
       fmt.Printf("%d\t", fibonacci(i))
    }
}

Go 语言类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式如下：

type_name(expression)

实例：

package main

import "fmt"

func main() {
    
    
   var sum int = 17
   var count int = 5
   var mean float32
   
   mean = float32(sum)/float32(count)
   fmt.Printf("mean 的值为: %f\n",mean)
}

Go 语言接口

Go 语言提供了另外一种数据类型即接口
实例1：

/* 定义接口 */
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] {
    
    
   /* 方法实现*/
}

实例2：

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()

}

Go 错误处理

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
errors.new类型是一个接口：

type error interface {
    
    
    Error() string
}

我们可以使用errors.new 返回错误信息：

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

实例1：

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

Go语言并发与通道的运用

在go语言中我们可以使用goroutine 开启并发。
goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。
goroutine 语法格式：
go 函数名( 参数列表 )
实例1：

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")
}

输出结果：

world
hello
hello
world
world
hello
hello
world
world
hello

我们通过以上程序发现输出结果是没有顺序的

通道（channel）

通道（channel）是用来传递数据的一个数据结构。
实例2：

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

通道缓冲区

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

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 遍历通道与关闭通道

实例4：

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语言：解决main.go:2:7: expected ‘STRING‘, found ‘{‘问题最佳方案
请欣赏错误代码操作

由于以前写c代码的习惯，经常使用{}正确写法将{}改成（）圆括号