In this tutorial, we will learn about the int32 data type in Go. We will cover the basics of defining and using int32 values, including how to perform arithmetic operations and compare 32-bit integers.
The int32
data type in Go is used to represent 32-bit signed integer values. The range of an int32
is from -2,147,483,648 to 2,147,483,647.
Int32 variables in Go can be defined using the var
keyword or by type inference with explicit type conversion.
var x int32 = 2147483647
y := int32(100000)
Arithmetic operations such as addition, subtraction, multiplication, and division can be performed on int32 values.
sum := x + y
difference := x - y
product := x * y
quotient := x / y
Int32 values can be compared using relational operators.
fmt.Println(x > y)
fmt.Println(x < y)
fmt.Println(x == y)
We can define and use int32 variables in Go to represent 32-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 int32 = 2147483647
y := int32(100000)
fmt.Println(x)
fmt.Println(y)
}
2147483647 100000
We can perform arithmetic operations on int32 values in Go.
For example,
x
and y
.package main
import "fmt"
func main() {
x := int32(2147483647)
y := int32(100000)
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: -2147383649 Difference: 2147383647 Product: -1448873564 Quotient: 21474
We can compare int32 values in Go using relational operators.
For example,
x
and y
with different values.package main
import "fmt"
func main() {
x := int32(2147483647)
y := int32(100000)
fmt.Println(x > y) // true
fmt.Println(x < y) // false
fmt.Println(x == y) // false
}
true false false
We can pass int32 values to functions and return int32 values from functions in Go.
For example,
multiply
that takes two int32 parameters and returns their product.package main
import "fmt"
func multiply(a int32, b int32) int32 {
return a * b
}
func main() {
result := multiply(30000, 70000)
fmt.Println(result)
}
2100000000