Go: Variables (Part 2)

This is a second post on Go programming language. You can read first post at - here.

Go is not just compiled programming language, but it is also statically typed programming language. You need to define a variable with its type. For example,

var x int

If this syntax looks a little awkward for you, read it in the way that makes sense. For example, the above declaration can be read as, define a variable x with type integer.

If the variable has initial value, you can assign it using assignment operator.

var x int = 2

You can define multiple variables using comma operator.

var x, y int

Again you can read these declaration as, defining variable x and y with type integer. If you know the initial values of x and y, then you can initialize them in just a single line using comma operator on right side of assignment operator.

var x, y int = 2, 3

Here, x will get 2 and y will get 3.

Go has couple of variation in integers. For example, int, int8, int16, int32 and int64. All these types save integers but the first save small number of integer value where as last save really big number of integer value. If you know that your variable never will have negative values then you can double the length of these integers by using unsigned integers such as uint, uint8, uint16, uint32 and uint64.

Like integer, you can also define variable with type floating point numbers. For floating points number, you need to use float32 or float64 type. For example,

var pi float32
var r float64

There is no such type with name float. So, please remember this.

While talking about the types, the other two popular types are string and boolean with string and bool type. You can define the variables with these types as follow.

var firstName string = "Bruce"
var isSupernatural bool = false
var lastName string
var married bool

Did you notice, how many times I wrote var? Four, right. We can eliminate this repetition by using () as follows.

var (
    firstName string = "Bruce"
    isSupernatural bool = false
    lastName string
    married bool
)

Much better, right? Let's create a new program with name var.go and define variables with each of these types. So far we know - integer, float, string and boolean. You know the basic needed code -

package main

func main() {

}

Let's define the variable with type integer.

package main

func main() {
    var x, y int = 2, 3
}

Let's run this program and see what happen.

$ go run hello.go
# command-line-arguments
./var.go:4:6: x declared and not used
./var.go:4:9: y declared and not used

We get errors! In Go, if you define variables, you must have to use it. Otherwise, your program wouldn't run. Even simple printing will work.

package main

import "fmt"

func main() {
    var x, y int = 2, 3

    fmt.Println(x, y)
}

So, what I did here is just use Println() function to print the value of defined variables in terminal. Also, Println() function is part of fmt package so that I imported it. Finally, just print the values of these variables by passing them as arguments. Let's run the program again.

$ go run var.go
2 3

So, we get the output! But, hey have you notice, I haven't added any spaces inside of Println() and still there is space between in output. This is because of Println() function. We'll talk about this space later because we are not currently interested in this space issue. For us, it looks good for now.

You can also define floating point variables.

package main

import "fmt"

func main() {
    var pi, r float64
    pi = 3.14
    r = 10

    fmt.Println(pi, r)
}

Now, if we run the program again -

$ go run var.go
3.14 10

Let's define variables with type string.

package main

import "fmt"

func main() {
    var (
        firstName string = "Bruce"
        lastName string = "Wayne"
    )

    fmt.Println(firstName, lastName)
}

Running this program produce the following output.

$ go run var.go
Bruce Wayne

Finally, let's define variables with type boolean.

package main

import "fmt"

func main() {
    var isMailSent bool

    fmt.Println(isMailSent)
}

If I run this program, it produce the following output.

$ go run var.go
false

From where this false came? In Go, when you define a variable, it set the initial value to zero values. The zero values for each type is different. For example, for integer it is 0. For floating point number it is 0.0. For string, its empty string "" and for Boolean, its false. Hence, we got the false. Go it?

That's it for the variables. I mean there are lot more to understand in Go for variables. But, as of now, what we learned is enough. We need to manipulate the values of defined variables, right? Otherwise what is the fun in doing programming?

Any questions?

The syntax for defining variables is little odd, any reason?: This "odd" syntax first introduce in Haskell programming language where they define variable like x:int or x has type integer. Because, they think defining a variable like int x is mistake in modern days. In old days when memory was limited, compiler first need to know the type of variable so that compiler can provide the memory based on type to upcoming variable x. That's not the case any more in modern days. So, let's define the variable in the way that make sense and x:int or var x int make sense if you read it like English - define a variable x with type int.

When you define r as floating point number, it print 10. I think it suppose to print 10.0: It does not matter what we think. But, still I can guarantee you that r is floating point number even though it print or evaluated as 10. To check the type of variable, you can use TypeOf() method from reflect package. Let me run one example for you -

package main

import "fmt"
import "reflect"

func main() {
    var r float64 = 10
    
    fmt.Println(reflect.TypeOf(r))
}

Now, if we run this program, it print -

$ go run var.go
float64

What is the difference between int and uint?: The main difference between these two types are unsigned. The first one accept negative number but second one not. Second one only accept positive numbers and due to that you almost get double size. Let's say you can save 7 numbers which are -3, -2, -1, 0, 1, 2, and 3. So, the range or limit for you is -3 to 3. But, I told you that you will never get negative number. In that case you can utilize those negative values on positive size and increase your limit as 0, 1, 2, 3, 4, 5 and 6. Now, with unsigned, you can save upto 6 where as previously you were saving upto 3. Got it?

Is it possible to run the program without using define variables?: I showed you that it is not possible. They have decided for language. If you are asking for some flags so that you can disable this type of errors, sorry there is no flag. You must have to use the define variable, otherwise don't define it at the first place.