Part 4: Types

This is the tutorial number 4 in our Golang tutorial series.

Please read Golang tutorial part 3: Variables of this series to learn about variables.

The following are the basic types available in go

  • bool
  • Numeric Types
    • int8, int16, int32, int64, int
    • uint8, uint16, uint32, uint64, uint
    • float32, float64
    • complex64, complex128
    • byte
    • rune
  • string

bool

A bool type represents a boolean and is either true or false. Please run the program below

package main

import "fmt"

func main() {  
    var a bool = true
    b := false
    fmt.Println("a:", a, "b:", b)
    c := a && b
    fmt.Println("c:", c)
    d := a || b
    fmt.Println("d:", d)
}

Here a is assigned to true and b is assigned a false value.

c is assigned the value of a && b. The && operator returns true only when both a and b are true. So in this case c is false.

The || operator returns true when either a or b is true. In this case d is assigned to true since a is true. We will get the following output for this program.

a: true b: false  
c: false  
d: true  

Signed integers

int8: represents 8 bit signed integers
size: 8 bits
range: -128 to 127

int16: represents 16 bit signed integers
size: 16 bits
range: -32768 to 32767

int32: represents 32 bit signed integers
size: 32 bits
range: -2147483648 to 2147483647

int64: represents 64 bit signed integers
size: 64 bits
range: -9223372036854775808 to 9223372036854775807

int: represents 32 or 64 bit integers depending on the underlying platform. You should generally be using int to represent integers unless there is a need to use a specific sized integer.
size: 32 bits in 32 bit systems and 64 bit in 64 bit systems.
range: -2147483648 to 2147483647 in 32 bit systems and -9223372036854775808 to 9223372036854775807 in 64 bit systems

package main

import "fmt"

func main() {  
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
}

Running the above program will output value of a is 89 and b is 95

In the above program a is of type int and the type of b is inferred from the value assigned to it (95). As we have stated above, the size of int is 32 bit in 32 bit systems and 64 bit in 64 bit systems. Lets go ahead and verify this claim.

The type of a variable can be printed using %T format specifier in Printf method. Go has a package unsafe which has a Sizeof function which returns in bytes the size of the variable passed to it. unsafe package should be used with care as the code using it might have portability issues, but for the purposes of this tutorial we can use it.

The following program outputs the type and size of both variables a and b. %T is the format specifier to print the type and %d is used to print the size.

package main

import (  
    "fmt"
    "unsafe"
)

func main() {  
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
    fmt.Printf("type of a is %T size of a is %d", a, unsafe.Sizeof(a)) //type and size of a
    fmt.Printf("\ntype of b is %T size of b is %d", b, unsafe.Sizeof(b)) //type and size of b
}

Running the above program will produce the output

value of a is 89 and b is 95  
type of a is int size of a is 4  
type of b is int size of b is 4  

We can infer from the above output that a and b are of type int and they are 32 bit sized(4 bytes). The output will vary if you run the above program on a 64 bit system. In a 64 bit system, a and b occupy 64 bits (8 bytes).

Unsigned integers

uint8: represents 8 bit unsigned integers
size: 8 bits
range: 0 to 255

uint16: represents 16 bit unsigned integers
size: 16 bits
range: 0 to 65535

uint32: represents 32 bit unsigned integers
size: 32 bits
range: 0 to 4294967295

uint64: represents 64 bit unsigned integers
size: 64 bits
range: 0 to 18446744073709551615

uint : represents 32 or 64 bit unsigned integers depending on the underlying platform.
size : 32 bits in 32 bit systems and 64 bits in 64 bit systems.
range : 0 to 4294967295 in 32 bit systems and 0 to 18446744073709551615 in 64 bit systems

Floating point types

float32: 32 bit floating point numbers
float64: 64 bit floating point numbers

The following is a simple program to illustrate integer and floating point types

package main

import (  
    "fmt"
)

