Programa de control de flujo de
decidir cómo poner en práctica el programa, las tres sentencias de control de flujo común
- Control de la secuencia
- control de la rama: if-else
- control de bucle: para el cumplimiento de las condiciones antes de que el control de bucle, control de lazo (nota 10 al registro) después de la calificación
Control de la secuencia
-
De arriba a abajo de ejecución, cada programa sigue este principio, de acuerdo con la ejecución de un tramo de la línea, ni juicio, hasta que el programa está terminado o error a mitad de camino.
-
Acerca de las variables, hay que seguir el principio de referencias hacia delante legales {}, que es declarar su reutilización, a no utilizar, reexpresión
package main import "fmt" func main() { //正确 var a int = 100 a += 100 fmt.Println(a) //错误 b += 100 var b int = 200 fmt.Println(b) }
if-else if-else control de la rama
- if-else: sola rama, rama doble, múltiples tres ramas
- ramas individuales : el establecimiento del bloque de código se ejecuta cuando se determina la condición, el bloque omitido no se cumple, no hay salida. Si <expresión condicional> {<contenidos códigos>}
- rama Dual : se ejecuta el establecimiento de un bloque de código, el bloque de código no se satisface 2, viene bajo el control de condición sigue determinación orden de ejecución. Si <expresión condicional> {<Código Contenido 1>} else {<Código Descripción 2>}
- Multiramificados : 1 bloque de código está configurado, no se sostiene el bloque de código se ejecuta no se sostiene 2 ... n del bloque, de lo contrario no haya configurado en el bloque de código se ejecuta cuando se determina la condición.
Si <expresión condicional> {<Código Contenido 1>} else if <expresión condicional> {<Código Descripción 2>} else if ... <expresión condicional> <code {Contenido n>} else {<contenidos de código finales>}
-
Sobre si el formato, el funcionario sugirió expresiones sin paréntesis, y todo el código de desarrollo no añade la expresión entre paréntesis, pero los paréntesis añadir nada malo
if a>10 { fmt.Println("a大于10") //a>10执行打印，a<=10 } -
Acerca de si-else formato, disposiciones Golang única manera de escribir:
if a>10 { fmt.Println("a大于10") } else { fmt.Println("a小于10") } -
Sobre si: else if - otra cosa, de lo contrario no se requiere, una vez configurado, a continuación, pasar a la parte inferior de la secuencia de código de control
if a>10 { fmt.Println("a大于10") } else if a==10 { fmt.Println("a等于10") } else { fmt.Println("a小于10") } -
Usar la fosa debe ser añadido posterior si la expresión condicional, puede ser un == 10, pero no puede ser a = 10 esta asignación, el compilador es, sin duda no pasa
Ejemplo multiramificados:
Escuelas Secundarias través ax ^ 2 + bx + c = 0 son variables de entrada a, b, c de tres parámetros, hay varios raíz de la ecuación es determinado
b ^ 2 - 4ac> 0: Hay dos distintos bienes raíces
b ^ 2 - 4ac = 0: hay una verdadera
b ^ 2 - 4ac <0: no hay raíces reales
package main
import (
"fmt"
"math"
)
func main() {
/*
需求分析：
中学数学学过 ax^2+bx+c=0 分别输入变量a,b,c三个参数，判断方程有几个根
b^2 - 4ac > 0：有两个不同实根
b^2 - 4ac = 0：有一个实根
b^2 - 4ac < 0：无实根
引入x1和x2两个变量接收 b^2 - 4ac > 0：有两个不同实根情况
x1= (-b + math.Sqrt(b^2 - 4ac))/2a
x2= (-b - math.Sqrt(b^2 - 4ac))/2a
引入变量x一个变量接收 b^2 - 4ac = 0：有一个实根情况
x = -b / 2a
如果无实根则打印，没有实根
*/
var (
a float64
b float64
c float64
drt float64
)
fmt.Printf("请分别按顺序输入方程中a,b,c三个参数数值，用空格间隔开：\n")
fmt.Scanf("%f %f %f",&a,&b,&c)
drt = float64(b*b - 4 * a * c)
if drt > 0 {
x1 := (-b + math.Sqrt(drt)) / 2 * a
x2 := (-b - math.Sqrt(drt)) / 2 * a
fmt.Printf("\n该方程有两个实根，分别是\nx1=%v, x2=%v",x1,x2)
} else if drt == 0 {
x := -b / 2 * a
fmt.Printf("该方程有一个实根，分别是 x=%v",x)
} else if drt < 0 {
fmt.Printf("该方程没有实根")
}
}
ramas anidadas: nueva rama rama anidados, es decir, si anidado si iteración,
Múltiples sucursales presentaciones de casos anidada:
package main
import "fmt"
func main() {
/*
需求：圣斗士可进入竞技场的条件，
战斗力大于等于1000的为黄金圣斗士；
战斗力大于等于500小于1000的为白银圣斗士；
战斗力大于等于200小于500的为青铜圣斗士；
战斗力小于200的为战五渣，直接出局，不可进入竞技场
需求分析：
进入竞技场和进不了竞技场为两类人，需要用if-else判断；
if条件成立则
进入竞技场的又可以继续划分圣斗士等级，使用if-else if - else结构
if条件不成立则直接让战五渣out
*/
var name string
var power int
fmt.Println("请输入圣斗士姓名： ")
fmt.Scanf("%s",&name)
fmt.Printf("请输入圣斗士%s的战斗力：",name)
fmt.Scanf("%d",&power)
if power > 200 {
fmt.Printf("圣斗士%s允许进入竞技场参加角逐",name)
if power >= 1000 {
fmt.Printf("圣斗士%s经过战力评定判定为黄金圣斗士",name)
} else if power >= 500 {
fmt.Printf("\n圣斗士%s经过战力评定判定为白银圣斗士",name)
} else if power > 200 {
fmt.Printf("\n圣斗士%s经过战力评定判定为青铜圣斗士",name)
}
} else if power <= 200 && power >5 {
fmt.Printf("圣斗士%s战斗力不足，不允许进入竞技场",name)
} else {
fmt.Printf("圣斗士%s是战斗力不足5的渣，不允许进入竞技场",name)
}
}
interruptor de control de la rama
-
sentencia switch basado en diferentes condiciones para llevar a cabo diferentes acciones, cada rama caso es único, prueba individualmente de arriba a abajo hasta que un partido.
-
Volver partidos ★★★ lenguaje Golang no necesita añadir descanso! ! ! !
-
interruptor de selección múltiple manera particularmente adecuada para obtener los resultados correspondientes
-
Después ★★★ contacto de conmutación y el caso es una expresión puede ser constantes, variables, operadores, hay un valor de retorno de la función , se puede utilizar.
-
★★★ caso de que el valor de la expresión para ser coherente con el valor del tipo de datos de la expresión switch!
-
Detrás del caso puede tener múltiples expresiones, pero todas las expresiones deben coincidir con el tipo de datos del interruptor!
-
Todas las expresiones en caso si se trata de un valor constante, no se puede repetir, deben ser mutuamente excluyentes!
-
declaración por defecto no es necesario, si no hay un interruptor de fósforo directamente a su fin.
-
interruptor de nuevo no puede añadir expresión, directamente debajo del caso como si-else if la rama de uso
switch { case <分支表达式1>,<分支表达式2>: 语句块1 } -
detrás del interruptor puede ser una variable de expresiones de asignación, el interruptor num: = xxx {...}
-
Interruptor de penetrar: fallthrough, a saber case1 partidos, lógicamente hablando al final del bloque de interruptores, pero no quiero para cambiar, a continuación, utilizar el fallthrough, el siguiente caso continúa a la altura, por defecto fallthrough sólo puede penetrar en una capa, si la siguiente case2 también coinciden con los criterios, case1, salida case2 voluntad
Si la comparación y el interruptor
- Si se juzga valores no más específicas, de acuerdo con el número entero, punto flotante, carácter, tipos de cadenas de caracteres que utilizan interruptor eficiente.
- Y la sección de juicio los jueces del tipo de bool, si un mejor uso
Ejemplo de código:
switch <表达式>(多用来传入变量，不然没有意义) {
case <分支表达式1>,<分支表达式2>:
语句块1 //没有break，默认有符合的case执行完了默认就break了，结束switch块
case <分支表达式3>,<分支表达式4>...<分支表达式n>:
语句块2
.
.
.
default:
<上面都不匹配>语句块d //类似异常执行后的finally
} //待完成之后结束switch块继续执行顺序控制
caso:
package main
import "fmt"
func main() {
/*
需求：冰封王座英雄技能表，首先输入一个英雄名称，然后查看英雄相应技能及说明
英雄名称：恶魔猎手，死亡骑士
恶魔猎手技能：法力燃烧，献祭，闪避，恶魔化身
死亡骑士技能：死亡缠绕，吃尸，邪恶光环，黑暗奴仆
*/
var heroName string
fmt.Println("请输入要查询的英雄的名字：")
fmt.Scanf("%v",&heroName)
switch heroName {
case "恶魔猎手":
var skill string
fmt.Println("请输入要查询的技能名字：")
fmt.Scanf("%v",&skill)
switch skill {
case "法力燃烧":
fmt.Printf("%s真的很牛逼啊~", skill)
case "献祭":
fmt.Printf("%s真的很牛逼啊~", skill)
case "闪避":
fmt.Printf("%s真的很牛逼啊~", skill)
case "恶魔化身":
fmt.Printf("%s真的很牛逼啊~", skill)
}
case "死亡骑士":
var skill string
fmt.Println("请输入要查询的技能名字：")
fmt.Scanf("%v",&skill)
switch skill {
case "死亡缠绕":
fmt.Printf("%s真的很牛逼啊~",skill)
case "吃尸":
fmt.Printf("%s真的很牛逼啊~",skill)
case "邪恶光环":
fmt.Printf("%s真的很牛逼啊~",skill)
case "黑暗奴仆":
fmt.Printf("%s真的很牛逼啊~",skill)
}
default:
fmt.Printf("没有查询到该英雄名称，请重新输入")
}
}
