package main

import "fmt"

func main () {
     const n int = 42
     var h int = 0
     var v int
     
     fmt.Print ("Adivina en que número estoy pensando ? ")
     fmt.Scanf ("%d", &v)
     
     if v < 0 {
        fmt.Println ("Solo números positivos")
    return 
     }
     
     if v == n {
        fmt.Println ("Bien Hecho!")
     } else {
       fmt.Println ("Sigue Probando!");
       fmt.Print ("El número es ");
       if v > n {fmt.Println ("MENOR")} else {fmt.Println ("MAYOR")}
       
       if h := v - n; h < 0 { h = -h}
       fmt.Print ("PISTA : ")
       if h < 5 { fmt.Println ("TE QUEMAS!!!")
    } else if h < 10 { fmt.Println ("CALIENTE!!!")
    } else if h < 15 { fmt.Println ("TEMPLADO")
    } else { fmt.Println ("FRIO")   }
     }    
}

Go es bastante limitado en lo que a expresiones condicionales se refiere. Simplemente ofrece la clásica construcción if-else sin muchas florituras. Go no necesita encerrar las condiciones entre paréntesis ni nada por el estilo, si bien los paréntesis se pueden utilizar para indicar la precedencia de ciertas operaciones con expresiones condicionales complejas. Como en la mayoría de lenguajes es perfectamente correcto encadenar un nuevo bloque if-else en la clausula else de un cualquier expresión condicional.

No proporciona versiones reducidas del comando como Perl o Python, nisiquiera un operador ternario.

Lo que si podemos hacer es preceder las condiciones con una instrucción. En el programa de ejemplo utilizamos esto para calcular el valor absoluto.

 if h = v - n; h < 0 { 
    h = -h
}

El código de arriba primero inicializa el valor de h y acto seguido evalúa la condición. Esta construcción puede mejorar la lectura del código especialmente en lo que se refiere al manejo de errores. Por ejemplo, el siguiente código, utiliza la inicialización para intentar abrir un fichero e inmediatamente comprobar si se ha producido un error:

if file, err = os.Open("fichero"); err == nil {
// Fichero abierto con exito
} else {
// Error al abrir el fichero
}

Pero no hemos hablado todavía ni de ficheros ni de los valores retornados por funciones…. Bueno, cuando leas sobre eso, el fragmento de código de arriba tendrá sentido :).

Go también ofrece una instrucción switch la cual, en su forma más sencilla, es idéntica a su homónima en C/C++/Java, es decir, el comando switch acepta un valor y nos permite asignar código a cada posible valor utilizando la palabra clave case.

Sin embargo, Go presenta ciertas peculiaridades. La primera es que es posible expresar varios casos en un mismo case separados por comas:

switch v {
    case 1,2:
        fmt.Println ("Uno o Dos")
    case 3:
        fmt.Println ("Tres")
    default:
        fmt.Println("Otro")
}

Como podéis ver, no es necesario utilizar la palabra clave break para evitar que el flujo de cada case para evitar que el programa continúe en los casos siguientes, aunque todavía es posible permitir que el flujo continúe normalmente utilizando la palabra clave fallthrough. En otras palabras, en Go, el comportamiento por defecto es mantener los casos separados y tenemos que indicar explícitamente si queremos continuar en el siguiente caso.

switch v {
    case 1,2:
        fmt.Println ("Uno o Dos")
    case 3:
        fmt.Println ("Tres")
        fallthrough
    default:
        fmt.Println("Otro caso y caso Tres")
}

Otra peculiaridad es que la expresión sobre la que aplicamos el switch indica el tipo de datos a utilizar en los cases, los cuales no están limitados a enteros como en otros lenguajes. Es incluso posible ejecutar switch sobre el tipo de una variable para averiguar su tipo en tiempo de ejecución:

    var i interface{} = b;
    switch t := i.(type) {
    case bool:
        fmt.Println ("Booleano")
    case int:
        fmt.Println ("Entero")
    default:
        fmt.Printf ("Tipo %T\n", t)
    }

Si no especificamos ninguna variable, switch se comporta como un bloque if-else, y por tanto podemos utilizar expresiones en los distintos case.

    switch  {
    case (v > 10 && v < 20 ):
        fmt.Println ("mayor que 10")
    case (v < 10 && v > 0):
        fmt.Println ("el valor es menor que 10")
    default:
        fmt.Println ("Otro")
    }

Utilizando esta forma, podríamos haber escrito la pista de nuestro programa de la siguiente forma:

switch {
    case h < 5  : fmt.Println ("TE QUEMAS!!");
    case h < 10 : fmt.Println ("CALIENTE");
    case h < 15 : fmt.Println ("TEMPLADO");
    default     : fmt.Println ("FRIO");
}

Go soporta booleanos con el tipo bool y los valores true y false. En caso de no asignar ningún valor a una variable de tipo bool está se inicializará con el valor false.

Go soporta constantes nativamente utilizando la palabra clave const. Para asignar valores a las constantes se usa el operador de asignación = . El operador := que permite declarar y asignar variables no se puede usar con las constantes.

Resumen

• Soporta if ... [else if] ...[else] ...
• Soporta operador terciario (asignación + condición) if asignacion; condicion {cmd}
• Soporta booleanos: bool
• Soporta switch
• Soporta constantes nativamente (const CONSTANTE = val )