func main() {  
    a, b := 5.67, 8.97
    fmt.Printf("type of a %T b %T\n", a, b)
    sum := a + b
    diff := a - b
    fmt.Println("sum", sum, "diff", diff)

    no1, no2 := 56, 89
    fmt.Println("sum", no1+no2, "diff", no1-no2)
}

The type of a and b is inferred from the value assigned to them. In this case a and b are of type float64.(float64 is the default type for floating point values). We add a and b and assign it to a variable sum. We subtract b from a and assign it to diff. Then the sum and diff is printed. Similar computation is done with no1 and no2. Running the above program will output

type of a float64 b float64  
sum 14.64 diff -3.3000000000000007  
sum 145 diff -33  

Complex types

complex64: complex numbers which have float32 real and imaginary parts
complex128: complex numbers with float64 real and imaginary parts

The builtin function complex is used to construct a complex number with real and imaginary parts. The complex function has the following definition

func complex(r, i FloatType) ComplexType  

It takes a real and imaginary part as parameter and returns a complex type. Both the real and imaginary parts should be of the same type. ie either float32 or float64. If both the real and imaginary parts are float32, this function returns a complex value of type complex64. If both the real and imaginary parts are of type float64, this function returns a complex value of type complex128

Complex numbers can also be created using the shorthand syntax

c := 6 + 7i  

Lets write a small program to understand complex numbers.

package main

import (  
    "fmt"
)

func main() {  
    c1 := complex(5, 7)
    c2 := 8 + 27i
    cadd := c1 + c2
    fmt.Println("sum:", cadd)
    cmul := c1 * c2
    fmt.Println("product:", cmul)
}

In the above program, c1 and c2 are two complex numbers. c1 has 5 as real part and 7 as the imaginary part. c2 has real part 8 and imaginary part 27. cadd is assigned the sum of c1 and c2 and cmul is assigned the product of c1 and c2. Running this program will output

sum: (13+34i)  
product: (-149+191i)  

Other numeric types

byte is an alias of uint8
rune is an alias of int32

We will discuss bytes and runes in more detail when we learn about strings.

string type

Strings are a collection of bytes in golang. Its alright if this definition doesn't make any sense. For now we can assume a string to be a collection of characters. We will learn about strings in detail in a separate tutorial.

Lets write a program using strings.

package main

import (  
    "fmt"
)

func main() {  
    first := "Naveen"
    last := "Ramanathan"
    name := first +" "+ last
    fmt.Println("My name is",name)
}

In the above program, first is assigned the string "Naveen", last is assigned the string "Ramanathan". Strings can be concatenated using the + operator. name is assigned the value of first concatenated to a space followed by last. Run the above program and you will get My name is Naveen Ramanathan as the output.

There are some more operations that can performed on strings. We will look at those in a separate tutorial.

Type Conversion

Go is very strict about explicit typing. There is no automatic type promotion or conversion. Lets look at what this means with an example.

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //int + float64 not allowed
    fmt.Println(sum)
}

The above code is perfectly legal in C language. But in the case of go, this wont work. i is of type int and j is of type float64. We are trying to add 2 numbers of different types which is not allowed. When you run the program, you will get main.go:10: invalid operation: i + j (mismatched types int and float64)

To fix the error, we should convert both i and j to the same type. In this case lets convert j to int. T(v) is the syntax to convert a value v to type T

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + int(j) //j is converted to int
    fmt.Println(sum)
}

Now when you run the above program, you can see 122 as the output.

The same is the case with assignment. Explicit type conversion is required to assign a variable of one type to another. This is explained in the following program.

package main

import (  
    "fmt"
)

func main() {  
    i := 10
    var j float64 = float64(i) //this statement will not work without explicit conversion
    fmt.Println("j", j)
}

In the line var j float64 = float64(i) i is converted to float64 and then assigned to j. When you try to assign i to j without any type conversion, the compiler will throw an error.

Thanks for reading. Please post your feedback and queries in the comments section.

Next Tutorial - Constants