Go
Variables

Sintaxis

• var x int // declara la variable x con el tipo int
• var s string // declarar variable s con tipo string
• x = 4 // define el valor de x
• s = "foo" // define el valor de s
• y: = 5 // declara y define y deduce su tipo a int
• f: = 4.5 // declara y define f inferiendo su tipo a float64
• b: = "bar" // declara y define b inferiendo su tipo a cadena

Declaración Variable Básica

Go es un lenguaje de tipo estático, lo que significa que generalmente tiene que declarar el tipo de las variables que está utilizando.

// Basic variable declaration. Declares a variable of type specified on the right.
// The variable is initialized to the zero value of the respective type.
var x int
var s string
var p Person // Assuming type Person struct {}

// Assignment of a value to a variable
x = 3

// Short declaration using := infers the type
y := 4

u := int64(100)    // declare variable of type int64 and init with 100 
var u2 int64 = 100 // declare variable of type int64 and init with 100

Asignación de variables múltiples

En Go, puedes declarar múltiples variables al mismo tiempo.

// You can declare multiple variables of the same type in one line
var a, b, c string

var d, e string = "Hello", "world!"

// You can also use short declaration to assign multiple variables
x, y, z := 1, 2, 3

foo, bar := 4, "stack" // `foo` is type `int`, `bar` is type `string`

Si una función devuelve varios valores, también puede asignar valores a las variables en función de los valores de retorno de la función.

func multipleReturn() (int, int) {
    return 1, 2
}

x, y := multipleReturn() // x = 1, y = 2

func multipleReturn2() (a int, b int) {
    a = 3
    b = 4
    return
}

w, z := multipleReturn2() // w = 3, z = 4

Identificador en blanco

Go lanzará un error cuando haya una variable que no esté en uso para animarte a escribir un código mejor. Sin embargo, hay algunas situaciones en las que realmente no es necesario utilizar un valor almacenado en una variable. En esos casos, utiliza un "identificador en blanco" _ para asignar y descartar el valor asignado.

A un identificador en blanco se le puede asignar un valor de cualquier tipo, y se usa más comúnmente en funciones que devuelven valores múltiples.

Valores de retorno múltiples

func SumProduct(a, b int) (int, int) {
    return a+b, a*b
}

func main() {
    // I only want the sum, but not the product
    sum, _ := SumProduct(1,2) // the product gets discarded
    fmt.Println(sum) // prints 3
}

Utilizando range

func main() {

    pets := []string{"dog", "cat", "fish"}

    // Range returns both the current index and value
    // but sometimes you may only want to use the value
    for _, pet := range pets {
        fmt.Println(pet)
    }

}

Comprobando el tipo de una variable

Hay algunas situaciones en las que no estará seguro de qué tipo es una variable cuando se devuelve desde una función. Siempre puede verificar el tipo de una variable usando var.(type) si no está seguro de qué tipo es:

x := someFunction() // Some value of an unknown type is stored in x now

switch x := x.(type) {
    case bool:
        fmt.Printf("boolean %t\n", x)             // x has type bool
    case int:
        fmt.Printf("integer %d\n", x)             // x has type int
    case string:
        fmt.Printf("pointer to boolean %s\n", x) // x has type string
    default:
        fmt.Printf("unexpected type %T\n", x)     // %T prints whatever type x is
}