日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

淺析Go語言中Channel的各種用法_Golang

作者：掘金小逆 ? 更新時間： 2022-12-23 編程語言

Go語言基礎四

今天我們要來學習if語句，也就是大家口中的判斷語句，我們首先來看一下if語句的定義

if定義

條件語句需要開發者通過指定一個或多個條件，并通過測試條件是否為 true 來決定是否執行指定語句，并在條件為 false 的情況在執行另外的語句。相信讀者看到這兒，也是云里霧里的感覺，我們怎么來表示true和false呢？

單層if語法格式

  • 可省略條件表達式括號。
  • 持初始化語句，可定義代碼塊局部變量。?
  • 代碼塊左 括號必須在條件表達式尾部。

? ? if 布爾表達式 {
? ? /* 在布爾表達式為 true 時執行 */
? ? } ?

這里要為讀者介紹的是，如果if后面的條件語句程序給出的數能夠滿足，則我們表示為true；如果不能，則返回false

package main
?
import "fmt"
?
func main() {
   a := 3
   if a > 2 {
      fmt.Println("true")
   } else {
      fmt.Println("false")
   }
}

如代碼塊所示，這里我們定義了一個變量a的值為3，接下來是一個if判斷，如果該數值>2，則調用函數打印輸出true；否則返回false。換句話說，我們這里即是對a變量的一個判斷，至于調用函數打印輸出的內容，由讀者自行決定

語法警告

在Go語法中，不支持三元操作符(三目運算符) a > b ? a : b，如果讀者對三元運算符較感興趣，可以移步至java了解三元運算符（其本質上也是一種if判斷形式）

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

上方是關于if判斷的一個小練習，讀者自行體會即可；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)
}

在Go語言中，if語句也支持嵌套處理，即可以實現多重if判斷以達到程序想要的結果

多層if語法格式

if 布爾表達式 1 {
? ?/* 在布爾表達式 1 為 true 時執行 */
? ?if 布爾表達式 2 {
? ? ? /* 在布爾表達式 2 為 true 時執行 */
? ?}
}?

package main
?
import "fmt"
?
func main() {
   /* 定義局部變量 */
   var a int = 100
   var b int = 200
   /* 判斷條件 */
   if a == 100 {
       /* if 條件語句為 true 執行 */
       if b == 200 {
          /* if 條件語句為 true 執行 */
          fmt.Printf("a 的值為 100 ， b 的值為 200\n" )
       }
   }
   fmt.Printf("a 值為 : %d\n", a )
   fmt.Printf("b 值為 : %d\n", b )
}

如上圖所示，我們在if語句里面嵌套了另一個if語句，即是在默認a == 100的情況下寫出對變量b的值的判斷，最終調用函數打印輸出a和b的值

有時候我們多個變量匹配同一個值，就會用到Switch語句

Switch定義

switch 語句用于基于不同條件執行不同動作，每一個 case 分支都是唯一的，從上直下逐一測試，直到匹配為止。Golang switch 分支表達式可以是任意類型，不限于常量?？墒÷?break，默認自動終止。

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("優秀!\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 )
}

由上方代碼塊可知，我們定義了兩個局部變量grade和marks，對marks進行Switch判斷操作，當case滿足不同的值的時候，調用函數打印輸出的值也不一樣

Type Switch

switch 語句還可以被用于 type-switch 來判斷某個 interface 變量中實際存儲的變量類型

Type Switch語法格式

switch x.(type){
    case type:
       statement(s)      
    case type:
       statement(s)
    /* 你可以定義任意個數的case */
    default: /* 可選 */
       statement(s)
}

由于Type Switch用途不是特別的多，作者在這里不作詳細描述，讀者可以去官網自行查詢相關文檔進行學習

Select定義

  • select 語句類似于 switch 語句，但是select會隨機執行一個可運行的case。如果沒有case可運行，它將阻塞，直到有case可運行。
  • select 是Go中的一個控制結構，類似于用于通信的switch語句。每個case必須是一個通信操作，要么是發送要么是接收。
  • select 隨機執行一個可運行的case。如果沒有case可運行，它將阻塞，直到有case可運行。一個默認的子句應該總是可運行的。

