Go Operators

What is an Operator?

In programming, an operator is a symbol that represents a specific operation to be performed on one or more operands. Operators define how variables or values are manipulated to produce a result.

What is the Operator in Go?

In Go, operators are fundamental building blocks that allow developers to perform various operations on variables and values. These operations range from basic arithmetic calculations to more complex bitwise manipulations and logical evaluations.

Different Types of Operators

Arithmetic Operators

Arithmetic operators are used for basic mathematical operations such as addition, subtraction, multiplication, and division.

package main
import "fmt"
func main() {

a, b := 10, 4
fmt.Println("Addition:", a+b)
fmt.Println("Subtraction:", a-b)
fmt.Println("Multiplication:", a*b)
fmt.Println("Division:", a/b)
}

Lis of Arithmetic Operators

Assignment Operators

Assignment operators are used to assign values to variables. They can also combine assignments with arithmetic operations.

package main
import "fmt"
func main() {

x := 5

y := 10
x += y  // Equivalent to x = x + y
fmt.Println("Updated x:", x)
}

List of Assignment Operators

Comparison Operators

Comparison operators are used to compare values and return a boolean result.

package main
import "fmt"
func main() {

num1, num2 := 10, 20
fmt.Println("Equal:", num1 == num2)
fmt.Println("Not Equal:", num1 != num2)
fmt.Println("Greater Than:", num1 > num2)
fmt.Println("Less Than:", num1 < num2)
}

List of Comparison Operators

Logical Operators

Logical operators perform logical operations on boolean values.

package main
import "fmt"
func main() {

isTrue, isFalse := true, false
fmt.Println("Logical AND:", isTrue && isFalse)
fmt.Println("Logical OR:", isTrue || isFalse)
fmt.Println("Logical NOT:", !isTrue)
}

List of Logical Operators

Bitwise Operators

Bitwise operators manipulate individual bits of integer values.

package main
import "fmt"
func main() {

num1, num2 := 5, 3
fmt.Println("Bitwise AND:", num1&num2)
fmt.Println("Bitwise OR:", num1|num2)
fmt.Println("Bitwise XOR:", num1^num2)
fmt.Println("Bitwise NOT:", ^num1)
}

List of Bitwise Operators

List of Unary Operators

Unary operators operate on a single operand.

Operator Precedence in Go

In Go, operator precedence determines the order in which operators are evaluated within an expression. Operators with higher precedence are evaluated first. Here's a list of operator precedence in Go, from highest to lowest:

1. Unary operators: +, -, !, ^ (highest precedence)

2. Multiplicative operators: *, /, %

3. Additive operators: +, -

4. Bitwise shift operators: <<, >>

5. Relational operators: <, <=, >, >=

6. Equality operators: ==, !=

7. Bitwise AND: &

8. Bitwise XOR: ^

9. Bitwise OR: |

10. Logical AND: &&

11. Logical OR: ||

12. Conditional (Ternary) operator: ? :

13. Assignment operators: =, +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |= (lowest precedence)

It's important to note that parentheses () can be used to override the default precedence and explicitly specify the order of evaluation in an expression.

Here's an example demonstrating the operator precedence in Go:

package main
import "fmt"
func main() {

result := 5 + 23 > 7 && !(4 == 4)

fmt.Println("Result:", result)

}

In this example, the multiplication () has higher precedence than addition (+), and the logical NOT (!) has higher precedence than the logical AND (&&). The result is calculated based on the operator precedence, producing the final boolean result.

Conclusion

Understanding the different types of operators in Go and their specific use cases is crucial for writing effective and expressive code. The examples provided illustrate how these operators are applied in various scenarios, from basic arithmetic to complex logical and bitwise operations. As you continue to explore and use Go in your programming projects, a solid understanding of operators will greatly enhance your ability to manipulate and control the flow of your code.