Numeric data types
Go supports integer, floatingpoint, and complex number values in various versions depending on the memory space they consume—this saves memory and computing time. Integer data types can be either signed or unsigned, which is not the case for floating point numbers.
The table that follows lists the numeric data types of Go.
Data Type 
Description 

8bit signed integer 

16bit signed integer 

32bit signed integer 

64bit signed integer 

32 or 64bit signed integer 

8bit unsigned integer 

16bit unsigned integer 

32bit unsigned integer 

64bit unsigned integer 

32 or 64bit unsigned integer 

32bit floatingpoint number 

64bit floatingpoint number 

Complex number with 

Complex number with 
The int
and uint
data types are special as they are the most efficient sizes for signed and unsigned integers on a given platform and can be either 32 or 64 bits each—their size is defined by Go itself. The int
data type is the most widely used data type in Go due to its versatility.
The code that follows illustrates the use of numeric data types—you can find the entire program as numbers.go
inside the ch02
directory of the book GitHub repository.
func main() {
c1 := 12 + 1i
c2 := complex(5, 7)
fmt.Printf("Type of c1: %T\n", c1)
fmt.Printf("Type of c2: %T\n", c2)
The previous code creates two complex variables in two different ways—both ways are perfectly valid and equivalent. Unless you are into mathematics, you will most likely not use complex numbers in your programs. However, the existence of complex numbers shows how modern Go is.
var c3 complex64 = complex64(c1 + c2)
fmt.Println("c3:", c3)
fmt.Printf("Type of c3: %T\n", c3)
cZero := c3  c3
fmt.Println("cZero:", cZero)
The previous code continues to work with complex numbers by adding and subtracting two pairs of them. Although cZero
is equal to zero, it is still a complex number and a complex64
variable.
x := 12
k := 5
fmt.Println(x)
fmt.Printf("Type of x: %T\n", x)
div := x / k
fmt.Println("div", div)
In this part, we define two integer variables named x
and k
—their data type is identified by Go based on their initial values. Both are of type int
, which is what Go prefers to use for storing integer values. Additionally, when you divide two integer values, you get an integer result even when the division is not perfect. This means that if this is not what you want, you should take extra care—this is shown in the next code excerpt:
var m, n float64
m = 1.223
fmt.Println("m, n:", m, n)
y := 4 / 2.3
fmt.Println("y:", y)
divFloat := float64(x) / float64(k)
fmt.Println("divFloat", divFloat)
fmt.Printf("Type of divFloat: %T\n", divFloat)
}
The previous code works with float64
values and variables. As n
does not have an initial value, it is automatically assigned with the zero value of its data type, which is 0
for the float64
data type.
Additionally, the code presents a technique for dividing integer values and getting a floatingpoint result, which is the use of float64()
: divFloat := float64(x) / float64(k)
. This is a type conversion where two integers (x
and k
) are converted to float64
values. As the division between two float64
values is a float64
value, we get the result in the desired data type.
Running numbers.go
creates the following output:
$ go run numbers.go
Type of c1: complex128
Type of c2: complex128
c3: (17+8i)
Type of c3: complex64
cZero: (0+0i)
12
Type of x: int
div 2
m, n: 1.223 0
y: 1.7391304347826086
divFloat 2.4
Type of divFloat: float64
The output shows that both c1
and c2
are complex128
values, which is the preferred complex data type for the machine on which the code was executed. However, c3
is a complex64
value because it was created using complex64()
. The value of n
is 0
because the n
variable was not initialized, which means that Go automatically assigned the zero value of its data type to n
.
After learning about numeric data types, it is time to learn about nonnumeric data types, which is the subject of the next section.