Artigo Diretório
O controle de fluxo do programa determina como o programa é executado. As instruções de controle do programa geralmente incluem: sequência, ramificação e loop
Controle de sequência
O programa é executado de cima para baixo por padrão e não há salto no meio.
Em Golang, referências legais futuras são usadas, e as variáveis devem ser definidas antes do uso (algumas linguagens suportam julgamento antes da definição, e o processo de execução do programa será automaticamente otimizado)
Controle de filial
se controle de filial
se for compatível com a sintaxe de controle de ramificação única, ramificação dupla e ramificação múltipla é a seguinte
Gramática básica
if 条件表达式1 {
执行代码块1
}else if 条件表达式2{
执行代码块2
}
....
else{
执行代码块3
}
Quando a expressão condicional 1 for verdadeira, o bloco de código 1 será executado, caso contrário, a expressão condicional 2 será julgada, se for verdadeira, o bloco de código 2 será executado, se todas as expressões anteriores forem falsas, o bloco de código 3 será executado
Programa de amostra
func test6(){
var age int
fmt.Println("请输入年龄：")
fmt.Scanln(&age)
if(age>18){
fmt.Println("你是成年人")
}else if(age>0){
fmt.Println("你是未成年人")
}else{
fmt.Println("年龄不合法")
}
}
mudar o controle da filial
Gramática básica
switch 表达式{
case 表达式1，表达式2...：
代码块1
case 表达式3，表达式4...：
代码块2
...
default:
代码块n
}
Não há necessidade de adicionar break no bloco de instrução switch case em go, e pode haver várias expressões após o case separadas por vírgulas
Código de amostra
func test7(){
var age int
fmt.Println("请输入年龄：")
fmt.Scanln(&age)
switch age {
case 1,2,3,4,5,6:
fmt.Println("你是儿童")
case 7,8,9,10,11,12,13,14:
fmt.Println("你是少年")
default:
fmt.Println("你长大了")
}
switch {
case 0<age && age<=7:
fmt.Println("你是儿童")
case 7<age && age<=14:
fmt.Println("你是少年")
default:
fmt.Println("你长大了")
}
switch nage := age; {
case 0<nage && nage<=7:
fmt.Println("你是儿童")
//fallthrough switch 穿透
case 7<nage && nage<=14:
fmt.Println("你是少年")
default:
fmt.Println("你长大了")
}
var x interface{
}
var y = 10.0
x = y
switch i :=x.(type){
case nil:
fmt.Printf("x的类型是 : %T",i)
case int:
fmt.Printf("x的类型是 : int")
case float64:
fmt.Printf("x的类型是 : float64")
default:
fmt.Printf("x的类型是 未知类型")
}
}
ponto importante
- Depois de case / switch, pode ser uma variável, expressão ou função com um valor de retorno.
- O tipo de dados da expressão após o caso deve ser o mesmo que o tipo da expressão após a troca
- Se for um valor constante após o caso, não pode ser repetido
- padrão não é necessário
- Não pode haver expressão após switch, semelhante ao uso de if else
- Depois que o switch pode simplesmente declarar uma variável, um ponto - e - vírgula não é recomendado
- switch penetration-fallthrough: Se o fallthrough for adicionado após o bloco de instrução do caso, o próximo caso continuará a ser executado
- Switch de tipo: A instrução switch pode ser usada em switch de tipo para determinar o tipo de variável executada por uma variável de interface
Resumo
Se não houver muitos valores específicos a serem julgados e for adequado para números inteiros, números de ponto flutuante, caracteres e strings, é recomendável usar switch. Breve introdução é eficiente.
Outras situações: julgamento de intervalo, o o resultado é o julgamento do tipo bool, use se, e se a faixa de uso for mais ampla
Controle de loop
para controle de loop
Gramática básica
for 循环变量初始化；循环条件；循环变量迭代{
循环操作(语句)
}
for ; ; {
//无限循环 通常配合break语句使用
//操作语句
}
for {
//无限循环 通常配合break语句使用
//操作语句
}
for index,val := range str{
//操作语句
}
Exemplo de código
func test8(){
for i := 1;i < 10;i++{
fmt.Println("结果:",i)
}
fmt.Println("=====================")
var c int =1;
for {
fmt.Println("结果:",c)
c++
if(c>10){
break
}
}
fmt.Println("=====================")
var str string = "我爱北京天安门"
for i :=0 ; i<len(str); i++ {
fmt.Printf("%c \n",str[i])
}
fmt.Println("=====================")
for index,val := range str {
fmt.Printf("index =%d ,val=%c \n",index,val)
}
}
enquanto eu faço enquanto
Linguagem Go não tem tempo e fazer enquanto sintaxe, você pode usar para conseguir o mesmo efeito.
Exemplo de código
func test9(){
// ---------do while 效果实现
var c int =1
for {
fmt.Println("结果:",c)
c++
if(c>10){
break
}
}
// while 效果实现
for {
if(c>10){
break
}
fmt.Println("结果:",c)
c++
}
}
Quebra de instrução de controle de salto continue goto return
Break
break é usado para suspender a execução de um bloco de instrução e é usado para interromper o loop for atual ou instrução switch
- Você pode usar o rótulo para especificar qual nível do loop for parar
- Salte do loop for mais próximo por padrão
continue é
usado para encerrar este loop e iniciar diretamente o próximo loop. Quando
vários loops estão aninhados, o rótulo pode ser usado para especificar qual nível de loop pular
vamos para
- goto pode fazer com que o programa vá incondicionalmente para o local especificado para execução
- Geralmente é usado em conjunto com declarações condicionais para realizar funções como transição condicional e fora do loop
- Geralmente não é recomendado usar goto, é fácil causar confusão no fluxo do programa
return é
usado para saltar para fora do método ou função
Código de amostra
func test10(){
outf://增加标签
for i := 0;i<5;i++ {
inf:
for j :=0; j<5; j++ {
fmt.Println("i=",i,",j=",j);
if i == 1 && j == 2{
break inf //结束内存循环 外层循环继续执行 外层继续i =2 的循环
}
if i==3 {
continue outf
}
if i == 5 && j == 2{
// 输出 5 2 后外层循环中止，后续不在有输出
break outf //结束内存循环
}
}
}