# Go Variables

## Syntax

• var x int // declare variable x with type int
• var s string // declare variable s with type string
• x = 4 // define x value
• s = "foo" // define s value
• y := 5 // declare and define y inferring its type to int
• f := 4.5 // declare and define f inferring its type to float64
• b := "bar" // declare and define b inferring its type to string

## Basic Variable Declaration

Go is a statically typed language, meaning you generally have to declare the type of the variables you are using.

``````// 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
``````

## Multiple Variable Assignment

In Go, you can declare multiple variables at the same time.

``````// 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`
``````

If a function returns multiple values, you can also assign values to variables based on the function's return values.

``````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
``````

## Blank Identifier

Go will throw an error when there is a variable that is unused, in order to encourage you to write better code. However, there are some situations when you really don't need to use a value stored in a variable. In those cases, you use a "blank identifier" `_` to assign and discard the assigned value.

A blank identifier can be assigned a value of any type, and is most commonly used in functions that return multiple values.

Multiple Return Values

``````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
}
``````

Using `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)
}

}
``````

## Checking a variable's type

There are some situations where you won't be sure what type a variable is when it is returned from a function. You can always check a variable's type by using `var.(type)` if you are unsure what type it is:

``````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
}
``````