One place for hosting & domains

      instrucciones

      Cómo escribir instrucciones condicionales en Go


      Introducción

      Las instrucciones condicionales son parte de cada lenguaje de programación. Con las instrucciones condicionales, podemos disponer de código que a veces se ejecuta y que en otros momentos no lo hace, según las condiciones del programa en ese momento.

      Cuando ejecutamos por completo cada instrucción de un programa, no pedimos a este que evalúe condiciones específicas. Al usar las instrucciones condicionales, los programas pueden determinar si se cumplen ciertas condiciones y luego recibir instrucciones sobre cómo proceder a continuación.

      Veamos algunos ejemplos en los que usaríamos instrucciones condicionales:

      • Si el estudiante recibe más del 65 % en su examen, informar que obtuvo una calificación de aprobación; si no, informar que obtuvo una calificación de desaprobación.
      • Si posee dinero en su cuenta, calcular intereses; si no, cobrar una penalización.
      • Si compra 10 o más naranjas, calcular un descuento del 5 %; si compra menos, no hacerlo.

      Al evaluar las condiciones y asignar un código para que se ejecute según si se cumplan o no estas condiciones, escribimos código condicional.

      Este tutorial le servirá como guía para escribir instrucciones condicionales en el lenguaje de programación Go.

      Instrucciones “if”

      Comenzaremos con la instrucción if, que evaluará si una instrucción es verdadera o falsa, y ejecutaremos código solo cuando la instrucción sea verdadera.

      En un editor de texto simple, abra un archivo y escriba el siguiente código:

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 70
      
          if grade >= 65 {
              fmt.Println("Passing grade")
          }
      }
      

      Con este código, disponemos de la variable grade y le asignaremos el valor entero 70. Luego, usaremos la instrucciónifpara evaluar si la variable “grade” es superior o igual (>=) a 65. Si cumple con esta condición, indicaremos al programa que imprima la cadena Passing grade.

      Guarde el programa como grade.go y ejecútelo en un entorno de programación local desde una ventana de terminal con el comando go run grade.go.

      En este caso, la calificación de 70 cumple la condición de ser superior o igual a 65, por lo que verá el siguiente resultado una vez que ejecute el programa:

      Output

      Passing grade

      A continuación, cambiaremos el resultado de este programa modificando el valor de la variable grade de modo que sea 60:

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 60
      
          if grade >= 65 {
              fmt.Println("Passing grade")
          }
      }
      

      Cuando guardemos y ejecutemos este código, no veremos resultados porque no se cumplió la condición y no indicamos al programa que ejecute otra instrucción.

      Para dar un ejemplo más, calculemos si el balance de una cuenta bancaria es inferior a 0. Crearemos un archivo llamado account.go y escribiremos el siguiente programa:

      account.go

      package main
      
      import "fmt"
      
      func main() {
          balance := -5
      
          if balance < 0 {
              fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
          }
      }
      

      Cuando ejecutemos el programa con go run account.go veremos el siguiente resultado:

      Output

      Balance is below 0, add funds now or you will be charged a penalty.

      En el programa, iniciamos la variable balance con el valor -5, que es inferior a 0. Debido a que el balance cumplió la condición de la instrucción if (balance < 0), una vez que guardemos y ejecutemos el código, recibiremos el resultado de la cadena. Una vez más, si cambiamos el balance a 0 o un número positivo, no veremos resultados.

      Instrucciones Else

      Es probable que le convenga que el programa realice algo aun cuando una instrucción si se evalúe a “false”. En nuestro ejemplo de calificación, nos convendrá obtener resultados independientemente de que la calificación sea o no de aprobación.

      Para hacer esto, agregaremos a la condición de calificación anterior una declaración else que se construye así:

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 60
      
          if grade >= 65 {
              fmt.Println("Passing grade")
          } else {
              fmt.Println("Failing grade")
          }
      }
      

      Puesto que la variable “grade” tiene el valor 60, la instrucción if se evalúa a “false”, por lo que el programa no imprimirá Passing grade. La instrucción else siguiente indica al programa que realice alguna acción de todos modos.

      Al guardar y ejecutar el programa, veremos el siguiente resultado:

      Output

      Failing grade

      Si luego reescribimos el programa para darle a la calificación el valor 65 o uno superior, en su lugar obtendremos Passing grade.

      Para agregar una instrucción else al ejemplo de cuenta bancaria, reescribimos el código de esta manera:

      account.go

      package main
      
      import "fmt"
      
      func main() {
          balance := 522
      
          if balance < 0 {
              fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
          } else {
              fmt.Println("Your balance is 0 or above.")
          }
      }
      

      Output

      Your balance is 0 or above.

      Aquí, cambiamos el valor de la variable balance a un número positivo para que realice una impresión la instrucción else. A fin de lograr que la primera instrucción if realice una impresión, podemos reescribir el valor a un número negativo.

      Al combinar una instrucción if con una instrucción else, construye una instrucción condicional de dos partes que indicará a la computadora que ejecute un código determinado independientemente de que se cumpla o no la condición if.

      Instrucciones else if

      Hasta ahora, presentamos una opción de booleano para declaraciones condicionales y cada declaración if realizando una evaluación a “true” o “false”. En muchos casos, nos convendrá un programa que evalúe más de dos posibles resultados. Para esto, usaremos una instrucción else if, la cual se redacta en Go como else if. else if o la “instrucción else if” se parece a la instrucción if y evaluará otra condición.

      En el programa de cuentas bancarias, posiblemente nos convenga disponer de tres resultados discretos para tres situaciones diferentes:

      • El balance es inferior a 0.
      • El balance es igual a 0.
      • El balance es superior a 0.

      La instrucción else if se dispondrá entre las instrucciones if y else de la siguiente manera:

      account.go

      package main
      
      import "fmt"
      
      func main() {
          balance := 522
      
          if balance < 0 {
              fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
          } else if balance == 0 {
              fmt.Println("Balance is equal to 0, add funds soon.")
          } else {
              fmt.Println("Your balance is 0 or above.")
          }
      }
      

      Ahora, hay tres posibles resultados que pueden producirse una vez que ejecutemos el programa:

      • Si la variable balance es igual a 0, veremos el resultado de la instrucción else if (Balance is equal to 0, add funds soon).
      • Si la variable balance se fija en un número positivo, veremos el resultado de la instrucción else (Your balance is 0 or above).
      • Si la variable balance se fija a un número negativo, el resultado será la cadena de la instrucción if (Balance is below 0, add funds now or you will be charged a penalty).

      ¿Qué sucede si, no obstante, deseamos disponer de más de tres posibilidades? Podemos hacer esto escribiendo más de una instrucción else if en nuestro código.

      En el programa grade.go, reescribiremos el código para que haya algunas calificaciones de letras correspondientes a rangos de calificaciones numéricas:

      • 90, o más, equivale a una calificación “A”.
      • Entre 80 y 89, equivale a una calificación “B”.
      • Entre 70 y 79 equivale a una calificación “C”.
      • Entre 65 y 69 equivale a una calificación “D”.
      • 64, o menos, equivale a una calificación “F”.

      Para ejecutar este código, necesitaremos una instrucción if, tres instrucciones else ify una instrucción else que manejarán todos los casos fallidos.

      Reescribiremos el código del ejemplo anterior para disponer de cadenas que impriman cada una de las calificaciones de letras. Podemos hacer que nuestra instrucción else sea igual.

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 60
      
          if grade >= 90 {
              fmt.Println("A grade")
          } else if grade >= 80 {
              fmt.Println("B grade")
          } else if grade >= 70 {
              fmt.Println("C grade")
          } else if grade >= 65 {
              fmt.Println("D grade")
          } else {
              fmt.Println("Failing grade")
          }
      }
      

      Debido a que las instrucciones else if se evalúan en orden, podemos mantener un perfil bastante básico para nuestras instrucciones. Este programa completa los siguientes pasos:

      1. Si la calificación es superior a 90, el programa imprimirá A grade; si es inferior a 90, el programa continuará con la declaración siguiente…

      2. Si la calificación es superior o igual a 80, el programa imprimirá B grade; si es 79 o inferior, el programa continuará con la declaración siguiente…

      3. Si la calificación es superior o igual a 70, el programa imprimirá C grade; si la calificación es 69 o inferior, el programa continuará con la declaración siguiente…

      4. Si la calificación es superior o igual a 65, el programa imprimirá D grade; si es 64 o inferior, el programa continuará con la declaración siguiente…

      5. El programa imprimirá Failing grade porque no se cumplieron todas las condiciones anteriores.

      Instrucciones If anidadas

      Una vez que se sienta cómodo con las instrucciones if, else if y else, puede proseguir con las instrucciones condicionales anidadas. Podemos usar instrucciones if anidadas para situaciones en las que deseemos verificar una condición secundaria si la primera condición se ejecuta como verdadera. Para esto, podemos tener una instrucción if-else dentro de otra instrucción if-else. Veamos la sintaxis de una instrucción if anidada:

      if statement1 { // outer if statement
          fmt.Println("true")
      
          if nested_statement { // nested if statement
              fmt.Println("yes")
          } else { // nested else statement
              fmt.Println("no")
          }
      
      } else { // outer else statement
          fmt.Println("false")
      }
      

      De este código pueden surgir algunos resultados:

      • Si statement1 se evalúa a “true”, el programa evaluará si nested_statement también se evalúa a “true”. Si ambos casos son verdaderos, se obtendrá el siguiente resultado:

      Output

      true yes
      • Sin embargo, si statement1 se evalúa a “true”, pero nested_statement se evalúa a “false”, el resultado será el siguiente:

      Output

      true no
      • Si statement1 se evalúa a “false”, no se ejecutará la instrucción “if-else” anidada, por lo que la instrucción else se ejecutará sola y el resultado será el siguiente:

      Output

      false

      También podemos disponer de varias instrucciones if anidadas en nuestro código:

      if statement1 { // outer if
          fmt.Println("hello world")
      
          if nested_statement1 { // first nested if
              fmt.Println("yes")
      
          } else if nested_statement2 { // first nested else if
              fmt.Println("maybe")
      
          } else { // first nested else
              fmt.Println("no")
          }
      
      } else if statement2 { // outer else if
          fmt.Println("hello galaxy")
      
          if nested_statement3 { // second nested if
              fmt.Println("yes")
          } else if nested_statement4 { // second nested else if
              fmt.Println("maybe")
          } else { // second nested else
              fmt.Println("no")
          }
      
      } else { // outer else
          statement("hello universe")
      }
      

      En este código, hay una instrucción if anidada dentro de cada instrucción if además de la instrucción if else. Esto hará posibles más opciones dentro de cada condición.

      Veamos un ejemplo de instrucciones if anidadas con nuestro programa de grade.go. Podemos verificar primero si una calificación es de aprobación (superior o igual al 65 %) y luego evaluar la letra de la calificación a la que debería equivaler la calificación numérica. Sin embargo, si la calificación no es de aprobación no es necesario que revisemos las calificaciones con letras y, como alternativa, podemos hacer que el programa informe que la calificación equivale a una desaprobación. Nuestro código modificado con la instrucción if anidada tendrá el siguiente aspecto:

      grade.go

      
      package main
      
      import "fmt"
      
      func main() {
          grade := 92
          if grade >= 65 {
              fmt.Print("Passing grade of: ")
      
              if grade >= 90 {
                  fmt.Println("A")
      
              } else if grade >= 80 {
                  fmt.Println("B")
      
              } else if grade >= 70 {
                  fmt.Println("C")
      
              } else if grade >= 65 {
                  fmt.Println("D")
              }
      
          } else {
              fmt.Println("Failing grade")
          }
      }
      

      Si ejecutamos el código con la variable grade fijada en el valor entero 92, se cumplirá la primera condición y el programa imprimirá Passing grade of: A continuación, verificará si la calificación es mayor o igual a 90, y dado que esta condición también se cumple, imprimirá A.

      Si ejecutamos el código con la variable grade fijada en 60, la primera condición no se cumplirá, por lo que el programa omitirá las instrucciones anidadas if, pasará a la instrucción else e imprimirá Failing grade.

      Podemos, por supuesto,agregar aún más opciones a esto y usar una segunda capa de instrucciones if anidadas. Posiblemente nos convenga evaluar las notas de A+, A y A- por separado. Podemos hacerlo revisando primero si la calificación es de aprobación, luego si la calificación es 90 o superior y finalmente si es superior a 96 para equivaler a A+:

      grade.go

      ...
      if grade >= 65 {
          fmt.Print("Passing grade of: ")
      
          if grade >= 90 {
              if grade > 96 {
                  fmt.Println("A+")
      
              } else if grade > 93 && grade <= 96 {
                  fmt.Println("A")
      
              } else {
                  fmt.Println("A-")
              }
      ...
      

      En este código, para una variable grade fijada en 96 el programa realizará lo siguiente:

      1. Verificar si la calificación es superior o igual a 65 (true)
      2. Imprimir Passing grade of:
      3. Verificar si la calificación es superior o igual a 90 (true)
      4. Verificar si la calificación es superior a 96 (false)
      5. Verificar si la calificación es superior a 93 e inferior o igual a 96 (true)
      6. Imprimir A
      7. Dejar estas instrucciones condicionales anidadas y continuar con el código restante

      Por lo tanto, el resultado del programa para una calificación de 96 tiene el siguiente aspecto:

      Output

      Passing grade of: A

      Las instrucciones if anidadas pueden permitir añadir varios niveles específicos de condiciones a su código.

      Conclusión

      Al usar instrucciones condicionales como if, tendrá mayor control sobre las ejecuciones que realice su programa. Las instrucciones condicionales indican al programa que evalúe si se cumple una condición determinada. Si la condición se cumple, este ejecutará código específico, pero si no se cumple continuará con otros códigos.

      Para continuar practicando con las instrucciones condicionales, intente usar diferentes operadores para familiarizarse más con ellas.



      Source link

      Cómo escribir instrucciones switch en Go


      Introducción

      Las instrucciones condicionales brindan a los programadores la capacidad indicar a sus programas que realicen una acción si una condición es verdadera y otra si la condición es falsa. Con frecuencia, nos conviene comparar alguna variable con múltiples valores posibles y realizar diferentes acciones en cada circunstancia. Es posible lograr esto utilizando solo instrucciones if. Sin embargo, escribir software no solo se trata de lograr que las cosas funcionen, sino también de comunicar su intención a usted mismo en el futuro y a otros desarrolladores. switch es una instrucción condicional alternativa útil para comunicar las acciones realizadas por sus programas de Go cuando se les presentan diferentes opciones.

      Todo lo que podamos escribir con la instrucción de switch también se puede escribir con instrucciones if. En este tutorial, veremos algunos ejemplos de lo que puede lograr la instrucción switch, las instrucciones if que sustituye y en que situaciones se aplica de forma más adecuada.

      Estructura de las instrucciones Switch

      Switch se utiliza comúnmente para describir las acciones efectuadas por un programa cuando a una variable se le asignan valores específicos. En el siguiente ejemplo se muestra la forma en que lograríamos esto usando instrucciones if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              if flav == "strawberry" {
                  fmt.Println(flav, "is my favorite!")
                  continue
              }
      
              if flav == "vanilla" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              if flav == "chocolate" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              fmt.Println("I've never tried", flav, "before")
          }
      }
      

      Esto generará el siguiente resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Dentro de main, definimos un slice de sabores de helado. Luego usaremos un for loop para iterarlos. Utilizamos tres instrucciones if para imprimir diferentes mensajes que indican preferencias por diferentes sabores de helado. Cada instrucción if debe usar la instrucción continue para detener la ejecución del bucle for, de modo que el mensaje predeterminado al final no se imprima para los sabores de helado preferidos.

      Al añadir nuevas preferencias de helado, debemos seguir agregando instrucciones if para manejar los nuevos casos. En los mensajes duplicados, como en el caso de “vanilla” y “chocolate”, deben estar duplicadas las instrucciones if. Para los futuros lectores de nuestro código (incluidos nosotros), la naturaleza repetitiva de las instrucciones if oculta la parte importante de lo que hacen, (cuando se compara la variable con varios valores y tomando y se toman diferentes acciones). Además, nuestro mensaje de reserva se distingue de los condicionales y hace que parezca que no está relacionado. La instrucción switch puede servirnos para organizar mejor esta lógica.

      La instrucción switch comienza con la palabra clave switch y le sigue, en su forma más básica, alguna variable contra la cual puedan realizarse comparaciones. A esto le sigue un par llaves ({}) en el que pueden aparecer varias_ cláusulas de caso_. Las cláusulas de caso describen las acciones que su programa de Go debe realizar cuando la variable proporcionada a la instrucción switch es igual al valor referido por las cláusulas de caso. El siguiente ejemplo convierte el ejemplo anterior para que utilice switch en lugar de varias instrucciones if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      El resultado es el mismo que el anterior:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Una vez más, definimos un segmento de sabores de helado en main y usamos la instrucción range para iterar cada sabor. Sin embargo, esta vez usamos una instrucción switch que examinará la variable flav. Utilizamos dos cláusulas case para indicar las preferencias. Ya no necesitamos las instrucciones continue porque la instrucción switch solo ejecutará una cláusula case. También podemos combinar la lógica duplicada de los condicionales “chocolate” y “vanilla” separando cada uno con una coma en la declaración de la cláusula case. La cláusula default sirve como cláusula general. Se ejecutará para cualquier sabor que no hayamos tenido en cuenta en el cuerpo de la instrucción switch. En este caso, “banana” hará que se ejecute default, con lo cual se imprimirá el mensaje I've never tried banana before.

      Esta forma simplificada de las instrucciones switch aborda el uso más común para ellas: comparar una variable con varias alternativas. También nos proporciona practicidad cuando queremos realizar la misma acción para varios valores diferentes y cualquier otra acción cuando no se cumple ninguna de las condiciones enumeradas al usar la palabra clave default.

      Cuando esta forma simplificada de switch resulta demasiado limitada, podemos usar una forma más general de la instrucción switch.

      Instrucciones generales de switch

      Las instrucciones switch son útiles para agrupar las colecciones de condicionales más complicadas a fin de mostrar que están de algún modo relacionadas. Esto se utiliza con mayor frecuencia al comparar una variable con un rango de valores, en lugar de valores específicos como en el ejemplo anterior. El siguiente ejemplo implementa un juego de adivinanzas usando instrucciones if que se podrían beneficiar con una instrucción switch:

      package main
      
      import (
          "fmt"
          "math/rand"
          "time"
      )
      
      func main() {
          rand.Seed(time.Now().UnixNano())
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              if guess > target {
                  fmt.Println("Too high!")
                  continue
              }
      
              if guess < target {
                  fmt.Println("Too low!")
                  continue
              }
      
              fmt.Println("You win!")
              break
          }
      }
      

      El resultado puede variar dependiendo del número aleatorio que seleccionó y de lo bien que se desempeñe en el juego. A continuación, se muestra el resultado de una sesión de ejemplo:

      Output

      Enter a guess: 10 Too low! Enter a guess: 15 Too low! Enter a guess: 18 Too high! Enter a guess: 17 You win!

      En nuestro juego de adivinanzas se requiere un número al azar para compararlas, por lo que usamos la función rand.Intn del paquete math/rand. A fin de asegurarnos de obtener valores diferentes para target cada vez que juguemos, usamos rand.Seed para aleatorizar el generador de números aleatorios según la hora actual. El argumento 100 en rand.Intn nos proporcionará un número dentro del rango de 0 a 100. Luego, usaremos un bucle for para comenzar a recopilar adivinanzas del jugador.

      La función fmt.Scanf nos proporciona un medio para leer las entradas del usuario en una variable que elijamos. Se requiere un verbo de cadena de formato que convierta la entrada del usuario al tipo que esperamos. Aquí %d significa que esperamos un int y pasamos la dirección de la variable guess de modo que fmt.Scanf pueda establecer esa variable. Después de manejar cualquier error de análisis, usamos dos instrucciones if para comparar la adivinanza del usuario con el valor target. El string que muestran, junto con bool, controla el mensaje que se presenta al jugador y si el juego se cerrará.

      Estas instrucciones if ocultan el hecho de que el rango de valores con los que se compara la variable están todos relacionados de alguna manera. También puede ser difícil, a simple vista, saber si faltó alguna parte del rango. En el siguiente ejemplo se vuelve a refactorizar el ejemplo anterior para usar una instrucción switch en su lugar:

      package main
      
      import (
          "fmt"
          "math/rand"
      )
      
      func main() {
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              switch {
              case guess > target:
                  fmt.Println("Too high!")
              case guess < target:
                  fmt.Println("Too low!")
              default:
                  fmt.Println("You win!")
                  return
              }
          }
      }
      

      Con esto, se mostrará un resultado similar al siguiente:

      Output

      Enter a guess: 25 Too low! Enter a guess: 28 Too high! Enter a guess: 27 You win!

      En esta versión del juego de adivinanzas, se sustituyó el bloque de instrucciones if por una instrucción switch. Se omite el argumento de la expresión de switch, ya que solo nos interesa recopilar los condicionales juntos utilizando switch. Cada cláusula case contiene una expresión diferente que compara guess con target. Como la primera vez que sustituimos las instrucciones if por switch, ya no necesitamos las instrucciones continue porque solo se ejecutará una cláusula case. Por último, la cláusula default se encarga del caso en el que guess == target, ya que cubrimos todos los demás valores posibles con las otras dos cláusulas case.

      En los ejemplos que vimos hasta el momento, se ejecutará exactamente una instrucción caso. De vez en cuando, es posible que desee combinar los comportamientos de varias cláusulas case. Las instrucciones switch proporcionan otra palabra clave para lograr este comportamiento.

      Fallthrough

      A veces, querrá volver a utilizar el código que otra cláusula case contiene. En estos casos, es posible solicitar que Go ejecute el cuerpo de la siguiente cláusula case enumerada usando la palabra clave fallthrough. En el siguiente ejemplo, se modifica nuestro ejemplo anterior de sabores de helado para reflejar con mayor precisión nuestro entusiasmo por el helado de fresa:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
                  fallthrough
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      Veremos el siguiente resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! strawberry is great! I've never tried banana before

      Como ya lo observamos antes, definimos un segmento string para representar los sabores e iterar este usando un bucle for. La instrucción switch aquí es idéntica a la que vimos antes, pero se agrega la clave fallthrough al final de la cláusula case para “strawberry”. Esto hará que Go ejecute el cuerpo de case “strawberry”:, imprimiendo primero la cadena strawberry is my favorite!. Cuando este encuentre fallthrough, ejecutará el cuerpo de la cláusula case siguiente. Esto hará que el cuerpo de case “vanilla”, “chocolate”: se ejecute e imprima strawberry is great!.

      Los desarrolladores de Go no utilizan la palabra clave fallthrough a menudo. Normalmente, la reutilización del código mediante fallthrough se puede obtener de mejor manera definiendo una función con el código común. Por estas razones, generalmente no se recomienda utilizar fallthrough.

      Conclusión

      Las instrucciones switch nos ayudan a transmitir, a otros desarrolladores que leen nuestro código, que una serie de comparaciones están de alguna manera relacionadas entre sí. Hacen que sea mucho más fácil añadir comportamientos diferentes cuando un nuevo caso se añade en el futuro y permite garantizar que cualquier cosa que se haya olvidado se maneje de manera adecuada también con cláusulas default. La próxima vez que tenga que escribir varias instrucciones if que impliquen todas la misma variable, intente reescribirla con una instrucción switch, le resultará más sencillo volver a trabajar cuando llegue el momento de considerar algún otro valor alternativo.

      Si desea obtener más información acerca del lenguaje de programación de Go, consulte toda la serie sobre Cómo realizar codificaciones en Go.



      Source link

      Usar instrucciones break y continue cuando se trabaja con bucles en Go


      Introducción

      Usar bucles for en Go le permite automatizar y repetir tareas de forma eficiente.

      Aprender a controlar el funcionamiento y el flujo de los bucles hará posible una lógica personalizada en su programa. Puede controlar sus bucles con las instrucciones break y continue.

      Instrucción break

      En Go, la instrucción break finaliza la ejecución del bucle actual. Una instrucción break casi siempre se sincroniza con una instrucción condicional if.

      Veamos un ejemplo en el que se utiliza la instrucción break en un bucle for:

      break.go

      package main
      
      import "fmt"
      
      func main() {
          for i := 0; i < 10; i++ {
              if i == 5 {
                  fmt.Println("Breaking out of loop")
                  break // break here
              }
              fmt.Println("The value of i is", i)
          }
          fmt.Println("Exiting program")
      }
      

      Este pequeño programa crea un bucle for que se iterará mientras i sea inferior a 10.

      En el bucle for, hay una instrucción if. La instrucción if prueba la condición de i para ver si el valor es inferior a 5. Si el valor de i no es igual a 5, el bucle continúa e imprime el valor de i. Si el valor de i es igual a 5, el bucle ejecuta la instrucción break, imprime Breaking out of loop y deja de ejecutarse. Al final del programa, imprimimos Exiting program para indicar que cerramos el bucle.

      Cuando ejecutemos este código, el resultado será el siguiente:

      Output

      The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 The value of i is 4 Breaking out of loop Exiting program

      Esto muestra que una vez que se evalúa el entero i como equivalente a 5, el bucle se rompe porque se indica al programa que lo haga con la instrucción break.

      Bucles anidados

      Es importante recordar que la instrucción break solo detendrá la ejecución del bucle más interno en el que se invoca. Si tiene un conjunto de bucles anidados, necesitará una instrucción break para cada bucle, si lo desea.

      nested.go

      package main
      
      import "fmt"
      
      func main() {
          for outer := 0; outer < 5; outer++ {
              if outer == 3 {
                  fmt.Println("Breaking out of outer loop")
                  break // break here
              }
              fmt.Println("The value of outer is", outer)
              for inner := 0; inner < 5; inner++ {
                  if inner == 2 {
                      fmt.Println("Breaking out of inner loop")
                      break // break here
                  }
                  fmt.Println("The value of inner is", inner)
              }
          }
          fmt.Println("Exiting program")
      }
      

      En este programa, hay dos bucles. Aunque ambos bucles se repiten 5 veces, cada uno tiene una instrucción if condicional con una instrucción break. El bucle externo se interrumpirá si el valor de outer es igual a 3. El bucle interno se interrumpirá si el valor de inner es 2.

      Si ejecutamos el programa, veremos el siguiente resultado:

      Output

      The value of outer is 0 The value of inner is 0 The value of inner is 1 Breaking out of inner loop The value of outer is 1 The value of inner is 0 The value of inner is 1 Breaking out of inner loop The value of outer is 2 The value of inner is 0 The value of inner is 1 Breaking out of inner loop Breaking out of outer loop Exiting program

      Observe que cada vez que se interrumpe el bucle interno, no sucede lo mismo con el externo. Esto es porque break solo interrumpirá el bucle más interno desde el que se invoca.

      Hemos visto cómo el uso de break detendrá la ejecución de un bucle. A continuación, veremos la forma de continuar la iteración de un bucle.

      Instrucción continue

      La instrucción continue se usa cuando se busca omitir la parte restante del bucle, volver a la parte superior de este y continuar con una nueva iteración.

      Como en el caso de la instrucción break, la instrucción continue se utiliza comúnmente con una instrucción if condicional.

      Usando el mismo programa de bucle for que en la sección Instrucción break, emplearemos la instrucción continue en vez de break:

      continue.go

      package main
      
      import "fmt"
      
      func main() {
          for i := 0; i < 10; i++ {
              if i == 5 {
                  fmt.Println("Continuing loop")
                  continue // break here
              }
              fmt.Println("The value of i is", i)
          }
          fmt.Println("Exiting program")
      }
      

      La diferencia al usar la instrucción continue en vez de una instrucción break radica en que nuestro código continuará a pesar de la interrupción cuando la variable i se evalúe como equivalente a 5. Veamos el resultado:

      Output

      The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 The value of i is 4 Continuing loop The value of i is 6 The value of i is 7 The value of i is 8 The value of i is 9 Exiting program

      Aquí vemos que la línea The value of i is 5 nunca se aparece en el resultado, pero el bucle continúa después de ese punto para imprimir líneas para los números 6 a 10 antes de cerrarse.

      Puede usar la instrucción continue para evitar código condicional profundamente anidado o para optimizar un bucle eliminando los casos frecuentes que desee rechazar.

      La instrucción continue hace que un programa omita determinados factores que surgen dentro de un bucle, pero luego continuará con resto de este.

      Conclusión

      Las instrucciones break y continue en Go le permitirán usar los bucles for de forma más eficaz en su código.



      Source link