In this tutorial, we will learn about the int64 data type in Go. We will cover the basics of defining and using int64 values, including how to perform arithmetic operations and compare 64-bit integers.
The int64
data type in Go is used to represent 64-bit signed integer values. The range of an int64
is from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
Int64 variables in Go can be defined using the var
keyword or by type inference with explicit type conversion.
var x int64 = 9223372036854775807
y := int64(10000000000)
Arithmetic operations such as addition, subtraction, multiplication, and division can be performed on int64 values.
sum := x + y
difference := x - y
product := x * y
quotient := x / y
Int64 values can be compared using relational operators.
fmt.Println(x > y)
fmt.Println(x < y)
fmt.Println(x == y)
We can define and use int64 variables in Go to represent 64-bit signed integer values.
For example,
x
and assign it a value.y
using type inference with explicit type conversion and assign it a value.package main
import "fmt"
func main() {
var x int64 = 9223372036854775807
y := int64(10000000000)
fmt.Println(x)
fmt.Println(y)
}
9223372036854775807 10000000000
We can perform arithmetic operations on int64 values in Go.
For example,
x
and y
.package main
import "fmt"
func main() {
x := int64(9223372036854775807)
y := int64(10000000000)
sum := x + y
difference := x - y
product := x * y
quotient := x / y
fmt.Println("Sum:", sum)
fmt.Println("Difference:", difference)
fmt.Println("Product:", product)
fmt.Println("Quotient:", quotient)
}
Sum: -9223372026854775809 Difference: 9223372026854775807 Product: 46116860184273879040000000000 Quotient: 922337203
We can compare int64 values in Go using relational operators.
For example,
x
and y
with different values.package main
import "fmt"
func main() {
x := int64(9223372036854775807)
y := int64(10000000000)
fmt.Println(x > y) // true
fmt.Println(x < y) // false
fmt.Println(x == y) // false
}
true false false
We can pass int64 values to functions and return int64 values from functions in Go.
For example,
subtract
that takes two int64 parameters and returns their difference.package main
import "fmt"
func subtract(a int64, b int64) int64 {
return a - b
}
func main() {
result := subtract(20000000000, 10000000000)
fmt.Println(result)
}
10000000000