06. Go to go: condicionales

Publicado por

This one?

Regularmente cuando programamos nuestros algoritmos, llega un momento donde las acciones que se deben realizar dependerán un poco o mucho del valor o el estado de alguna variable (o constante) que especifiquemos. Por ejemplo: si nuestro programa está destinado a realizar unos cálculos con valores de entrada del usuario, y dependiendo de la magnitud de ese cálculo se sume o reste algún valor N para acotar el resultado; en ese caso es necesario recurrir a sentencias condicionales que verifiquen la magnitud de nuestra variable. ¡Comenzamos!

No! That one!

Las sentencias condicionales regularmente siguen el siguiente formato para la mayoría de los lenguajes de programación:

condicionales-golang
Condicionales (Go)

Cuando se encuentra una condición, ésta es evaluada; si el resultado es verdadero (true), entonces continúa con el código que se haya indicado; si por otro lado el resultado de evaluar la condición es falso (false), esa sección de código no se ejecuta y continúa el resto del programa. También es posible especificar una serie de sentencias que solamente se ejecute cuando la condición no se cumpla.

Sentencia if

La sentencia if (si, en inglés) verifica que la expresión que se le indique sea verdadera para entonces ejecutar la sección de código destinada solamente a ejecutarse cuando eso suceda. Si la condicional es falsa, se continúa ejecutando el código de forma secuencial.

Sentencia "if" (Go)
Sentencia “if” (Go)

Ejemplo:

package main
import "fmt"

func main() {
  /*variable local de tipo entero*/
  var calificacion int = 5

  /*Sentencia if, que verifica si calificación es menor a 6*/
  if calificacion < 6 {
    /*Si la condición se cumple, imprime*/
    fmt.Println("Reprobaste")
  }

  fmt.Println("Tu calificación fue de: ", calificacion)

}

Salida:

Reprobaste
Tu calificación fue de: 5

A diferencia de C, en Go es obligatorio incluir las sentencias después de if entre llaves independientemente de la cantidad de líneas que haya.

Sentencia if-else

Cuando necesitamos que el programa ejecute ciertas sentencias cuando la condición es verdadera, pero a su vez necesitamos que ejecute otras sentencias solamente cuando la condición es falsa, necesitamos una sentencia condicional if-else.

El siguiente diagrama ilustra el funcionamiento de if-else:

Sentencia "if/else" (Go)
Sentencia “if/else” (Go)

Ejemplo:

package main
import "fmt"

func main() {
  /*variable local de tipo entero*/
  var calificacion int = 7

  /*Sentencia if, verifica calificación menor 6*/
  if calificacion < 6 {
    /*Si la condición se cumple*/
    fmt.Println("Reprobaste")
  }else{
    /*Si la condición no se cumple*/
    fmt.Println("Aprobaste")
  }

  fmt.Println("Tu calificación fue de: ", calificacion)
}

Salida:

Aprobaste
Tu calificación fue de: 7

Debe tenerse especial cuidado con la sentencia else puesto que si no se le localiza en seguida de la llave de cierre de if, podría generar un error sintáctico:

if calificacion < 6{
  /*Si la condición se cumple*/
  fmt.Println("Reprobaste")
}

else{
  /*unexpected semicolon or newline before else*/
  fmt.Println("Aprobaste")
}

Es posible trabajar con múltiples condiciones que se verifiquen en cadena cuando la anterior no satisface por medio de else if y de ese modo verificar múltiples escenarios usando solamente sentencias if. Sin embargo debe de tenerse en cuenta que:

  • Un if puede tener 0 o 1 else que funciona para señalar las sentencias que se ejecutan cuando no se cumplió ninguna de las condiciones anteriores.

 

  • Un if puede tener de 0 a N else if siempre y cuando no estén después de un else (ya que el else, en caso de que exista, debe ser la sentencia final).

 

Si un else if se cumple, ninguno de los siguientes será siquiera revisado, continúa la ejecución del resto código.

El siguiente ejemplo ilustra el funcionamiento:

package main
import "fmt"

