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

Posted 2021-12-29 鸿渐之翼

Go语言简介：

作为一个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]int1, 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]float321000.0, 2.0, 3.4, 7.0, 50.0

balance := [5]float321000.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]float321000.0, 2.0, 3.4, 7.0, 50.0

   /* 输出数组元素 */         ...
   for i = 0; i < 5;以上是关于我的Go+语言初体验——Go语言总结篇（语法+实际问题解决方案）的主要内容，如果未能解决你的问题，请参考以下文章
 
 我的Go+语言初体验——Go+ 基本语法之 Switch
 我的Go+语言初体验——环境搭建篇（直男程序员的真实体验）
 我的Go+语言初体验——GoPlus基础语法学习
 我的Go+语言初体验——GoPlus基础语法学习
 我的Go+语言初体验——GoPlus基础语法学习
 我的Go+语言初体验——GoPlus基础语法学习