# Types

Welcome to 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*.

```
1package main
2
3import "fmt"
4
5func main() {
6 a := true
7 b := false
8 fmt.Println("a:", a, "b:", b)
9 c := a && b
10 fmt.Println("c:", c)
11 d := a || b
12 fmt.Println("d:", d)
13}
```

In the program above, 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

```
1package main
2
3import "fmt"
4
5func main() {
6 var a int = 89
7 b := 95
8 fmt.Println("value of a is", a, "and b is", b)
9}
```

The above program will print `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*. Let’s go ahead and verify this claim.

The type of a variable can be printed using **%T** format specifier in `Printf`

function. 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.

```
1package main
2
3import (
4 "fmt"
5 "unsafe"
6)
7
8func main() {
9 var a int = 89
10 b := 95
11 fmt.Println("value of a is", a, "and b is", b)
12 fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) //type and size of a
13 fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) //type and size of b
14}
```

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

```
1package main
2
3import (
4 "fmt"
5)
6
7func main() {
8 a, b := 5.67, 8.97
9 fmt.Printf("type of a %T b %T\n", a, b)
10 sum := a + b
11 diff := a - b
12 fmt.Println("sum", sum, "diff", diff)
13
14 no1, no2 := 56, 89
15 fmt.Println("sum", no1+no2, "diff", no1-no2)
16}
```

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. The above program will print

```
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 a parameter and returns a complex type. *Both the real and imaginary parts must 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
```

Let’s write a small program to understand complex numbers.

```
1package main
2
3import (
4 "fmt"
5)
6
7func main() {
8 c1 := complex(5, 7)
9 c2 := 8 + 27i
10 cadd := c1 + c2
11 fmt.Println("sum:", cadd)
12 cmul := c1 * c2
13 fmt.Println("product:", cmul)
14}
```

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. 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 Go. It’s 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 strings tutorial.

Let’s write a program using strings.

```
1package main
2
3import (
4 "fmt"
5)
6
7func main() {
8 first := "Naveen"
9 last := "Ramanathan"
10 name := first +" "+ last
11 fmt.Println("My name is",name)
12}
```

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*. The above program will print `My name is Naveen Ramanathan`

as the output.

There are some more operations that can be 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. Let’s look at what this means with an example.

```
1package main
2
3import (
4 "fmt"
5)
6
7func main() {
8 i := 55 //int
9 j := 67.8 //float64
10 sum := i + j //int + float64 not allowed
11 fmt.Println(sum)
12}
```

The above code is perfectly legal in C language. But in the case of go, this won’t 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 `./prog.go:10:11: invalid operation: i + j (mismatched types int and float64)`

To fix the error, both *i* and *j* should be of the same type. Let’s convert *j* to int. *T(v) is the syntax to convert a value v to type T*

```
1package main
2
3import (
4 "fmt"
5)
6
7func main() {
8 i := 55 //int
9 j := 67.8 //float64
10 sum := i + int(j) //j is converted to int
11 fmt.Println(sum)
12}
```

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.

```
1package main
2
3import (
4 "fmt"
5)
6
7func main() {
8 i := 10
9 var j float64 = float64(i) //this statement will not work without explicit conversion
10 fmt.Println("j", j)
11}
```

In line no. 9, 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.

This brings us to an end of this tutorial. Please post your feedback and queries in the comments section. Please consider sharing this tutorial on twitter or LinkedIn. Have a good day.

If you would like to advertise on this website, hire me, or if you have any other software development needs please email me at *naveen[at]golangbot[dot]com*.

**Next Tutorial - Constants**

**Previous Tutorial - Variables**