func main() {
  /*variable local de tipo entero*/
  var calificacion int = 9

  /*Sentencia if, verifica calificación menor a 6*/
  if calificacion < 6 { /*Si la condición se cumple*/ fmt.Println("Reprobaste.") }else if calificacion >= 6 && calificacion <= 8 {
    /*Segunda condición*/
    fmt.Println("Aprobaste.")

  }else if calificacion == 9{
    /*Tercera condición*/
    fmt.Println("Aprobaste. Te fue muy bien.")

  }else{
    /*Si ninguna de las anteriores se cumplió*/
    fmt.Println("Felicidades. Aprobaste con calificación perfecta")
  }

  fmt.Println("Tu calificación fue de: ", calificacion)
}

Salida:

Aprobaste. Te fue muy bien.
Tu calificación fue de: 9

Sentencia switch

La sentencia switch permite evaluar una variable de prueba contra una lista de valores conocidos como casos (case). En Go un switch puede ser de dos tipos posible:

  • Expresión – Los casos contienen expresiones que son comparadas con el valor de la variable de prueba.

 

  • Tipo – Los casos contienen un tipo de dato que es comparado con el tipo de dato de la variable de prueba.

 

El siguiente diagrama muestra su funcionamiento:

Sentencia "switch" (Go)
Sentencia “switch” (Go)

Switch de expresiones

Las siguientes reglas aplican para los switch que evalúan expresiones:

  • Si no se pasa una expresión, el valor por defecto es true.
  • Puede haber cualquier cantidad de casos siempre y cuando cada caso esté seguido de al menos un valor contra el cual comparar, y dos puntos.
  • Si se usa una expresión constante para un caso, debe de ser del mismo tipo que el valor de prueba, y debe de ser una constante o una literal.
  • Cuando la variable evaluada es igual a un caso, el código después de los dos puntos se ejecuta. No se utiliza break para terminar el caso.
  • Puede haber un caso por defecto (default) para ejecutarse cuando no se cumple ninguno de los otros casos. El caso por defecto debe de ir al final y tampoco necesita break.

 

Ejemplo:

package main
import "fmt"

func main() {
  /*variable local de tipo entero*/
  var hora int = 10

  /*Se pasa hora como variable de prueba*/
  switch hora{
    /*Si hora coincide con alguna de las literales especificadas*/
    case 1, 2, 3, 4: fmt.Println("Aún es temprano")
    case 5, 6, 7: fmt.Println("Está atardeciendo")
    case 8: fmt.Println("Acaba de oscurecer")
    case 9, 10, 11: fmt.Println("Ya es tarde")
    default: fmt.Println("Es demasiado tarde")
  }
}

Salida:

Ya es tarde

Switch de tipo

El funcionamiento y estructura es similar al switch de expresiones. Las siguientes reglas aplican para switch de tipos:

  • La expresión usada en una sentencia debe de ser una variable o una interface (interfaz) de tipo.
  • Puede haber cualquier número de casos en un switch. Cada uno es seguido por el valor contra el cual comparar y dos puntos.
  • El tipo de dato para un caso debe ser el mismo tipo de dato que la variable de prueba, así como debe de ser de un tipo válido.
  • Cuando la variable de prueba es igual a un caso, se ejecuta dicho caso y los demás no son verificados. No es necesario un break.
  • Puede haber un caso por defecto (default) para ejecutarse cuando no se cumple ninguno de los otros casos. El caso por defecto debe de ir al final y tampoco necesita break.

 

Ejemplo:

package main
import "fmt"

func main() {
  /*variable interface sin tipo asignado*/
  var x interface{}
  switch x.(type){ /*Retorna el tipo de x*/
    /*Casos*/
    case nil: fmt.Println("Es una variable tipo nil")
    case int: fmt.Println("Es una variable tipo int")
    case float64: fmt.Println("Es una variable tipo float64")
    case int64: fmt.Println("Es una variable tipo int64")
    default: fmt.Println("No es ninguno de los tipos anteriores")
  }
}

Salida:

Es una variable tipo nil

Finalizando…

A lo largo de este capítulo hemos estudiado las sentencias condicionales de Go para aprovecharlas al momento de crear nuestros programas. Cabe aclarar que existe una sentencia más (select) pero será abordada más adelante. Sin más que agregar me despido.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *