idioma ir sentencia condicional
sentencia condicional requerido por los desarrolladores para especificar una o más condiciones, y si bien es cierto que decidir si llevar a cabo las condiciones de ensayo especificadas en la declaración, y si la condición es falsa en la ejecución de otras declaraciones.
La siguiente figura muestra la estructura de la sentencia condicional del lenguaje de programación:
| declaración | descripción |
|---|---|
| La sentencia if | si la declaración es seguida por una expresión booleana por las declaraciones de este último o más. |
| si ... else | si la declaración después de que se puede utilizar la opción else , else en la expresión de ejecución es falsa en expresiones booleanas. |
| if anidadas | Puede si o más si incrustado en una o más sentencias si o else if comunicado. |
| sentencia switch | interruptor de instrucción se utiliza para llevar a cabo diferentes acciones basadas en diferentes condiciones. |
| instrucción de selección | seleccione instrucción similar al interruptor de declaración, pero el caso de ejecución seleccionará al azar una carrera. Si no hay ningún caso para funcionar, se bloqueará hasta que el caso se ha ejecutado. |
si, si ... declaración y pitón persona o C-como el lenguaje
Clave para explicar:
sentencia switch basado en diferentes condiciones para llevar a cabo diferentes acciones, cada rama caso es único, analizarán por separado, de arriba hacia abajo, hasta que el partido.
sentencia switch ejecuta el proceso de arriba hacia abajo, hasta que se encuentra una coincidencia, seguido de un partido no necesita añadir descanso.
caso por defecto interruptor de último estado de ruptura se presenta en el caso, después de un partido de éxito no realiza otro caso, si tenemos que hacer detrás del caso, puede utilizar fallthrough .
gramática
sintaxis de la sentencia interruptor de lenguaje de programación Go es como sigue:
switch var1 {
case val1:
...
case val2:
...
default:
...
}
Puede ser cualquier tipo de var1, mientras val2 val1 y puede ser cualquier valor del mismo tipo. O tipo no se limita a un número entero constante, sino que debe ser del mismo tipo, o resultado final es el mismo tipo de expresión.
Se puede probar simultáneamente múltiples valores puede cumplir los criterios, que están separados por comas, por ejemplo: caso val1, val2, val3.
Diagrama de flujo:
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 conmutador
sentencia switch también se puede utilizar para determinar el tipo de interruptor interfaz de una variable de tipo de variable efectivamente almacenada.
Tipo de interruptor sintaxis es la siguiente:
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()
}
Los anteriores resultados de la ejecución de código:
x 的类型 :<nil>
caer a través
Utilice hace cumplir fallthrough la parte posterior de la declaración de caso, un caso bajo fallthrough no juzga si el resultado de la expresión es verdadera.
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")
}
}
Los anteriores resultados de la ejecución de código:
2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true
De los resultados anteriores salida de código: Interruptor comienza en la primera expresión es una determinación de la causa de cierto, un caso seguirá funcionando si el caso tiene fallthrough, programa, y no es para juzgar la siguiente expresión case si la fórmula es cierto.
instrucción de selección
Go es una estructura de control de selección es similar a la instrucción switch para la comunicación. Cada caso debe ser una operación de comunicación, transmitiendo o recibiendo.
realizado seleccionar al azar un caso corriente. Si no hay ningún caso para funcionar, se bloqueará hasta que el caso se ha ejecutado. Una cláusula por defecto siempre se debe ejecutar.
sintaxis:
Ir lenguaje de programación sintaxis de instrucción de selección es el siguiente:
select {
case communication clause :
statement(s);
case communication clause :
statement(s);
/* 你可以定义任意数量的 case */
default : /* 可选 */
statement(s);
}
A continuación se describe la sintaxis de la instrucción de selección:
-
Cada caso debe ser una comunicación
-
Se evaluarán todas canal de expresión
-
Todas las expresiones serán enviados para ser evaluados
-
Si cualquiera de la comunicación puede ser llevada a cabo, se lleva a cabo, el otro es ignorado.
-
Si más de un caso se puede ejecutar, Select seleccionará al azar una ejecución justa. no se ejecutarán otros.
De lo contrario:
- Si no hay cláusula de incumplimiento, se ejecuta la instrucción.
- Si no hay cláusulas de incumplimiento, seleccione el bloque hasta que una comunicación puede funcionar; ir al canal o no re-valor se evalúa.
Ejemplos
demostraciones de aplicaciones instrucción de selección:
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")
}
}