go编程基础(2)

函数

函数定义:函数是基本的代码块，用于执行一个任务。Go 语言最少有个 main() 函数。你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。函数声明告诉了编译器函数的名称，返回类型，和参数。

函数定义的格式如下

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

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

实例:

以下实例为 sum() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数之和

/* 函数返回两个数之和 */
func sum(num1, num2 int) int {
   /* 声明局部变量 */
   result=num1+num2
   return result
}

函数调用实例:

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int = 200
   var ret int
   /* 调用函数并返回两数之和 */
   ret = sum(a, b)
   fmt.Printf( "两数之和为 : %d\n", ret )
}

/* 函数返回两个数之和 */
func sum(num1, num2 int) int {
   /* 定义局部变量 */
   var result int
   result=num1+num2
   return result
}

//输出结果为: "两数之和为 : 300"

条件语句

if...else语句:

语法如下

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

实例:使用if...else语句判断a的大小

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

switch语句:

1.switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。

2.switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。

3.switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。

switch语句语法如下

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

//变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
//您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

实例:使用switch语句判断分数等级

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

select语句:

1.select 是 Go 中的一个控制结构，类似于 switch 语句。

2.select 语句只能用于通道操作，每个 case 必须是一个通道操作，要么是发送要么是接收。

3.select 语句会监听所有指定的通道上的操作，一旦其中一个通道准备好就会执行相应的代码块。

如果多个通道都准备好，那么 select 语句会随机选择一个通道执行。如果所有通道都没有准备好，那么执行 default 块中的代码。

select语句语法格式如下:

select {
  case <- channel1:
    // 执行的代码
  case value := <- channel2:
    // 执行的代码
  case channel3 <- value:
    // 执行的代码

    // 你可以定义任意数量的 case

  default:
    // 所有通道都没有准备好，执行的代码
}

//每个 case 都必须是一个通道
//所有 channel 表达式都会被求值
//所有被发送的表达式都会被求值
//如果任意某个通道可以进行，它就执行，其他被忽略。
//如果有多个 case 都可以运行，select 会随机公平地选出一个执行，其他不会执行。
//否则：如果有 default 子句，则执行该语句。如果没有 default 子句，select 将阻塞，直到某个通道可以运行；Go 不会重新对 channel 或值进行求值。

实例:使用select语句从通道中获取数据

package main

import "fmt"

func main() {
  // 定义两个通道
  ch1 := make(chan string)
  ch2 := make(chan string)

  // 启动两个 goroutine，分别从两个通道中获取数据
  go func() {
    for {
      ch1 <- "from 1"
    }
  }()
  go func() {
    for {
      ch2 <- "from 2"
    }
  }()

  // 使用 select 语句非阻塞地从两个通道中获取数据
  for {
    select {
    case msg1 := <-ch1:
      fmt.Println(msg1)
    case msg2 := <-ch2:
      fmt.Println(msg2)
    default:
      // 如果两个通道都没有可用的数据，则执行这里的语句
      fmt.Println("no message received")
    }
  }
}

循环语句

for循环

//g0语言for循环有以下三种形式

for init; condition; post { }

for condition { }

for { }

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

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

//or 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环

实例

//计算 1 到 10 的数字之和：
package main

import "fmt"

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

//输出结果为 55

break

• 用于循环语句中跳出循环，并开始执行循环之后的语句。
• break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
• 在多重循环中，可以用标号 label 标出想 break 的循环。

实例:在a为15的时候跳出循环

package main

import "fmt"

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

   /* for 循环 */
   for a < 20 {
      fmt.Printf("a 的值为 : %d\n", a);
      a++;
      if a > 15 {
         /* 使用 break 语句跳出循环 */
         break;
      }
   }
}

接口

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

并发

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的.

语法格式如下:

go 函数名( 参数列表 )

实例:

两个 goroutine同时执行,一个执行say("world")另一个执行say("hello")

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