If you come from JavaScript, Java, C, C# or Python you will feel at home with Go operators. On this article we will provide a summary of the operators in Go and provide some examples.

## What are operators?

## Which operators are supported in Go?

The following are the operators (including assignment operators) and punctuation supported in Go:

+ & += &= && == != ( ) - | -= |= || < <= [ ] * ^ *= ^= <- > >= { } / << /= <<= ++ = := , ; % >> %= >>= -- ! ... . : &^ &^=

## Types of operators

Go operators are usually categorized based on functionality:

- Arithmetic Operators
- Comparison Operators
- Relational Operators
- Logical Operators
- Bitwise Operators
- Assignment Operators
- Misc Operators

## Arithmetic operators

Arithmetic operators apply to numeric values and yield a result of the same
type as the first operand. The four standard arithmetic operators
(`+`

,
`-`

, `*`

, `/`

) apply to integer,
floating-point, and complex types; `+`

also applies to strings. The
bitwise logical and shift operators apply to integers only.

+ sum integers, floats, complex values, strings - difference integers, floats, complex values * product integers, floats, complex values / quotient integers, floats, complex values % remainder integers & bitwise AND integers | bitwise OR integers ^ bitwise XOR integers &^ bit clear (AND NOT) integers << left shift integer << unsigned integer >> right shift integer >> unsigned integer

## Comparison operators

Comparison operators compare two operands and yield an untyped boolean value. They are:

== equal != not equal < less <= less or equal > greater >= greater or equal

## Logical operators

Logical operators apply to boolean values and yield a result of the same type as the operands. The right operand is evaluated conditionally.

&& conditional AND p && q is "if p then q else false" || conditional OR p || q is "if p then true else q" ! NOT !p is "not p"

## Address operators

For an operand `x`

of type `T`

, the address operation
`&x`

generates a pointer of type `*T`

to
`x`

. The operand must be *addressable*, that is, either a
variable, pointer indirection, or slice indexing operation; or a field
selector of an addressable struct operand; or an array indexing operation of
an addressable array. As an exception to the addressability requirement,
`x`

may also be a (possibly parenthesized)
composite literal. If the evaluation of `x`

would cause a
run-time panic, then
the evaluation of `&x`

does too.

For an operand `x`

of pointer type `*T`

, the pointer
indirection `*x`

denotes the
variable of type
`T`

pointed to by `x`

. If `x`

is
`nil`

, an attempt to evaluate `*x`

will cause a
run-time panic.

&x &a[f(2)] &Point{2, 3} *p *pf(x) var x *int = nil *x // causes a run-time panic &*x // causes a run-time panic

## Operator precedence

### Unary operators

Unary operators have the highest precedence. As the `++`

and
`--`

operators form statements, not expressions, they fall outside
the operator hierarchy. As a consequence, statement `*p++`

is the
same as `(*p)++`

.

### Binary operators

There are five precedence levels for binary operators. Multiplication
operators bind strongest, followed by addition operators, comparison
operators, `&&`

(logical AND), and finally
`||`

(logical OR).

Precedence Operator 5 * / % << >> & &^ 4 + - | ^ 3 == != < <= > >= 2 && 1 ||

Binary operators of the same precedence associate from left to right. For
instance, `x / y * z`

is the same as `(x / y) * z`

.

+x 23 + 3*x[i] x <= f() ^a >> b f() || g() x == y+1 && <-chanPtr > 0

## Conclusion

On this article we discussed a little about Go operators. If you come from JavaScript, Java, C, C# or Python you will feel at home with Go operators. Knowing and understanding operators in any programming language is important for writing better and readable code, we recommend that you read the Go spec for more information.