Go Variables
Tags: go
Published: 2021-11-06 11:59:04

#####How to declare variables?

There are 3 ways to declare variables:

######1. Declare using `var` keyword, variable name & type

To declare a variable you will use the `var` keyword, followed by the `the variable name` and then `the variable type`.See the example below:

```
var i int
```
you can then assign the variable using an equal sign
```
i = 20
```
Type this in your [Playground](https://play.golang.org/) and run it:
```
package main

import (
	"fmt"
)

func main() {
	var i int
	i = 30
	fmt.Println(i)
}

//prints 30

```
######2. Declare using `var` keyword, variable name , and assign.

To declare a variable you will use the `var` keyword, followed by the `the variable name` and then `the variable type` and then assign the variable using an equal sign .See the example below:

```
var i int = 20
```
Type this in your [Playground](https://play.golang.org/) and run it:
```
package main

import (
	"fmt"
)

func main() {
	var i int = 20
	fmt.Println(i)
}

//prints 20
```
###### 3 Declare without using `var` keyword and variable type

The go compiler provides for automatic type detection. To declare such, do as below:
```
i:=42
``` 
Now run this in your playground:
```
package main
import (
	"fmt"
)

func main() {
	i := 42
	fmt.Println(i)
}

//prints 42
```
The compiler automatically figures the type.

##### When should you use the different variable declaration?

U can use `var i int` when you want to use a variable without initializing it. For example where you want to assign the value in a for loop.
U can use `var i int =20` when you want to have more control of your variable.
U can use `i := 20` when you are comfortable with automatic type detection. As you work with go, u will note that the format `:=` doesn't detect `float 32` types and instead detects them as integers. Also this can't be used in package level variables as you will see later in this article. Case in example, run this in your playground:

```
package main

import (
	"fmt"
)

func main() {
	i := 32
	fmt.Printf("%v %T", i, i)
}

//prints 32 int
```
Then run this:
```
package main

import (
	"fmt"
)

func main() {
	var i float32 = 32
	fmt.Printf("%v %T", i, i)
}

//prints 32 float32
```

**Note: You can also declare a variable at the package level. However in such cases you cant use `:=` automatic type detection.**
```
package main

import (
	"fmt"
)

//package level variable
var i float32 = 32

func main() {
   fmt.Printf("%v %T", i, i)
}

//prints 32 float32
```
##### Declaring variable as a block

Let say for example you have want to describe a  person, you would have to declare the following variables: Full names , gender , age ,Location as below:

```
package main

import (
	"fmt"
)

var name string = "Samuel Bazeng"
var gender string = "Male"
var age int = 24
var location string = "Nairobi"

func main() {

	fmt.Println(name)
	fmt.Println(gender)
	fmt.Println(age)
	fmt.Println(location)

}
```
But as Go is designed to be clear and concise, we dont need to keep writing var on each variable we can simply wrap all variables in a block:

```
var(
name string = "Samuel Bazeng"
gender string = "Male"
age int = 24
location string = "Nairobi"
)
```
When you run the code below it still works:

```
package main

import (
	"fmt"
)
var(
name string = "Samuel Bazeng"
gender string = "Male"
age int = 24
location string = "Nairobi"
)

func main() {

	fmt.Println(name)
        fmt.Println(gender)
        fmt.Println(age)
        fmt.Println(location)

}
```
This way of declaring variable can also help in grouping variables by function.

#####Reassigning Variable
In case of reassignment, Go considers the variable within the innermost scope. This is called `shadowing`. Case in example , the code below will print 10 instead of 20.

```
package main

import (
	"fmt"
)
var i int =20;
func main() {
	var i int =10
	fmt.Println(i)
}
```
**Note:** You cant use  `:=` to redeclare a variable, it will result to an error.

#####Important Points To Note While Working With Variables:

1. Every variable declared must be used. Failure to do so results into an error. Try this on your playground.
```
package main

import (
	"fmt"
)
var i int =20;
func main() {
	var i int =10
	k := 11
	fmt.Println(i)
	
}

// ./prog.go:9:2: k declared but not used
//Go buid failed
```
##### Naming Variables
There are two sets of rules you need to keep track of:
1 .How naming controls the visibility of variables.
- **Lower case** variables are scoped to the package. Any file in the same package can access the variable. For example the variable `var i int =20` in the example below:
```
package main

import (
	"fmt"
)

var i int = 20

func main() {
	var i int = 10
	fmt.Println(i)
}

```
- **Upper case** variables are exported and are available globally.For example the variable `var I int =20` in the example below:
```
package main

import (
	"fmt"
)

var I int = 20

func main() {
	var I int = 10
	fmt.Println(I)

}
```
- Variable defined in a block are scoped to the block and aren't visible outside the block.For example 
```
func main() {
	var i int = 10
	fmt.Println(i)
}
```
2.Naming Conventions

There are a few rules we should follow:

1. The length of a variable name should reflect its  lifeline.
`var i int` is perfect for a for loop and other places where you don't have to keep it in your head for a long time. In a case where you will use a variable quite often its better to have a longer name example `var firstName string`
2. For a package level variable its good to use a verbose name and clear enough for someone who is outside the source life to understand.
3. Use Pascal or Camel Case
```
//pascal case
 var ThisShouldBePascalCase string = "Pascal"
 var thisShouldBeCamelCase string = "camelCase"
```

#####Variable Typecasting / Conversion

Type conversion happens when we assign a value of one data type to another data type. There are two types of Data type conversion available in Programming.

- **Implicit Type Conversion:** Implicit type conversion, also known as coercion, is an automatic type conversion by the compiler. Some languages allow or even require compilers to provide coercion. Golang does not support implicit type conversion because of its robust type system.

- **Explicit Type Conversion:** Explicit type conversion is special programming instruction that specifies what data type to treat a variable as in a given expression. For example, casting will ignore “extra” information (but never adds information to the type being cast).

Go uses `Explicit Type Conversion`

######Syntax of type conversion
```
newDataTypeVariable = newType(oldDataTypeVariable)
```
For example:
```
package main

import (
	"fmt"
)

func main() {
	var i int = 10
	var j float32
	j = float32(i)
	fmt.Printf("%v %T", j, j)

}

//prints 10 float32
```
An example where typecasting ignores “extra” information:
```
package main

import (
	"fmt"
)

func main() {
	var i float32 = 10.5
	var j int
	j = int(i)
	fmt.Printf("%v %T", j, j)

}

//prints 10 int ignoring .5
```
######String Conversions

String conversion are a bit different. For example try running the code below results into an error:
```
package main

import (
	"fmt"
)

func main() {
	var i int = 10
	var j string
	j = string(i)
	fmt.Printf("%v %T", j, j)

}

//conversion from int to string yields a string of one rune, not a string of digits (did you mean fmt.Sprint(x)?)

```
You can use:
```
package main

import (
	"fmt"
)

func main() {
	var i int = 10
	var j string
	j = fmt.Sprint(i)
	fmt.Printf("%v %T", j, j)
}

```
or you can also use the `strconv` package.
```
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var i int = 10
	var j string
	j = strconv.Itoa(i)
	fmt.Printf("%v %T", j, j)

}

```