Select語法格式

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定義任意數量的 case */
    default : /* 可選 */
       statement(s);
}

Select語句注意事項

  • 每個case都必須是一個通信
  • 所有channel表達式都會被求值
  • 所有被發送的表達式都會被求值
  • 如果任意某個通信可以進行，它就執行；其他被忽略。
  • 如果有多個case都可以運行，Select會隨機公平地選出一個執行。其他不會執行。
  • 如果有default子句，則執行該語句。
  • 如果沒有default字句，select將阻塞，直到某個通信可以運行；Go不會重新對channel值重新進行求值。
package main
?
import "fmt"
?
func main() {
   var c1, c2, c3 chan int //通道機制
   var i1, i2 int
   select {
   case i1 = <-c1:
      fmt.Printf("received ", i1, " from c1\n")
   case c2 <- i2:
      fmt.Printf("sent ", i2, " to c2\n")
   case i3, ok := (<-c3): // same as: i3, ok := <-c3
      if ok {
         fmt.Printf("received ", i3, " from c3\n")
      } else {
         fmt.Printf("c3 is closed\n")
      }
   default:
      fmt.Printf("no communication\n")
   }
}

根據上方代碼所示，定義了c1、c2、c3三個變量，并且使用chan通道。關于寫法的解釋：一個可以發送 int 類型數據的 channel 一般寫為 chan int，根據上方的語法規則：如果有default子句，則執行該語句，故上方代碼塊執行代碼為：no communication

Select用法補充

  • 我們可以使用select來監聽channel的數據流動
  • select的用法與switch語法非常類似，由select開始的一個新的選擇塊，每個選擇條件由case語句來描述
  • switch語句可以選擇任何使用相等比較的條件相比，select由比較多的限制，其中最大的一條限制就是每個case語句里必須是一個IO操作
  • 如果每個 case都未讀取到，則Go語言會自動讀取default語句所描述的東西，在正常情況下，每個select程序都會有一個輸出語句
  • 如果既沒有case語句滿足，也不存在default語句，則程序進入阻塞狀態，系統會發出警告，直至疏通

超時判斷

var resChan = make(chan int)
// do request
func test() {
    select {
    case data := <-resChan:
        doData(data)
    case <-time.After(time.Second * 3):
        fmt.Println("request time out")
    }
}
?
func doData(data int) {
    //...
}

根據上方代碼塊可知，我們定義了一個select語句，在第一條case里面，我們將resChan傳給data，如果在傳輸的過程中時長超過3s，則會執行第二條case語句

退出

var shouldQuit=make(chan struct{})
fun main(){
    {
        //loop
    }
    //...out of the loop
    select {
        case <-c.shouldQuit:
            cleanUp()
            return
        default:
        }
    //...
}
?
//在另外一個協程中，如果運行遇到非法操作或不可處理的錯誤，就向shouldQuit發送數據通知程序停止運行
close(shouldQuit)

我們定義一個var類型的shouldQuit變量用于結構體的通道，首先我們開啟一個select循環，在case里面調用通道方法，并且返回所對應的值；如果不滿足，則返回default的值。同時我們在另外一個協程中，如果我們遇到了非法操作或不可處理的錯誤，就向shouldQuit發送數據通知程序停止運行

判斷Channel狀態

ch := make (chan int, 5)
//...
data：=0
select {
case ch <- data:
default:
}

有時候我們不喜歡緩存變慢，這樣不利于我們去釋放資源，因此我們可以用一個簡單的判斷方法去進行判斷：首先我們開啟一個int類型，長度為5的通道，在通道里面我們開啟一個select循環，如果data通道的值能被ch所接收，則執行該條語句，否則我們可對default語句進行拋棄data等處理操作

原文鏈接：https://juejin.cn/post/7169400353715290142

欄目分類
最近更新