Operators in Go - Arithmetic, Relational, Logical, etc.

This comprehensive guide covers the different types of operators in Go, including arithmetic, relational, logical, assignment, and bitwise operators. You'll learn how to effectively use each type of operator through detailed explanations and practical examples.

Introduction to Operators in Go

What are Operators?

Operators in programming are symbols that perform specific operations on operands (variables or values). They are a fundamental part of any programming language as they help in forming expressions and statements.

Think of operators like the verbs in a sentence. Just as verbs describe the action performed by a subject or object, operators specify the action to be performed on operands.

For example, in the expression 5 + 3, the + is an operator that performs the action of addition on the operands 5 and 3.

In Go, operators are categorized into several types: arithmetic, relational, logical, assignment, bitwise, and miscellaneous (such as the conditional operator). Each type serves a specific purpose, and understanding them is crucial for effective programming.

Overview of Operators in Programming

In programming, operators help us manipulate data, make decisions, and perform actions on variables. They play a pivotal role in creating logic and controlling the flow of a program. Here are some common types of operators you will learn about in this guide:

Arithmetic Operators: Perform mathematical calculations such as addition, subtraction, multiplication, and division.
Relational Operators: Compare the values of two operands and return a boolean value (true or false).
Logical Operators: Used to combine multiple conditions and perform logical operations.
Assignment Operators: Assign values to variables.
Bitwise Operators: Perform operations at the bit level on operands.
Miscellaneous Operators: Include the conditional and composite assignment operators.

Each of these operators has its unique syntax and use cases, and they are essential for writing efficient and effective Go programs. As you progress through this guide, you'll see how each type of operator fits into the bigger picture of Go programming.

Now, let's dive deeper into each type of operator, starting with arithmetic operators.

Arithmetic Operators

Arithmetic operators are used to perform common mathematical operations on operands. These operators include addition, subtraction, multiplication, division, and modulo.

Basic Arithmetic Operators

Addition

The + operator is used for addition. It adds the values of two operands.

Example:

package main

import "fmt"

func main() {
    num1 := 5
    num2 := 3
    sum := num1 + num2
    fmt.Println("The sum of", num1, "and", num2, "is", sum)
}

Explanation:

We declare two variables, num1 and num2, and assign them the values 5 and 3, respectively.
We then use the + operator to add num1 and num2 and store the result in the variable sum.
Finally, we print the result.

Expected Output:

The sum of 5 and 3 is 8

Subtraction

The - operator is used for subtraction. It subtracts the second operand from the first.

Example:

package main

import "fmt"

func main() {
    num1 := 10
    num2 := 4
    difference := num1 - num2
    fmt.Println("The difference between", num1, "and", num2, "is", difference)
}

Explanation:

We declare two variables, num1 and num2, with values 10 and 4.
We use the - operator to subtract num2 from num1 and store the result in difference.
We print the result.

Expected Output:

The difference between 10 and 4 is 6

Multiplication

The * operator is used for multiplication. It multiplies the two operands.

Example:

package main

import "fmt"

func main() {
    num1 := 6
    num2 := 7
    product := num1 * num2
    fmt.Println("The product of", num1, "and", num2, "is", product)
}

Explanation:

Two variables, num1 and num2, hold the values 6 and 7.
The * operator multiplies num1 and num2, storing the result in product.
The result is printed.

Expected Output:

The product of 6 and 7 is 42

Division

The / operator is used for division. It divides the first operand by the second, returning the quotient.

Example:

package main

import "fmt"

func main() {
    num1 := 15
    num2 := 3
    quotient := num1 / num2
    fmt.Println("The quotient of", num1, "divided by", num2, "is", quotient)
}

Explanation:

The variables num1 and num2 are assigned the values 15 and 3.
The / operator divides num1 by num2 and stores the quotient in quotient.
The result is displayed using fmt.Println.

Expected Output:

The quotient of 15 divided by 3 is 5

Modulo

