Go 语言之基础语法2 ｜ 青训营笔记

TomorroW
75 阅读6分钟

这是我参与「第五届青训营 」伴学笔记创作活动的第 3 天

01. Go 流程

1.1 Go 语言条件语句

条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况再执行另外的语句。 下图展示了程序语言中条件语句的结构：

Go条件语句.jpg

Go 语言提供了以下几种条件判断语句：
  • if 语句

语法如下：

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

If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则不执行。

// 实例
package main

import "fmt"

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

if 语句后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行 if...else 语句语法如下：

语法如下：

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

If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则执行 else 语句块。

package main

import "fmt"

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

对于 if 或 if...else 语句，你还可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句

  • switch 语句 语法如下：
switch var1 {         // 变量 var1 可以是任何类型
    case val1:        // val1 和 val2 则可以是同类型的任意值
        ...
    case val2:        // val1 和 val2 则可以是同类型的任意值
        ...
    default:
        ...
}

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3

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("优秀!\n" )     
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )      
      case grade == "D" :
         fmt.Printf("及格\n" )      
      case grade == "F":
         fmt.Printf("不及格\n" )
      default:
         fmt.Printf("差\n" )
   }
   fmt.Printf("你的等级是 %s\n", grade )     
   /*
   执行结果：
           优秀!
           你的等级是 A
   */
}
  • Type Switch 语句

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

Type Switch 语法格式如下：

switch x.(type){
    case type:
       statement(s)     
    case type:
       statement(s)
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s)
}

1.2 Go 语言循坏语句

以下为大多编程语言循环程序的流程图：

循环语句流程图.png

Go 语言仅提供了一种判断语句: for 循环语句

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

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

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

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

实例如下：

package main

import "fmt"

func main() {

   var b int = 15
   var a int

   numbers := [6]int{1, 2, 3, 5} 

   /* for 循环 */
   for a := 0; a < 10; a++ {
      fmt.Printf("a 的值为: %d\n", a)
   }

   for a < b {
      a++
      fmt.Printf("a 的值为: %d\n", a)
      }

   for i, x:= range numbers {
      fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
   }   
}
  • 循环控制语句 循环控制语句可以控制循环体内语句的执行过程。

GO 语言支持以下几种循环控制语句：

控制语句描述
break 语句经常用于中断当前 for 循环或跳出 switch 语句
continue 语句跳过当前循环的剩余语句，然后继续进行下一轮循环
goto 语句将控制转移到被标记的语句

如果循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环

02. Go语言函数

函数是基本的代码块，用于执行一个任务。

Go 语言最少有1个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的分量个数。

2.1 函数定义

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

func function_name( [parameter list] ) [return_types]{
   函数体
}
  • func： 函数由 func 开始声明
  • function_name： 函数名称，函数名和参数列表一起构成了函数签名。
  • parameter list]： 参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序及参数个数。参数是可选的，也就是说函数也可以不包含参数。
  • return_types： 返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
  • 函数体： 函数定义的代码集合。

上述流程说明时所列举的实例中，均由函数组成，此部分就不举例说明。若读者还不清楚，请自行向上翻页查看前面实例。

2.2 函数调用

当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。

调用函数，向函数传递参数，并返回值，例如：

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 
}

在这个实例中，我们首先定义程序所需要的局部变量，之后声明了求最大值的函数func max(num1, num2 int) int，ret 用来接收函数的返回值并输出 ret 的值，从而实现了求最大值这一功能。

上述例子中，函数返回值只有一个，Go 函数可以返回多个值。例如：

package main

import "fmt"

/* 交换 x, y 的值 */
func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Mahesh", "Kumar")
   /* 执行结果：Kumar Mahesh */   
   fmt.Println(a, b)
}

2.3 defer 语句

  • Go语言中的 defer 语句会将其后面跟随的语句进行延迟处理
  • 在 defer 所属的函数即将返回时，将延迟处理的语句按照 defer 定义的顺序逆序执行，即先进后出
package main

import "fmt"

func main() {
	fmt.Println("开始")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("结束")
        /*
            执行结果：
              开始
              结束
              3
              2
              1
        */
}

总而言之，Go 语言在流程和函数方面与其他语言没有什么本质上的区别，尤其是C语言，除了循环语句之外，其余几乎大同小异。其实，Go 语言是一种类C的高级语言，被描述为“ C 类似语言”，或者是“21世纪的 C 语言”。 Go 从 C 语言继承了相似的表达式语法、控制流结构、基础数据类型、调用参数传值、指针等很多思想，还有 C 语言一直所看中的编译后机器码的运行效率以及和现有操作系统的无缝适配。

avatar
文章
阅读
粉丝