How do I use arithmetic operators in Go ( , -, *, /, %, , --)?

The methods of using arithmetic operators in Go language include: 1. Basic operators, -, *, /, % are used for addition, subtraction, multiplication, division and separation, and taking remainder. The result of integer division is an integer, and the division of negative numbers is rounded to zero, and the remainder only supports integers; 2. Self-increase and self-decrease--can only act on variables as independent statements and cannot be used in expressions; 3. Mixed type operations require explicit conversion of types, and cannot directly operate on different types. For example, int and float64 must be converted to the same type first.

Using arithmetic operators in Go is straightforward, and they work pretty much like you'd expect if you've used other C-style languages. Let's go over how to use each of them effectively.

Basic Arithmetic: , -, *, /, %

These are the standard math operations you'll use most often:

• for addition
• - for subtraction
• * for multiplication
• / for division
• % for modulus (remainder after division)

Here's a quick example:

 a := 10
b := 3

fmt.Println(ab) // 13
fmt.Println(a - b) // 7
fmt.Println(a * b) // 30
fmt.Println(a / b) // 3 (since both are integers)
fmt.Println(a % b) // 1

A few things to note:

• If both operators are integers, the result will also be an integer.
• Division with negative numbers rounds toward zero.
• Modulus works only with integers in Go (unlike some other languages).

Increment and Decrement: and --

Go uses to increment by 1 and -- to decline by 1. But unlike in C or Java, these can't be used in expressions — they're statements only.

For example:

 i := 5
i  
fmt.Println(i) // 6

j := 10
j--
fmt.Println(j) // 9

You can't do something like this:

 x := i // ❌ Compile error

So just remember:

• They only work on variables, not constants or expressions.
• They must appear on their own line as standalone operations.

Mixing Types? Be Careful!

Go doesn't allow mixing types automatically in arithmetic. For example, you can't add an int and an float64 directly — you have to convert one to match the other.

 var x int = 5
var y float64 = 2.5

// This won't compile:
// fmt.Println(xy)

// You need to convert:
fmt.Println(float64(x) y) // OK

Same goes for different integer types like int8 , int16 , etc. Always make sure your types match before doing math.

That's the core of using arithmetic operators in Go. The rules are simple, but strict — especially around type conversion and where /- can be used.

The above is the detailed content of How do I use arithmetic operators in Go ( , -, *, /, %, , --)?. For more information, please follow other related articles on the PHP Chinese website!