The % operator is used to find the remainder of a division. It divides the first operand by the second and returns the remainder.

Example:

package main

import "fmt"

func main() {
    num1 := 16
    num2 := 5
    remainder := num1 % num2
    fmt.Println("The remainder of", num1, "divided by", num2, "is", remainder)
}

Explanation:

We declare num1 and num2 with values 16 and 5.
The % operator finds the remainder when num1 is divided by num2, and the result is stored in remainder.
The result is printed.

Expected Output:

The remainder of 16 divided by 5 is 1

Advanced Arithmetic Operators

These operators, increment and decrement, are used to modify the value of a variable by increasing or decreasing it by one.

Increment

The ++ operator increases the value of a variable by one. It can be used in two ways: prefix (++i) and postfix (i++).

Prefix Increment (++variable): The value of the variable is incremented before it is used in an expression. Postfix Increment (variable++): The value of the variable is used in an expression, and then it is incremented.

Example:

package main

import "fmt"

func main() {
    num := 10
    fmt.Println("Prefix Increment:", ++num) // Increment before use
    fmt.Println("Current value of num:", num)
    fmt.Println("Postfix Increment:", num++) // Use before increment
    fmt.Println("Current value of num after postfix:", num)
}

Explanation:

The variable num is initialized with the value 10.
The prefix increment ++num increases num to 11 before it is printed.
After prefix increment, num is 11.
In the postfix increment num++, num is 11 when used in the print statement, but it is incremented to 12 afterward.

Expected Output:

Prefix Increment: 11
Current value of num: 11
Postfix Increment: 11
Current value of num after postfix: 12

Decrement

The -- operator decreases the value of a variable by one. Similar to increment, it can be used as prefix (--i) or postfix (i--).

Prefix Decrement (--variable): The value of the variable is decremented before it is used in an expression. Postfix Decrement (variable--): The value of the variable is used in an expression, and then it is decremented.

Example:

package main

import "fmt"

func main() {
    num := 10
    fmt.Println("Prefix Decrement:", --num) // Decrement before use
    fmt.Println("Current value of num:", num)
    fmt.Println("Postfix Decrement:", num--) // Use before decrement
    fmt.Println("Current value of num after postfix:", num)
}

Explanation:

The variable num is initialized to 10.
In the prefix decrement --num, num is decremented to 9 before it is printed.
After prefix decrement, num is 9.
In the postfix decrement num--, num is 9 during the print statement, but it is decremented to 8 afterward.

Expected Output:

Prefix Decrement: 9
Current value of num: 9
Postfix Decrement: 9
Current value of num after postfix: 8

Relational Operators

Relational operators compare two operands and return a boolean value (true or false), depending on the comparison.

Types of Relational Operators

Equal to

The == operator checks if the values of two operands are equal. If they are equal, it returns true; otherwise, it returns false.

Example:

package main

import "fmt"

func main() {
    num1 := 5
    num2 := 5
    fmt.Println("Is", num1, "equal to", num2, "?", num1 == num2)
}

Explanation:

We compare the values of num1 and num2 using the == operator.
Since num1 and num2 are equal, the output is true.

Expected Output:

Is 5 equal to 5? true

Not Equal to

The != operator checks if the values of two operands are not equal. If they are not equal, it returns true; otherwise, it returns false.

Example:

package main

import "fmt"

func main() {
    num1 := 7
    num2 := 9
    fmt.Println("Is", num1, "not equal to", num2, "?", num1 != num2)
}

Explanation:

The != operator compares num1 (7) and num2 (9).
Since num1 and num2 are not equal, the operator returns true.

Expected Output:

Is 7 not equal to 9? true

Greater Than

The > operator checks if the first operand is greater than the second. It returns true if the first operand is greater, otherwise false.

Example:

package main

import "fmt"

func main() {
    num1 := 12
    num2 := 8
    fmt.Println("Is", num1, "greater than", num2, "?", num1 > num2)
}

