Was sind die Golang-Flusskontrollanweisungen?

Flusskontrollanweisung: 1. if-Anweisung, bestehend aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen; 2. „if...else“-Anweisung, der Ausdruck in else wird ausgeführt, wenn der boolesche Ausdruck falsch ist; switch-Anweisung, die zum Ausführen verschiedener Aktionen basierend auf unterschiedlichen Bedingungen verwendet wird; 5. for-Schleifenanweisung, Syntax „for k,v := range oldmap{newmap[k]=v}“; , weiter, gehe zu.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Werfen wir einen Blick auf den grundlegenden Inhalt von Golang-Flusskontrollanweisungen.

1. Die bedingte Verzweigungsanweisung

ähnelt der C-Sprache. Die zugehörigen bedingten Anweisungen sind in der folgenden Tabelle aufgeführt:

if-Anweisung if…else-Anweisung switch-Anweisung select-Anweisung

Anweisung	Beschreibung
if-Anweisung besteht aus einem booleschen A-Ausdruck, gefolgt von einer oder mehreren Anweisungen.
if-Anweisung kann von einer optionalen else-Anweisung gefolgt werden. Der Ausdruck in der else-Anweisung wird ausgeführt, wenn der boolesche Ausdruck falsch ist.
switch-Anweisung wird verwendet, um verschiedene Aktionen basierend auf unterschiedlichen Bedingungen auszuführen.
Die select-Anweisung ähnelt der switch-Anweisung, aber select führt zufällig einen ausführbaren Fall aus. Wenn kein Fall zum Ausführen vorhanden ist, wird es blockiert, bis ein Fall zum Ausführen vorhanden ist.

if-Anweisung

Die Syntax lautet wie folgt:
• 
  

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

if-else-Anweisung

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

switch-Anweisung

Die darin enthaltenen Variablen<span class ="hljs- attribute">v</span> kann von jedem beliebigen Typ sein, val1 und val2 Es kann sich um einen beliebigen Wert desselben Typs handeln, der Typ ist nicht auf Konstanten oder Ganzzahlen beschränkt, oder das Endergebnis ist ein Ausdruck desselben Typs.
• 
  

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

  <span class="hljs-attribute">v</span>可以是任何类型，val1和val2可以是同类型的任意值，类型不局限为常量或者整数，或者最终结果为相同类型的表达式。

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

• select语句
  select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。它将会随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

for key, value := range oldmap {
	newmap[key] = value
}

注意：

• 每个case必须都是一个通信
• 所有channel表达式都会被求值，所有被发送的表达式都会被求值
• 如果任意某一个通信都可以，它就执行，其他就忽略
• 如果有多个case都可以运行，select就会随机挑选一个来执行。
• 如果没有一个case可以被运行：如果有default子句，就执行default子句，select将被阻塞，直到某个通信可以运行，从而避免饥饿问题。

2、循环语句

2.1 循环处理语句

与多数语言不同的是，Go语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构，关键字 for 的基本使用方法与C语言和 C++ 中非常接近。

go中时使用for实现循环的，共有三种形式：

select-Anweisung

a := 0
for a<5 {
	fmt.Printf("%d\n", a)
	a++
	if a==2 {
		break;
	}
}
/* output
0
1
2
*/

	语法
和c语言中的for相同	for init; condition; post {}
和c语言中的while相同	for condition{}
和c语言中的<span class="hljs-function"><span class="hljs-title">for</span><span class="hljs-params">(;;)</span></span>	select ist eine Kontrollstruktur in Go, ähnlich einer Switch-Anweisung, die für die Kommunikation verwendet wird. Bei jedem Fall muss es sich um einen „Kommunikationsvorgang“ handeln, entweder Senden oder Empfangen. Es wird zufällig ein ausführbarer Fall ausgeführt. Wenn kein Fall zum Ausführen vorhanden ist, wird es blockiert, bis ein Fall zum Ausführen vorhanden ist. Eine Standardklausel sollte immer ausführbar sein.

Hinweis:

Jeder Fall muss eine Kommunikation sein

Alle Kanalausdrücke werden ausgewertet, alle gesendeten Ausdrücke werden ausgewertetWenn eine Kommunikation in Ordnung ist, wird sie einfach ausgeführt, die anderen werden ignoriert Wenn mehrere Fälle ausgeführt werden können, wählt „select“ zufällig einen aus, der ausgeführt werden soll.

Wenn kein Fall ausgeführt werden kann: Wenn eine Standardklausel vorhanden ist, wird die Standardklausel ausgeführt und die Auswahl wird blockiert, bis eine bestimmte Kommunikation ausgeführt werden kann, wodurch das Hungerproblem vermieden wird.

2.1 SchleifenverarbeitungsanweisungenIm Gegensatz zu den meisten Sprachen unterstützen Schleifenanweisungen in der Go-Sprache nur das for-Schlüsselwort und nicht die while- und do-while-Strukturen. Die grundlegende Verwendung des Schlüsselworts for kommt der in C-Sprache und C++ sehr nahe . Es gibt drei Formen der Verwendung von for-Schleifen in go: Syntax ist die gleiche wie für in C-Sprache for init; condition; post {}

	2、 Schleifenanweisung

🎜 🎜🎜 ist dasselbe wie in C-Sprache 🎜🎜für Bedingung{}🎜🎜🎜🎜 und <span class="hljs-function"><span class=" hljs-title ">for</span><span class="hljs-params">(;;)</span></span>Gleiches 🎜🎜for{}🎜🎜🎜🎜🎜außer , die for-Schleife kann Verwenden Sie 🎜range🎜 auch direkt, um über Slices, Maps, Arrays und Strings usw. zu iterieren. Das Format ist wie folgt: 🎜

    // 不使用标记
    fmt.Println("---- continue ---- ")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue
            }
    }

/* output
i: 1
i2: 11
i2: 12
i2: 13
i: 2
i2: 11
i2: 12
i2: 13
i: 3
i2: 11
i2: 12
i2: 13
*/

    // 使用标记
    fmt.Println("---- continue label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d", i)
                for i2 := 11; i2 <= 13; i2++ {
                    fmt.Printf("i2: %d\n", i2)
                    continue re
                }
        }

/* output
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11
*/

🎜🎜🎜🎜2.2 Schleifenkontrollanweisung🎜🎜🎜🎜🎜🎜Steueranweisung🎜🎜ausführliche Erklärung🎜🎜 🎜 🎜🎜🎜break🎜🎜Unterbrechen Sie die Schleife oder wechseln Sie die Anweisung🎜🎜🎜🎜continue🎜🎜Überspringen Sie die verbleibenden Anweisungen der aktuellen Schleife und fahren Sie dann mit dem nächsten Zyklus fort🎜🎜🎜🎜goto-Anweisung🎜🎜Übertragen Sie die Steuerung an die markierte Aussage 🎜🎜🎜🎜

1、break

break主要用于循环语句跳出循环，和c语言中的使用方式是相同的。且在多重循环的时候还可以使用label标出想要break的循环。
实例代码如下：

a := 0
for a<5 {
	fmt.Printf("%d\n", a)
	a++
	if a==2 {
		break;
	}
}
/* output
0
1
2
*/

2、continue

Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。在多重循环中，可以用标号 label 标出想 continue 的循环。
实例代码如下：

    // 不使用标记
    fmt.Println("---- continue ---- ")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue
            }
    }

/* output
i: 1
i2: 11
i2: 12
i2: 13
i: 2
i2: 11
i2: 12
i2: 13
i: 3
i2: 11
i2: 12
i2: 13
*/

    // 使用标记
    fmt.Println("---- continue label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d", i)
                for i2 := 11; i2 <= 13; i2++ {
                    fmt.Printf("i2: %d\n", i2)
                    continue re
                }
        }

/* output
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11
*/

3、goto

goto语句主要是无条件转移到过程中指定的行。goto语句通常和条件语句配合使用，可用来实现条件转移、构成循环以及跳出循环体等功能。但是并不主张使用goto语句，以免造成程序流程混乱。
示例代码如下：

var a int = 0
LOOP: for a<5 {
	if a == 2 {
		a = a+1
		goto LOOP
	}
	fmt.Printf("%d\n", a)
	a++
}

/*
output:
0
1
2
3
4
*/

以上代码中的LOOP就是一个标签，当运行到goto语句的时候，此时执行流就会跳转到LOOP标志的哪一行上。

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

Das obige ist der detaillierte Inhalt vonWas sind die Golang-Flusskontrollanweisungen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!