Llegado a este punto, asumo que ya has leído mi publicación anterior, en caso contrario te invito a hacer clic aquí, o que ya tienes conocimiento al menos básico del lenguaje Go. Comencemos con la estructura de decisión más elemental, el bien conocido if.
package main
import "fmt"
func main() {
encendido := true
if encendido {
fmt.Println("Está encendido")
}
}
Notarán que es muy parecido a la sintaxis de C o a la mayoría de los lenguajes inspirados por este, la principal diferencia es que los paréntesis alrededor de la condición son opcionales, pero de igual forma comprueba si dicha condición es verdadera y en caso de que así sea, realiza las instrucciones que se encuentran dentro de sus respectivas llaves, en caso contrario las instrucciones son ignoradas, nada raro hasta el momento. Bastante útil, pero ¿Que sucede si necesito que se ejecute una instrucción en caso de que a condición resulte falsa?
package main
import "fmt"
func main() {
encendido := false
if encendido {
fmt.Println("Está encendido")
} else {
fmt.Println("Está apagado")
}
}
Perfecto, la confiable instrucción else al rescate. En este caso la condición sea evaluada como falsa, las instrucciones dentro del if son ignoradas y se ejecutan las del else. Si esto te resulta confuso te recomiendo que busques un tutorial, curso o libro de programación básica, el propósito de estás publicaciones es introducirlos al lenguaje de programación Go, no a la programación en general, aún así creo que que no es demasiado complicado. Otra caso frecuente es necesitar comprobar más de una condición, fácilmente podrías anidar condicionales (colocar otro if dentro del bloque del else, por ejemplo), pero dependiendo del caso podría ser mas adecuado simplemente usar la estructura else-if, aunque será necesario recurrir a un ejemplo diferente al anterior.
package main
import "fmt"
func main() {
var edad uint8 = 180
if edad > 150 {
fmt.Println("¿Eres inmortal?")
} else if edad >= 18 {
fmt.Println("Eres mayor de edad")
} else {
fmt.Println("Eres menor de edad")
}
}
Hasta el momento nada fuera de lo común, me parece, ahora veamos algo Go.
package main
import "fmt"
func main() {
if edad := -5; edad > 150 {
fmt.Println("¿Eres inmortal?")
} else if edad >= 18 {
fmt.Println("Eres mayor de edad")
} else if edad < 18 && edad > 0 {
fmt.Println("Eres menor de edad")
} else {
fmt.Println("Edad fuera del rango")
}
}
Así es, if permite ejecutar una declaración corta antes de comenzar a evaluar las condiciones, es importante resaltar que el ámbito de esa variable está limitado a la propia estructura condicional, intentar acceder a ella desde fuera generará un error al momento de compilar.
Como alternativa a múltiples else-if contamos con switch.
package main
import "fmt"
func main() {
switch dias := 1; dias {
case 0:
fmt.Println("Lunes")
case 1:
fmt.Println("Martes")
case 2:
fmt.Println("Miercoles")
case 3:
fmt.Println("Jueves")
case 4:
fmt.Println("Viernes")
case 5:
fmt.Println("Sabado")
case 6:
fmt.Println("Domingo")
default:
fmt.Println("Desconocido")
}
}
package main
import "fmt"
func main() {
var edad uint8 = 18
switch {
case edad >= 150:
fmt.Println("¿Eres inmortal?")
case edad >= 18:
fmt.Println("Eres mayor de edad")
default:
fmt.Println("Eres menor de edad")
}
}
Dependiendo de la ocasión es una opción elegante y eficiente, también existen variantes del switch, pero en este momento me gustaría resaltar algo, si aún no lo notan, no es necesario utilizar break al final de cada caso para evitar que continúe ejecutando los posteriores, genial, pero si necesitas que lo haga, basta con colocar la palabra reservada fallthrough al final del caso para que continúe con el siguiente.
Suficiente de condicionales, veamos los ciclos, probablemente se lleven una sorpresa, pero el único constructor para ciclos en Go es for, no se preocupen, es el único que van a necesitar.
package main
import "fmt"
func main() {
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}
No hay mucho que decir, el ciclo for de toda la vida para aquellos que conozcan lenguajes como C, Java, JavaScript, entre otros. Lo único novedoso sería el hecho de que, al igual que con los condicionales, no son necesarios los paréntesis.
package main
import "fmt"
func main() {
var i = 0
for i < 10 {
fmt.Println(i)
i++
}
}
package main
import "fmt"
func main() {
for indice, letra := range "hola mundo" {
fmt.Println(indice, string(letra))
}
}
Como mencioné anteriormente, for es el único constructor de ciclos en Go, pero es bastante flexible. Y si se preguntan como hacer un ciclo infinito intencional.
package main
import "fmt"
func main() {
for {
fmt.Println("Hola")
}
}
Personalmente me resulta de lo más práctico, y es del tipo de pequeños detalles que enamoran. Ahora uno no tan común.
Defer permite realizar una declaración que se ejecutará al final de la función, antes del retorno, sin importar en que orden fue declarada. Veamos un ejemplo.
package main
import "fmt"
func main() {
defer fmt.Println("primera") // Se imprime al final
defer fmt.Println("segunda") // Se imprime justo después del "Hola mundo"
fmt.Println("Hola mundo")
}
Interesante, si te preguntas que utilidad tiene, es perfecta para cerrar recursos, como archivos y conexiones a bases de datos, en Go se acostumbra usar justo debajo de la declaración donde se abre el recurso para no olvidar cerrarlo, sabes que de todas formas se ejecutará al final. Otra cosa a tener en cuenta respecto a defer es que si hay mas de uno en la función se ejecutarán en el orden inverso en el que fueron declarados.
La verdad esta publicación resultó bastante más extenso de lo que tenía pensado, espero que disfrutaran leyendo el contenido tanto como yo escribiéndolo y, aún mas, que se interesen por conocer más de este magnifico lenguaje de programación. Les aseguro que aún hay mucho por aprender de Go, yo aún tengo mucho pero mucho que aprender y si les ha gustado o no, por favor, dejen sus comentarios para continuar compartiendo contenido y cada vez de mejor calidad. Saludos y hasta la próxima.