Explanation:

The > operator compares num1 and num2.
Since 12 is greater than 8, the result is true.

Expected Output:

Is 12 greater than 8? true

Less Than

The < operator checks if the first operand is less than the second. It returns true if the first operand is less, otherwise false.

Example:

package main

import "fmt"

func main() {
    num1 := 5
    num2 := 7
    fmt.Println("Is", num1, "less than", num2, "?", num1 < num2)
}

Explanation:

The < operator checks if num1 is less than num2.
Since 5 is less than 7, the result is true.

Expected Output:

Is 5 less than 7? true

Greater Than or Equal to

The >= operator checks if the first operand is greater than or equal to the second. It returns true if the condition is met, otherwise false.

Example:

package main

import "fmt"

func main() {
    num1 := 10
    num2 := 10
    fmt.Println("Is", num1, "greater than or equal to", num2, "?", num1 >= num2)
}

Explanation:

The >= operator checks if num1 is greater than or equal to num2.
Since 10 is equal to 10, the result is true.

Expected Output:

Is 10 greater than or equal to 10? true

Less Than or Equal to

The <= operator checks if the first operand is less than or equal to the second. It returns true if the condition is met, otherwise false.

Example:

package main

import "fmt"

func main() {
    num1 := 8
    num2 := 10
    fmt.Println("Is", num1, "less than or equal to", num2, "?", num1 <= num2)
}

Explanation:

The <= operator evaluates whether num1 is less than or equal to num2.
Since 8 is less than 10, the result is true.

Expected Output:

Is 8 less than or equal to 10? true

Logical Operators

Logical operators are used to combine multiple conditions and make decisions based on the results.

Types of Logical Operators

Logical AND

The && operator returns true if both operands are true. If either or both are false, it returns false.

Example:

package main

import "fmt"

func main() {
    condition1 := true
    condition2 := false
    result := condition1 && condition2
    fmt.Println("Is", condition1, "AND", condition2, "?", result)
}

Explanation:

We have two boolean variables, condition1 and condition2, set to true and false, respectively.
The && operator checks if both conditions are true. Since condition2 is false, result is false.

Expected Output:

Is true AND false ? false

Logical OR

The || operator returns true if at least one of the operands is true. It returns false only if both operands are false.

Example:

package main

import "fmt"

func main() {
    condition1 := true
    condition2 := false
    result := condition1 || condition2
    fmt.Println("Is", condition1, "OR", condition2, "?", result)
}

Explanation:

We have two boolean variables, condition1 and condition2, with values true and false.
The || operator evaluates if either condition is true. Since condition1 is true, result is true.

Expected Output:

Is true OR false ? true

Logical NOT

The ! operator negates the boolean value of an operand. If the operand is true, ! makes it false, and vice versa.

Example:

package main

import "fmt"

func main() {
    condition := true
    negated := !condition
    fmt.Println("The negation of", condition, "is", negated)
}

Explanation:

The variable condition is set to true.
The ! operator negates condition, making negated false.

Expected Output:

The negation of true is false

Assignment Operators

Assignment operators are used to assign a value to a variable. They allow us to store values in variables, making the program dynamic.

Basic Assignment Operators

Simple Assignment

The = operator is the most basic assignment operator. It assigns the value of the right operand to the left operand.

Example:

package main

import "fmt"

func main() {
    num := 15
    fmt.Println("The value of num is", num)
}

Explanation:

The = operator assigns the value 15 to the variable num.
The value of num is then printed.

Expected Output:

The value of num is 15

Addition Assignment

The += operator adds the right operand to the left operand and assigns the result to the left operand.

Example:

package main

import "fmt"

func main() {
    num := 10
    num += 5
    fmt.Println("After adding, num is", num)
}

Explanation:

num is initially set to 10.
The += operator adds 5 to num, so num becomes 15.
The updated value is printed.

Expected Output:

After adding, num is 15

Subtraction Assignment

