linguagem Go condicional declaração
declaração condicional exigido por desenvolvedores para especificar uma ou mais condições, e se é verdade que decidir se é necessário executar as condições de teste especificados pela instrução, e se a condição for falsa na implementação de outras declarações.
A figura abaixo mostra a estrutura da instrução condicional linguagem de programação:
| afirmação | descrição |
|---|---|
| A instrução if | if é seguido por uma expressão booleana por esta última ou mais declarações. |
| if ... else | if depois pode usar o opcional else , else na expressão execução é falso em expressões booleanas. |
| if aninhadas | Você pode se ou mais se incorporado em uma ou mais declarações se ou else if declaração. |
| switch | interruptor declaração é usada para executar ações diferentes com base em diferentes condições. |
| select | selecionar instrução semelhante à interruptor declaração, mas o caso de execução irá selecionar aleatoriamente uma corrida. Se não há nenhum caso para executar, ele irá bloquear até que o caso foi executado. |
se, se ... declaração e python pessoa ou C-like linguagem
Chave para explicar:
switch com base em condições diferentes para executar ações diferentes, cada sucursal caso é único, individualmente testada de cima para baixo, até a partida.
instrução switch executa o processo de cima para baixo, até que seja encontrada uma correspondência, seguido de um jogo não precisa adicionar pausa.
caso padrão interruptor declaração última pausa vem no caso, depois de um casamento bem-sucedido não executa outro caso, se o que precisamos fazer para trás o caso, você pode usar fallthrough .
gramática
Go sintaxe instrução switch linguagem de programação é a seguinte:
switch var1 {
case val1:
...
case val2:
...
default:
...
}
Ele pode ser qualquer tipo de var1, enquanto val2 val1 e pode ser qualquer valor do mesmo tipo. Ou do tipo não se limita a um número inteiro constante, mas deve ser do mesmo tipo; ou o resultado final é o mesmo tipo de expressão.
Pode testar simultaneamente múltiplos valores podem satisfazer os critérios, que são separados por vírgulas, por exemplo: caso val1, val2, val3.
fluxograma:
func tyepe() {
// switch语句练习
grader := "B"
marks := 40
switch marks {
case 90:
grader = "A"
case 80:
grader = "B"
case 50, 60, 70:
grader = "C"
default:
grader = "D"
}
switch {
case grader == "A":
fmt.Println("优秀")
case grader == "B":
fmt.Println("良好")
case grader == "C":
fmt.Println("及格")
case grader == "D":
fmt.Println("不及格")
}
}
func main() {
// traversalstring()
// changeStrings()
tyepe()
}
tipo de interruptor
switch também pode ser usado para determinar a troca do tipo de interface de uma variável do tipo variável realmente armazenados.
Mudar tipo de sintaxe é a seguinte:
switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 你可以定义任意个数的case */
default: /* 可选 */
statement(s);
}
func test() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Println("x的类型是 %T", i)
case int:
fmt.Println("x的类型是 %T", i)
case float32:
fmt.Println("x的类型是 %T", i)
case bool, string:
fmt.Println("x的类型是 %T", i)
default:
fmt.Println("未知类型")
}
}
func main() {
// traversalstring()
// changeStrings()
// tyepe()
test()
}
Os resultados da execução do código acima:
x 的类型 :<nil>
Cair em
Use Enforces fallthrough parte de trás da declaração caso, um caso sob fallthrough não julgar se o resultado da expressão é verdadeira.
package main
import "fmt"
func main() {
switch {
case false:
fmt.Println("1、case 条件语句为 false")
fallthrough
case true:
fmt.Println("2、case 条件语句为 true")
fallthrough
case false:
fmt.Println("3、case 条件语句为 false")
fallthrough
case true:
fmt.Println("4、case 条件语句为 true")
case false:
fmt.Println("5、case 条件语句为 false")
fallthrough
default:
fmt.Println("6、默认 case")
}
}
Os resultados da execução do código acima:
2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true
A partir dos resultados acima saída de código: interruptor começa pela primeira expressão é uma determinação do caso para true, um caso continuará a operar se o caso tem fallthrough, programa, e não é para julgar a próxima expressão caso se a fórmula for verdadeira.
select
Go é um seleto estrutura de controle é semelhante à declaração switch para a comunicação. Cada caso deve ser uma operação de comunicação, quer transmitir ou receber.
realizada seleccionar aleatoriamente um caso em execução. Se não há nenhum caso para executar, ele irá bloquear até que o caso foi executado. A cláusula padrão deve sempre ser executado.
sintaxe:
Go linguagem de programação sintaxe instrução select é a seguinte:
select {
case communication clause :
statement(s);
case communication clause :
statement(s);
/* 你可以定义任意数量的 case */
default : /* 可选 */
statement(s);
}
A seguir descreve a sintaxe da instrução SELECT:
-
Cada caso deve ser uma comunicação
-
Todos expressão do canal será avaliada
-
Todas as expressões será enviado para ser avaliado
-
Se alguém da comunicação pode ser realizada, ele executa, o outro é ignorado.
-
Se mais de um caso pode correr, Select irá selecionar aleatoriamente uma execução justa. Outros não será executado.
Caso contrário:
- Se não houver cláusula padrão, a instrução é executada.
- Se não houver cláusulas de default, selecione o bloco até que uma comunicação pode ser executado; Vai para o canal ou não re-valor é avaliada.
Exemplos
demos aplicação selecione declaração:
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")
}
}