Artikel yang menganalisis secara ringkas kawalan proses di Golang

Artikel ini akan mengajar anda tentang Golang dan bercakap tentang kawalan proses dalam asas bahasa Go. Saya harap ia akan membantu anda.

Kawalan proses asas bahasa Go terutamanya termasuk kandungan berikut:

• Pernyataan bersyarat jika
• Suis pernyataan bersyarat
• Pilih pernyataan bersyarat
• Penyataan gelung untuk
• Julat pernyataan gelung
• Kawalan gelung Goto, Break, Continue

[Pengaturcaraan tutorial disyorkan:Pengajaran Pengaturcaraan】

1. Pernyataan bersyarat jika

Format if penghakiman bersyarat dalam Bahasa Go adalah seperti berikut :

if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

前端的同学想必对js相对熟悉，相对于js来说，go表达式去掉了括号（）, tetapi pada masa yang sama beberapa kekangan diberikan if padanan { mesti diletakkan pada baris yang sama dengan if和表达式 . Meletakkan { pada kedudukan lain akan Mencetuskan ralat kompilasi. Dengan cara yang sama, else yang sepadan dengan { juga mesti ditulis pada baris yang sama dengan else dan else juga mesti berada pada baris yang sama dengan pendakap di sebelah kanan if sebelumnya. atau else if.

x := 0

// if x > 10        // Error: missing condition in if statement
// {
// }

if n := "abc"; x > 0 {     // 初始化语句未必就是定义变量， 如 println("init") 也是可以的。
    println(n[2])
} else if x < 0 {    // 注意 else if 和 else 左大括号位置。
    println(n[1])
} else {
    println(n[0])
}



 *不支持三元操作符(三目运算符) "a > b ? a : b"。
 
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

2. Suis pernyataan bersyarat

Pernyataan suis digunakan untuk melakukan tindakan yang berbeza berdasarkan keadaan yang berbeza unik , uji satu persatu dari atas ke bawah sehingga sepadan. Ungkapan cawangan suis Golang boleh terdiri daripada sebarang jenis, tidak terhad kepada pemalar. rehat boleh ditinggalkan dan ditamatkan secara automatik secara lalai.

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

3 Pernyataan bersyarat pilih

Pernyataan pilih adalah serupa dengan pernyataan suis, tetapi pilih akan melaksanakan kes boleh jalan secara rawak. . Jika tiada kes untuk dijalankan, ia akan menyekat sehingga ada kes untuk dijalankan.

pilih ialah struktur kawalan dalam Go, serupa dengan pernyataan suis yang digunakan untuk komunikasi. Setiap kes mestilah operasi komunikasi, sama ada menghantar atau menerima. pilih secara rawak melaksanakan kes boleh dijalankan. Jika tiada kes untuk dijalankan, ia akan menyekat sehingga ada kes untuk dijalankan. Klausa lalai hendaklah sentiasa boleh dijalankan.

Yang berikut menerangkan sintaks penyataan pilih:

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



以上代码执行结果为：

 no communication

pilih boleh memantau aliran data saluran

Penggunaan pilih sangat serupa kepada sintaks suis Pada permulaan blok pemilihan baharu, setiap syarat pemilihan diterangkan oleh pernyataan kes

Berbanding dengan pernyataan suis yang boleh memilih sebarang syarat menggunakan perbandingan kesamaan, pilih mempunyai banyak sekatan, yang terbesar. yang mana setiap pernyataan kes mestilah operasi IO

 select { //不停的在这里检测
    case <-chanl : //检测有没有数据可以读
    //如果chanl成功读取到数据，则进行该case处理语句
    case chan2 <- 1 : //检测有没有可以写
    //如果成功向chan2写入数据，则进行该case处理语句


    //假如没有default，那么在以上两个条件都不成立的情况下，就会在此阻塞//一般default会不写在里面，select中的default子句总是可运行的，因为会很消耗CPU资源
    default:
    //如果以上都没有符合条件，那么则进行default处理流程
    }

Dalam pernyataan pilih, Go akan menilai setiap penyata hantar dan terima mengikut urutan dari awal hingga akhir.

Jika mana-mana pernyataan boleh terus dilaksanakan (iaitu, ia tidak disekat), kemudian pilih mana-mana satu kenyataan yang boleh dilaksanakan untuk digunakan. Jika tiada pernyataan boleh dilaksanakan (iaitu, semua saluran disekat), maka terdapat dua situasi yang mungkin: ① Jika pernyataan lalai diberikan, proses lalai akan dilaksanakan, dan pelaksanaan program akan bermula selepas pernyataan pilih kenyataan. ② Jika tiada pernyataan lalai, pernyataan pilihan akan disekat sehingga sekurang-kurangnya satu kes boleh diteruskan.

Penggunaan biasa - pertimbangan tamat masa

//比如在下面的场景中，使用全局resChan来接受response，如果时间超过3S,resChan中还没有数据返回，则第二条case将执行
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) {
   //...
}

4 Penyataan gelung untuk

dan Seperti jika, berbanding dengan js, ​​gelung untuk bahasa go juga membuang kurungan (), dan tidak banyak perbezaan dalam aspek lain.

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


以上实例运行输出结果为:

    a 的值为: 0
    a 的值为: 1
    a 的值为: 2
    a 的值为: 3
    a 的值为: 4
    a 的值为: 5
    a 的值为: 6
    a 的值为: 7
    a 的值为: 8
    a 的值为: 9
    a 的值为: 1
    a 的值为: 2
    a 的值为: 3
    a 的值为: 4
    a 的值为: 5
    a 的值为: 6
    a 的值为: 7
    a 的值为: 8
    a 的值为: 9
    a 的值为: 10
    a 的值为: 11
    a 的值为: 12
    a 的值为: 13
    a 的值为: 14
    a 的值为: 15
    第 0 位 x 的值 = 1
    第 1 位 x 的值 = 2
    第 2 位 x 的值 = 3
    第 3 位 x 的值 = 5
    第 4 位 x 的值 = 0
    第 5 位 x 的值 = 0

5 Julat pernyataan gelung

Julat Golang adalah serupa dengan operasi lelaran, pengembalian (indeks, nilai) atau ( kunci, nilai).

Format julat gelung for boleh berulang pada kepingan, peta, tatasusunan, rentetan, dsb. Formatnya adalah seperti berikut:

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

package main

func main() {
    s := "abc"
    // 忽略 2nd value，支持 string/array/slice/map。
    for i := range s {
        println(s[i])
    }
    // 忽略 index。
    for _, c := range s {
        println(c)
    }
    // 忽略全部返回值，仅迭代。
    for range s {

    }

    m := map[string]int{"a": 1, "b": 2}
    // 返回 (key, value)。
    for k, v := range m {
        println(k, v)
    }
}

输出结果：

    97
    98
    99
    97
    98
    99
    a 1
    b 2

Apakah perbezaan antara untuk dan untuk julat?

Sebab utamanya ialah senario penggunaan adalah berbeza

kerana boleh merentasi tatasusunan dan menghiris, dan kekunci traversal ialah Integer meningkatkan peta, merentas rentetan

untuk julat boleh melakukan semua perkara yang boleh dilakukan, tetapi ia boleh melakukan apa yang tidak boleh dilakukan, termasuk melintasi a peta dengan kunci jenis rentetan dan mendapatkan kunci serta nilai pada masa yang sama, merentasi saluran

6 Kawalan gelung Goto, Break, Continue

Pernyataan kawalan gelung.

Pernyataan kawalan gelung boleh mengawal proses pelaksanaan pernyataan dalam badan gelung.

Bahasa GO menyokong pernyataan kawalan gelung berikut:

Goto, Break, Continue

    1.三个语句都可以配合标签(label)使用
    2.标签名区分大小写，定以后若不使用会造成编译错误
    3.continue、break配合标签(label)可用于多层循环跳出
    4.goto是调整执行位置，与continue、break配合标签(label)的结果并不相同

break(跳出循环): Pernyataan continue (teruskan gelung seterusnya) break boleh menamatkan blok kod for, switch dan select. Pernyataan break juga boleh menambah label selepas pernyataan untuk menunjukkan keluar dari blok kod yang sepadan dengan label tertentu Keperluan label mesti ditakrifkan pada blok kod for, switch dan select yang sepadan.

continue(继续下次循环)：continue语句可以结束当前循环，开始下一次的循环迭代过程，仅限在for循环内使用。在 continue语句后添加标签时，表示开始标签对应的循环

goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：

func gotoDemo1() {
	var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				breakFlag = true
				break
			}
			fmt.Printf("%v-%v\n", i, j)
		}
		// 外层for循环判断
		if breakFlag {
			break
		}
	}
}

使用goto语句能简化代码：

func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")
}

结束:

再次提醒，需要进技术交流群的同学，可以加我微信fangdongdong_25,需要进前端工程师交流群的备注“前端”，需要进go后端交流群的备注“go后端”

【相关推荐：Go视频教程】

Atas ialah kandungan terperinci Artikel yang menganalisis secara ringkas kawalan proses di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!