The -= operator subtracts the right operand from the left operand and assigns the result to the left operand.

Example:

package main

import "fmt"

func main() {
    num := 20
    num -= 7
    fmt.Println("After subtracting, num is", num)
}

Explanation:

num starts with the value 20.
The -= operator subtracts 7 from num, making num 13.
The new value is printed.

Expected Output:

After subtracting, num is 13

Multiplication Assignment

The *= operator multiplies the left operand by the right operand and assigns the result to the left operand.

Example:

package main

import "fmt"

func main() {
    num := 4
    num *= 6
    fmt.Println("After multiplying, num is", num)
}

Explanation:

The variable num is initialized with the value 4.
The *= operator multiplies num by 6, resulting in 24.
The updated value is printed.

Expected Output:

After multiplying, num is 24

Division Assignment

The /= operator divides the left operand by the right operand and assigns the result to the left operand.

Example:

package main

import "fmt"

func main() {
    num := 20
    num /= 5
    fmt.Println("After dividing, num is", num)
}

Explanation:

We initialize num with 20.
The /= operator divides num by 5, resulting in 4.
The result is printed.

Expected Output:

After dividing, num is 4

Modulo Assignment

The %= operator divides the left operand by the right operand and assigns the remainder to the left operand.

Example:

package main

import "fmt"

func main() {
    num := 21
    num %= 5
    fmt.Println("After modulo, num is", num)
}

Explanation:

The variable num is set to 21.
The %= operator finds the remainder of 21 divided by 5, which is 1, and assigns it to num.
The updated value is printed.

Expected Output:

After modulo, num is 1

Bitwise Operators

Bitwise operators perform operations on the individual bits of the operands.

Types of Bitwise Operators

Bitwise AND

The & operator performs a bitwise AND operation. Each bit of the output is 1 if the corresponding bits of both operands are 1; otherwise, it is 0.

Example:

package main

import "fmt"

func main() {
    num1 := 5  // Binary: 0101
    num2 := 3  // Binary: 0011
    result := num1 & num2
    fmt.Println("Bitwise AND of", num1, "and", num2, "is", result) // Binary result: 0001 (1 in decimal)
}

Explanation:

num1 is 5 (binary 0101).
num2 is 3 (binary 0011).
The & operator performs bitwise AND, resulting in 0001 (which is 1 in decimal).

Expected Output:

Bitwise AND of 5 and 3 is 1

Bitwise OR

The | operator performs a bitwise OR operation. Each bit of the output is 1 if at least one of the corresponding bits of the operands is 1.

Example:

package main

import "fmt"

func main() {
    num1 := 5  // Binary: 0101
    num2 := 3  // Binary: 0011
    result := num1 | num2
    fmt.Println("Bitwise OR of", num1, "and", num2, "is", result) // Binary result: 0111 (7 in decimal)
}

Explanation:

num1 is 5 (binary 0101).
num2 is 3 (binary 0011).
The | operator performs bitwise OR, resulting in 0111 (which is 7 in decimal).

Expected Output:

Bitwise OR of 5 and 3 is 7

Bitwise XOR

The ^ operator performs a bitwise XOR (exclusive OR) operation. Each bit of the output is 1 if the corresponding bits of the operands are different.

Example:

package main

import "fmt"

func main() {
    num1 := 5  // Binary: 0101
    num2 := 3  // Binary: 0011
    result := num1 ^ num2
    fmt.Println("Bitwise XOR of", num1, "and", num2, "is", result) // Binary result: 0110 (6 in decimal)
}

Explanation:

num1 is 5 (binary 0101).
num2 is 3 (binary 0011).
The ^ operator performs bitwise XOR, resulting in 0110 (6 in decimal).

Expected Output:

Bitwise XOR of 5 and 3 is 6

Bitwise Complement

The ^ operator can also be used as a bitwise complement operator when used as a single operand (unary). It inverts all the bits of its operand.

Example:

package main

import "fmt"

