Go語言基礎(chǔ)四

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

if定義

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

單層if語法格式

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

    if 布爾表達(dá)式 {
    /* 在布爾表達(dá)式為 true 時執(zhí)行 */
    }  

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

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

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

語法警告

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

package main
?
import "fmt"
?
func main() {
   /* 定義局部變量 */
   var a int = 10
   /* 使用 if 語句判斷布爾表達(dá)式 */
   if a < 20 {
       /* 如果條件為 true 則執(zhí)行以下語句 */
       fmt.Printf("a 小于 20\n" )
   }
   fmt.Printf("a 的值為 : %d\n", a)
}  

上方是關(guān)于if判斷的一個小練習(xí)，讀者自行體會即可；if 在布爾表達(dá)式為 true 時，其后緊跟的語句塊執(zhí)行，如果為 false 則執(zhí)行 else 語句塊。

package main
import "fmt"
func main() {
   /* 局部變量定義 */
   var a int = 100
   /* 判斷布爾表達(dá)式 */
   if a < 20 {
       /* 如果條件為 true 則執(zhí)行以下語句 */
       fmt.Printf("a 小于 20\n" )
   } else {
       /* 如果條件為 false 則執(zhí)行以下語句 */
       fmt.Printf("a 不小于 20\n" )
   }
   fmt.Printf("a 的值為 : %d\n", a)
}

在Go語言中，if語句也支持嵌套處理，即可以實現(xiàn)多重if判斷以達(dá)到程序想要的結(jié)果

多層if語法格式

if 布爾表達(dá)式 1 {
   /* 在布爾表達(dá)式 1 為 true 時執(zhí)行 */
   if 布爾表達(dá)式 2 {
      /* 在布爾表達(dá)式 2 為 true 時執(zhí)行 */
   }
} 

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

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

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

Switch定義

switch 語句用于基于不同條件執(zhí)行不同動作，每一個 case 分支都是唯一的，從上直下逐一測試，直到匹配為止。Golang switch 分支表達(dá)式可以是任意類型，不限于常量。可省略 break，默認(rèn)自動終止。

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("優(yōu)秀!\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進(jìn)行Switch判斷操作，當(dāng)case滿足不同的值的時候，調(diào)用函數(shù)打印輸出的值也不一樣

Type Switch

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

Type Switch語法格式

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

由于Type Switch用途不是特別的多，作者在這里不作詳細(xì)描述，讀者可以去官網(wǎng)自行查詢相關(guān)文檔進(jìn)行學(xué)習(xí)

Select定義

• select 語句類似于 switch 語句，但是select會隨機(jī)執(zhí)行一個可運行的case。如果沒有case可運行，它將阻塞，直到有case可運行。
• select 是Go中的一個控制結(jié)構(gòu)，類似于用于通信的switch語句。每個case必須是一個通信操作，要么是發(fā)送要么是接收。
• select 隨機(jī)執(zhí)行一個可運行的case。如果沒有case可運行，它將阻塞，直到有case可運行。一個默認(rèn)的子句應(yīng)該總是可運行的。

Select語法格式

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

Select語句注意事項

• 每個case都必須是一個通信
• 所有channel表達(dá)式都會被求值
• 所有被發(fā)送的表達(dá)式都會被求值
• 如果任意某個通信可以進(jìn)行，它就執(zhí)行；其他被忽略。
• 如果有多個case都可以運行，Select會隨機(jī)公平地選出一個執(zhí)行。其他不會執(zhí)行。
• 如果有default子句，則執(zhí)行該語句。
• 如果沒有default字句，select將阻塞，直到某個通信可以運行；Go不會重新對channel值重新進(jìn)行求值。

package main
?
import "fmt"
?
func main() {
   var c1, c2, c3 chan int //通道機(jī)制
   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")
   }
}

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

Select用法補(bǔ)充

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

超時判斷

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) {
    //...
}

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

退出

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

我們定義一個var類型的shouldQuit變量用于結(jié)構(gòu)體的通道，首先我們開啟一個select循環(huán)，在case里面調(diào)用通道方法，并且返回所對應(yīng)的值；如果不滿足，則返回default的值。同時我們在另外一個協(xié)程中，如果我們遇到了非法操作或不可處理的錯誤，就向shouldQuit發(fā)送數(shù)據(jù)通知程序停止運行

判斷Channel狀態(tài)

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

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

到此這篇關(guān)于淺析Go語言中Channel的各種用法的文章就介紹到這了,更多相關(guān)Go語言Channel用法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論