In the Go programming language, variables are containers marked by identifiers
or names, which can hold different values in a program. These variables can hold many different data types, whether they are numbers, words, or any other type. To restrict the type of data stored inside these variables, we need to specify the data type of the variables.
int
is one of the available numeric data types in Go
used to store signed integers. int64
is a version of int
that only stores signed numeric values composed of up to 64 bits. So, for example, if you try to store a string
value in it, or an integer
beyond what can be made using 64 bits, the program would return an error or result in an integer overflow.
The numeric data type of int
has several other versions in addition to int64
, which include:
int8
int16
int32
uint8
uint16
uint32
uint64
The data types starting from int
store signed integers, while those starting with uint
contain unsigned integers. The numeric value that follows each data type represents the number of bytes stored.
A variable of type int64
can store integers ranging from -9223372036854775808 til **9223372036854775807.
If an
int64
variable is assigned a value beyond the range mentioned above, then an overflow error occurs, which basically means that theint64
variable cannot properly store the assigned number.
The following code shows the positive limit of the values that an int64
variable can store and what happens if you try to store something larger than the stipulated range of values:
package mainimport "fmt"func main() {// initializing with the maximum allowed positive numbervar num int64 = 9223372036854775807// printing the value and data typefmt.Printf("Value is: %d and type is: %T\n", num, num);// making the value out of range by incrementing by 1num = num+1// printing out new value and typefmt.Printf("Value is: %d and type is: %T\n", num, num);}
As we can see from the outputs of the code above, when we stored the value 9223372036854775807 in num
and printed it, the value came out to be 2147483647. However, just incrementing it by 1 pushed it out of the allowed range, which resulted in the stored value being interpreted as -9223372036854775808 when printed again. When this happens, we call it an overflow.
In the following example, we declare a variable num
and explicitly state its data type to be int64
. Later, we can use the Printf
function to see that num
is indeed stored as an int64
data type:
package mainimport "fmt"func main() {var num int64num = 200fmt.Printf("Data type of %d is %T\n", num, num);}
It is also possible to create const
values of type int64
instead of variables. The only difference is that const
values are just variables whose values cannot be changed from what they were initialized to. We then check the stored data type again by printing it out using the Printf
function.
const
values must be declared and initialized in the same line.
package mainimport "fmt"func main() {// declaring and initializing a const value with an integerconst c_num int64 = 200// %T represents the type of the variable numfmt.Printf("Data type of %d is %T\n", c_num, c_num);}
Free Resources