func main() {
    num := 6  // Binary: 0110
    result := ^num
    fmt.Println("Bitwise Complement of", num, "is", result)
}

Explanation:

The variable num is 6 (binary 0110).
The ^ operator inverts all bits of num, resulting in a negative number due to the way Go handles signed integers. The result is -7 in decimal.

Expected Output:

Bitwise Complement of 6 is -7

Note: Bitwise complement in Go negates all bits, flipping both the sign and magnitude, which results in a negative number for positive integers.

Left Shift

The << operator shifts the bits of the left operand to the left by the number of positions specified by the right operand.

Example:

package main

import "fmt"

func main() {
    num := 5  // Binary: 0101
    result := num << 1
    fmt.Println("Bitwise Left Shift of", num, "by 1 is", result) // Result: 10 (binary 1010)
}

Explanation:

The variable num is 5 (binary 0101).
The << operator shifts the bits of num to the left by 1 position, resulting in 10 (binary 1010).

Expected Output:

Bitwise Left Shift of 5 by 1 is 10

Right Shift

The >> operator shifts the bits of the left operand to the right by the number of positions specified by the right operand.

Example:

package main

import "fmt"

func main() {
    num := 20  // Binary: 10100
    result := num >> 2
    fmt.Println("Bitwise Right Shift of", num, "by 2 is", result) // Result: 5 (binary 0101)
}

Explanation:

The variable num is 20 (binary 10100).
The >> operator shifts the bits of num to the right by 2 positions, resulting in 5 (binary 0101).

Expected Output:

Bitwise Right Shift of 20 by 2 is 5

Other Operators

Conditional (Ternary) Operator

Go does not have a ternary operator like ? : used in some other languages. Instead, use an if-else statement to achieve similar functionality.

Example:

package main

import "fmt"

func main() {
    num1 := 10
    num2 := 5
    var result string
    if num1 > num2 {
        result = "num1 is greater"
    } else {
        result = "num1 is not greater"
    }
    fmt.Println(result)
}

Explanation:

The if statement checks if num1 is greater than num2.
Since 10 is greater than 5, the result is set to "num1 is greater".
The result is then printed.

Expected Output:

num1 is greater

Composite Assignment Operators

Composite assignment operators combine arithmetic or bitwise operations with assignment in a single operation.

Example:

package main

import "fmt"

func main() {
    num := 8
    num += 2
    fmt.Println("After Addition Assignment, num is", num) // Result: 10
    num *= 2
    fmt.Println("After Multiplication Assignment, num is", num) // Result: 20
}

Explanation:

The += operator adds 2 to num, making it 10.
The *= operator multiplies num by 2, resulting in 20.

Expected Output:

After Addition Assignment, num is 10
After Multiplication Assignment, num is 20

Operator Precedence and Associativity

Precedence Levels

Operator precedence determines the order in which operators in an expression are evaluated. Operators with higher precedence are evaluated before those with lower precedence.

Example:

package main

import "fmt"

func main() {
    num1 := 15
    num2 := 3
    num3 := 2
    result := num1 / num2 + num3 * 2
    fmt.Println("Result:", result)
}

Explanation:

The / operator has higher precedence than +.
First, num1 / num2 is evaluated (15 / 3 = 5).
Then, the result is added to num3 * 2 (2 * 2 = 4).
The final evaluation is 5 + 4 = 9.

Expected Output:

Result: 9

Associativity Rules

Associativity determines the order of evaluation when operators of the same precedence are present. Most operators in Go have left-to-right associativity.

Example:

package main

import "fmt"

func main() {
    result := 5 - 3 + 2
    fmt.Println("Result:", result)
}

Explanation:

The - operator is evaluated before the + operator because they have the same precedence and left-to-right associativity.
First, 5 - 3 is evaluated (result is 2).
Then, 2 + 2 is evaluated (result is 4).

Expected Output:

Result: 4

Using Operators with Different Data Types

Integer Operations

Arithmetic operations can be performed on integer types. However, dividing two integers in Go results in an integer division, discarding the remainder.

Example:

package main

import "fmt"

func main() {
    num1 := 15
    num2 := 4
    result := num1 / num2
    fmt.Println("Integer division of", num1, "by", num2, "is", result) // Result: 3
}

Explanation:

Both num1 and num2 are integers.
The / operator performs integer division, resulting in 3 (the remainder 3 is discarded).

Expected Output:

Integer division of 15 by 4 is 3

Floating-Point Operations

Go supports operations on floating-point numbers using float32 and float64 types.

Example:

package main

import "fmt"

func main() {
    num1 := 15.5
    num2 := 4.2
    result := num1 / num2
    fmt.Println("Division of", num1, "by", num2, "is", result) // Result: 3.6904761904761907
}

Explanation:

num1 and num2 are floating-point numbers.
The / operator performs division on floating-point numbers, resulting in a precision result.

Expected Output:

Division of 15.5 by 4.2 is 3.6904761904761907

Mixed-Type Operations

Go does not allow arithmetic operations between types or variables of different types directly. You need to perform type conversion.

Example:

package main

import "fmt"

func main() {
    var num1 int = 10
    var num2 float64 = 3.5
    result := float64(num1) + num2
    fmt.Println("Result of mixed-type addition is", result) // Result: 13.5
}

Explanation:

num1 is an integer, while num2 is a float.
To perform addition, we convert num1 to float64 using float64(num1).
The result of the addition is a float.

Expected Output:

Result of mixed-type addition is 13.5

Examples and Code Snippets

Simple Examples

Simple Addition

package main

import "fmt"

func main() {
    num1 := 10
    num2 := 5
    sum := num1 + num2
    fmt.Println("Sum:", sum)
}

Explanation:

The + operator adds num1 and num2.
The result is printed.

Expected Output:

Sum: 15

Simple Multiplication

package main

import "fmt"

func main() {
    num1 := 7
    num2 := 2
    product := num1 * num2
    fmt.Println("Product:", product)
}

Explanation:

The * operator multiplies num1 and num2.
The product is printed.

Expected Output:

Product: 14

Complex Examples

Complex Relational and Logical Example

package main

import "fmt"

func main() {
    num1 := 10
    num2 := 20
    condition := num1 < num2 && num1 != 0
    fmt.Println("Condition:", condition)
}

Explanation:

The relational operators < and != are used to form conditions.
The && operator combines these conditions.
The final condition is evaluated as true.

Expected Output:

Condition: true

Complex Bitwise and Arithmetic Example

package main

import "fmt"

func main() {
    a := 10  // Binary: 1010
    b := 3   // Binary: 0011
    result := (a & b) + 5
    fmt.Println("Result:", result)
}

Explanation:

The bitwise & operator is applied to a and b (result: 2, binary 0010).
The + operator adds 5 to the result of a & b.
The final result is 7.

Expected Output:

Result: 7

Real-World Examples

Calculating Total Cost

package main

import "fmt"

func main() {
    price := 15.99
    quantity := 10
    total := price * float64(quantity)
    fmt.Printf("Total cost: $%.2f\n", total)
}

Explanation:

price is a float64 representing the price of an item.
quantity is an integer representing the number of items.
The * operator multiplies price and quantity (after converting quantity to float64).
The total cost is formatted to two decimal places and printed.

Expected Output:

Total cost: $159.90

Checking Discount

package main

import "fmt"

func main() {
    totalAmount := 200.00
    discount := 0.10
    discountedAmount := totalAmount - (totalAmount * discount)
    fmt.Printf("Discounted Amount: $%.2f\n", discountedAmount)
}

Explanation:

totalAmount is the initial amount.
discount is the discount percentage.
The expression (totalAmount * discount) calculates the discount amount.
The - operator subtracts the discount from totalAmount.
The final discounted amount is printed.

Expected Output:

Discounted Amount: $180.00

Common Errors and Pitfalls

Division by Zero

Attempting to divide a number by zero in Go results in a runtime panic. Always ensure the divisor is not zero.

Example to Avoid:

package main

import "fmt"

func main() {
    num1 := 10
    num2 := 0
    result := num1 / num2 // This causes a runtime panic
    fmt.Println("Result:", result)
}

Explanation:

Dividing by zero is not allowed in Go.
This code will cause a runtime panic.

Expected Output:

runtime error: integer divide by zero

Overflow and Underflow

In Go, when an arithmetic operation exceeds the maximum representable value of the type, it results in overflow or underflow.

Example:

package main

import "fmt"

func main() {
    var num int8 = 127
    num++
    fmt.Println("After incrementing:", num)
}

Explanation:

num is an int8, which can hold values from -128 to 127.
Incrementing num from 127 to 128 causes integer overflow, wrapping around to -128.

Expected Output:

After incrementing: -128

Summary

Recap of Key Points

Arithmetic Operators: Perform mathematical operations like addition, subtraction, multiplication, division, and remainder.
Relational Operators: Compare operands and return boolean values.
Logical Operators: Combine multiple conditions using AND, OR, and NOT.
Assignment Operators: Assign values to variables, including compound assignment operators.
Bitwise Operators: Perform operations at the bit level.
Miscellaneous Operators: Include conditional and composite assignment operators.

Importance of Understanding Operators

Operators are the backbone of any programming language, enabling you to manipulate data, perform calculations, make decisions, and control the flow of a program. Understanding the different types of operators and their behaviors is crucial for writing robust and efficient code.

By mastering the use of operators, you'll be better equipped to solve complex problems and create more sophisticated programs. Keep practicing with different examples to solidify your understanding of how operators work in Go.

This guide has covered a wide range of operators in Go, providing code examples and explanations to help you get started. Feel confident in using operators to build more powerful and effective Go programs. As you continue to learn, you'll find more ways to leverage these operators in your projects.

PreviousType Inference And Type Aliases

NextBasic Input And Output Fmt Package

Introduction

Go Language Fundamentals

Control Flow & Decision Making

Functions In Go

Pointers & Memory Manage

Arrays Slices And Maps

Structs And Interfaces

Concurrency & Goroutines

File Handling And Io Operations

Error Handling In Go

Packages And Modules In Go

Operators in Go - Arithmetic, Relational, Logical, etc.

Introduction to Operators in Go

What are Operators?

Overview of Operators in Programming

Arithmetic Operators

Basic Arithmetic Operators

Addition

Subtraction

Multiplication

Division

Modulo

Advanced Arithmetic Operators

Increment

Decrement

Relational Operators

Types of Relational Operators

Equal to

Not Equal to

Greater Than

Less Than

Greater Than or Equal to

Less Than or Equal to

Logical Operators

Types of Logical Operators

Logical AND

Logical OR

Logical NOT

Assignment Operators

Basic Assignment Operators

Simple Assignment

Addition Assignment

Subtraction Assignment

Multiplication Assignment

Division Assignment

Modulo Assignment

Bitwise Operators

Types of Bitwise Operators

Bitwise AND

Bitwise OR

Bitwise XOR

Bitwise Complement

Left Shift

Right Shift

Other Operators

Conditional (Ternary) Operator

Composite Assignment Operators

Operator Precedence and Associativity

Precedence Levels

Associativity Rules

Using Operators with Different Data Types

Integer Operations

Floating-Point Operations

Mixed-Type Operations

Examples and Code Snippets

Simple Examples

Simple Addition

Simple Multiplication

Complex Examples

Complex Relational and Logical Example

Complex Bitwise and Arithmetic Example

Real-World Examples

Calculating Total Cost

Checking Discount

Common Errors and Pitfalls

Division by Zero

Overflow and Underflow

Summary

Recap of Key Points

Importance of Understanding Operators