Golang Operators And Expressions Complete Guide

 Last Update:2025-06-23T00:00:00     .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION.    8 mins read      Difficulty-Level: beginner

Understanding the Core Concepts of GoLang Operators and Expressions

GoLang Operators and Expressions

GoLang, often referred to as Golang, is a statically typed, compiled programming language designed by Google. Like most programming languages, Go utilizes operators to perform operations on various data types. Operators can be broadly categorized into several types, each serving unique purposes: arithmetic, assignment, comparison, logical, bitwise, and others.

Arithmetic Operators

Arithmetic operators are fundamental for performing mathematical calculations. They include:

  • + (Addition): Combines the values of two operands.
  • - (Subtraction): Subtracts the second operand from the first.
  • * (Multiplication): Multiplies the values of two operands.
  • / (Division): Divides the first operand by the second. Division between integers will round down to the nearest integer. For float results, use float operands.
  • % (Modulus): Finds the remainder after dividing one operand by another.
  • ++ (Increment): Increases an integer operand's value by one. Prefix (++i) increment the value before its use, postfix (i++) uses the value before incrementing.
  • -- (Decrement): Decreases an integer operand's value by one. Similar rules apply as with the increment operator.

Assignment Operators

Assignment operators simplify the process of assigning a value to a variable. Here's a list:

  • = (Simple Assignment): Assigns the right operand to the left operand.
  • += (Add AND): Adds left and right operands and assigns the result to the left operand.
  • -= (Subtract AND): Subtracts right operand from left and assigns the result to the left operand.
  • *= (Multiply AND): Multiplies left and right operands and assigns the result to the left operand.
  • /= (Divide AND): Divides left operand by right operand and assigns the result to the left operand.
  • %= (Modulus AND): Takes modulus using left and right operands and assigns the result to the left operand.
  • &= (Bitwise AND AND): Performs a bitwise AND operation between the left and right operands, then assigns the result to the left operand.
  • |= (Bitwise OR AND): Performs a bitwise inclusive OR between the left and right operands, then assigns the result to the left operand.
  • ^= (Bitwise XOR AND): Performs a bitwise exclusive OR between the left and right operands, then assigns the result to the left operand.
  • <<= (Left shift AND): Left shifts the left operand by the number of bits specified by the right operand, then assigns the result to the left operand.
  • >>= (Right shift AND): Right shifts the left operand by the number of bits specified by the right operand, then assigns the result to the left operand.
  • &^= (Bit clear): Clears the bits set in the right operand from the left operand.

Example:

var i int = 10  
i += 2          // equivalent to i = i + 2

Comparison Operators

Comparison operators compare two values and return a Boolean value (true or false):

  • == (Equal to): Checks if the operands are equal.
  • != (Not equal to): Checks if the operands are not equal.
  • > (Greater than): Checks if the left operand is greater than the right.
  • < (Less than): Checks if the left operand is less than the right.
  • >= (Greater than or equal to): Checks if the left operand is greater than or equal to the right.
  • <= (Less than or equal to): Checks if the left operand is less than or equal to the right.

Example:

fmt.Println(5 == 5)   // Outputs: true
fmt.Println(5 > 3)    // Outputs: true
fmt.Println(5 <= 3)   // Outputs: false

Logical Operators

Logical operators are used to evaluate Boolean expressions:

  • && (AND): Returns true if both operands are true, else returns false.
  • || (OR): Returns true if at least one of the operands is true, else returns false.
  • ! (NOT): Reverses the Boolean result of the following expression. If the expression is true, the NOT operator makes it false and vice versa.

Example:

fmt.Println(true && false) // Outputs: false
fmt.Println(true || false) // Outputs: true
fmt.Println(!true)         // Outputs: false

Bitwise Operators

Go supports various bitwise operators that manipulate individual bits:

  • & (Bitwise AND): Compares each bit of its operands. If both corresponding bits are 1, the output bit is set; otherwise, it's 0.
  • | (Bitwise OR): Produces a 1 if either of the corresponding bits is 1.
  • ^ (Bitwise XOR): Produces a 1 if one of the corresponding bits is 1, but not both.
  • << (Left Shift): Moves all bits in its left operand to the left by the number of positions specified by the right operand.
  • >> (Right Shift): Moves all bits in its left operand to the right by the number of positions specified by the right operand.
  • &^ (Bit clear): Sets all bits in its left operand to 0 if the corresponding bit in the right operand is 1.

Example:

a := 5        // binary is 0101
b := 3        // binary is 0011

c := a & b    // Outputs: 1 (binary 0001)
d := a | b    // Outputs: 7 (binary 0111)
e := a ^ b    // Outputs: 6 (binary 0110)
f := a << 1   // Outputs: 10 (binary 1010)
g := a >> 1   // Outputs: 2 (binary 0010)
h := a &^ b   // Outputs: 4 (binary 0100)

Miscellaneous Operators

Other important operators include:

  • & (Address-of): Returns the memory address of a variable.
  • * (Pointer): Used with pointers to access the value stored at the memory address.

Example:

var val int = 5
ptr := &val  // ptr holds the memory address of val
fmt.Println(ptr)   // Outputs the memory address

value := *ptr      // Dereferences ptr to get the actual value held
fmt.Println(value)   // Outputs: 5
  • , (Comma Operator): Allows multiple statements within a single line, particularly useful in for loops and switch statements.

Example:

a, b := 1, 2
fmt.Println(a, b) // Outputs: 1 2
  • := (Short Variable Declaration): Shorthand for declaring and initializing variables, only valid inside functions.

Example:

func main() {
    a := 10               // shorthand for var a int = 10
    fmt.Println(a)        // Outputs: 10
}

Expressions

An expression in GoLang is a combination of values, variables, constants, functions, and operators. The evaluation of an expression yields another value.

Examples:

x := 1 + 2       // expression: 1 + 2
y := x - 1       // expression: x - 1
z := y * 2 + 3   // expression: y * 2 + 3
r := float64(x) / 2 // type conversion followed by division

Complex Expressions: They can involve multiple operators combined. To ensure a specific order of evaluation, parentheses are used to group sub-expressions.

Example:

p := (3 + 5) * 2   // expression: (3 + 5) * 2 evaluates to 16

Operator Precedence

Each operator in Go has its precedence, which determines the order of operation execution in complex expressions:

From highest to lowest precedence:

  1. Postfix Operators (x++, x--)
  2. Unary Operators (!x, -x, *x, &x, <-chan x)
  3. Multiplicative Operators (*, /, %, <<, >>, &, &^)
  4. Additive Operators (+, -, |, ^)
  5. Shift Operators (<<, >>)
  6. Bitwise Bit Clear Operators (&^)
  7. Relational Operators (==, !=, <, <=, >, >=)
  8. Logical AND Operator (&&)
  9. Logical OR Operator (||)
  10. Conditional Operator (?:) - Not available in Go.
  11. Assignment Operators (=, +=, -=, *=, /=, etc.)

Higher precedence means that operators appear more frequently to the right in the same expression. Example:

x := 7 + 5 * 6     // Evaluates (7 + (5 * 6)) = 37, not ((7 + 5) * 6)

For controlling the evaluation order explicitly, use parentheses:

x := (7 + 5) * 6   // Explicitly evaluates ((7 + 5) * 6) = 72

Important Points to Remember

  1. Go does not support operator overloading, meaning you can't redefine the behavior of built-in operators like + or * for user-defined types.
  2. The ++ and -- operators can only be applied to int, uint, uintptr, float, complex, and pointer types.
  3. Arithmetic operations between mismatched types require explicit type conversion. This prevents unintended data loss or corruption.
  4. Go’s switch statement does not fall through default, unlike some other languages where fall-through is common unless specified otherwise.
  5. Pointers: Understanding and properly managing pointers is crucial for advanced optimization and dynamic memory allocation tasks.

Operators and expressions form the core of many constructs in Go, including conditionals, loops, and function calls. Mastery of these concepts ensures efficient and clean code development.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement GoLang Operators and Expressions

Complete Examples, Step by Step for Beginners

Introduction to GoLang Operators

Operators in GoLang are symbols that are used to perform operations on variables and values. GoLang supports several types of operators, including:

  • Arithmetic
  • Assignment
  • Comparison
  • Logical
  • Bitwise
  • Others

1. Arithmetic Operators

Arithmetic operators are used to perform common mathematical operations.

Example 1: Simple Arithmetic Operations

package main

import "fmt"

func main() {
    var a int = 10
    var b int = 3

    fmt.Println("Addition:", a+b) // Output: Addition: 13
    fmt.Println("Subtraction:", a-b) // Output: Subtraction: 7
    fmt.Println("Multiplication:", a*b) // Output: Multiplication: 30
    fmt.Println("Division:", a/b) // Output: Division: 3
    fmt.Println("Modulus:", a%b) // Output: Modulus: 1
}

2. Assignment Operators

Assignment operators are used to assign values to variables.

Example 2: Using Assignment Operators

package main

import "fmt"

func main() {
    var a int = 10
    var b int

    b = a
    fmt.Println("b =", b) // Output: b = 10

    b += a // b = b + a
    fmt.Println("b =", b) // Output: b = 20

    b -= a // b = b - a
    fmt.Println("b =", b) // Output: b = 10

    b *= a // b = b * a
    fmt.Println("b =", b) // Output: b = 100

    b /= a // b = b / a
    fmt.Println("b =", b) // Output: b = 10

    b %= a // b = b % a
    fmt.Println("b =", b) // Output: b = 0
}

3. Comparison Operators

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

Example 3: Using Comparison Operators

package main

import "fmt"

func main() {
    var a int = 10
    var b int = 20

    fmt.Println("a == b:", a == b) // Output: a == b: false
    fmt.Println("a != b:", a != b) // Output: a != b: true
    fmt.Println("a > b:", a > b) // Output: a > b: false
    fmt.Println("a < b:", a < b) // Output: a < b: true
    fmt.Println("a >= b:", a >= b) // Output: a >= b: false
    fmt.Println("a <= b:", a <= b) // Output: a <= b: true
}

4. Logical Operators

Logical operators are used to combine multiple conditions.

Example 4: Using Logical Operators

package main

import "fmt"

func main() {
    var a bool = true
    var b bool = false

    fmt.Println("a && b:", a && b) // Output: a && b: false
    fmt.Println("a || b:", a || b) // Output: a || b: true
    fmt.Println("!a:", !a) // Output: !a: false
}

5. Bitwise Operators

Bitwise operators work on the binary representation of the integers.

Example 5: Using Bitwise Operators

package main

import "fmt"

func main() {
    var a int = 5  // binary: 0101
    var b int = 3  // binary: 0011

    fmt.Println("a & b:", a & b) // Output: a & b: 1 (binary: 0001)
    fmt.Println("a | b:", a | b) // Output: a | b: 7 (binary: 0111)
    fmt.Println("a ^ b:", a ^ b) // Output: a ^ b: 6 (binary: 0110)
    fmt.Println("a << b:", a << b) // Output: a << b: 20 (binary: 10100)
    fmt.Println("a >> b:", a >> b) // Output: a >> b: 1 (binary: 01)
}

6. Other Operators

a. := (Short Declaration Operator)

The := operator is used to declare and initialize variables in a concise way.

package main

import "fmt"

func main() {
    a := 10
    b := "Hello, Go!"

    fmt.Println("a:", a) // Output: a: 10
    fmt.Println("b:", b) // Output: b: Hello, Go!
}

b. The len Function

The len() function returns the length or size of a string, slice, array, map, or channel.

package main

import "fmt"

func main() {
    str := "Hello, Go!"
    slice := []int{1, 2, 3, 4, 5}

    fmt.Println("Length of string:", len(str)) // Output: Length of string: 11
    fmt.Println("Length of slice:", len(slice)) // Output: Length of slice: 5
}

Conclusion

Understanding and using operators and expressions is fundamental to programming in GoLang. These examples should help beginners to grasp the basics and start applying them in their own Go programs. Practice using different types of operators to become more comfortable and proficient in GoLang.

Top 10 Interview Questions & Answers on GoLang Operators and Expressions

1. What are the basic arithmetic operators in GoLang?

In Go, the basic arithmetic operators include:

  • + (addition)
  • - (subtraction)
  • * (multiplication)
  • / (division)
  • % (modulus, remainder of division)
  • + and - (unary operators used to denote positive or negative)

Here's an example:

func main() {
    a, b := 10, 3
    fmt.Println(a + b) // Output: 13
    fmt.Println(a - b) // Output: 7
    fmt.Println(a * b) // Output: 30
    fmt.Println(a / b) // Output: 3 (integer division)
    fmt.Println(a % b) // Output: 1
}

Note that in Go, the division operator / performs integer division when used with integers, meaning it floors the result.

2. How do you use assignment operators in GoLang?

Assignment operators in Go are used to assign values to variables and include:

  • = (simple assignment)
  • += (add and assign)
  • -= (subtract and assign)
  • *= (multiply and assign)
  • /= (divide and assign)
  • %= (modulus and assign)

Example:

func main() {
    a := 10     // Simple assignment
    a += 5      // a is now 15
    a -= 3      // a is now 12
    a *= 2      // a is now 24
    a /= 4      // a is now 6
    a %= 2      // a is now 0
    fmt.Println(a)
}

3. Can you explain comparison operators in GoLang?

Comparison operators in Go are used to compare two values:

  • == (equal to)
  • != (not equal to)
  • > (greater than)
  • < (less than)
  • >= (greater than or equal to)
  • <= (less than or equal to)

Example:

func main() {
    a, b := 10, 5
    fmt.Println(a == b)  // Output: false
    fmt.Println(a != b)  // Output: true
    fmt.Println(a > b)   // Output: true
    fmt.Println(a < b)   // Output: false
    fmt.Println(a >= b)  // Output: true
    fmt.Println(a <= b)  // Output: false
}

Note that all comparison operators always return a boolean value (true or false).

4. What are the logical operators in GoLang?

Logical operators in Go are used to combine conditional statements:

  • && (logical AND)
  • || (logical OR)
  • ! (logical NOT)

Example:

func main() {
    a, b := true, false
    fmt.Println(a && b)  // Output: false
    fmt.Println(a || b)  // Output: true
    fmt.Println(!a)      // Output: false
    fmt.Println(!b)      // Output: true
}

5. How do bitwise operators work in GoLang?

Bitwise operators operate on individual bits of a binary number:

  • & (bitwise AND)
  • | (bitwise OR)
  • ^ (bitwise XOR)
  • &^ (bitwise AND NOT)
  • << (left shift)
  • >> (right shift)

Example:

func main() {
    a, b := 4, 2
    fmt.Println(a & b)    // Output: 0 (binary: 100 & 010 = 000)
    fmt.Println(a | b)    // Output: 6 (binary: 100 | 010 = 110)
    fmt.Println(a ^ b)    // Output: 6 (binary: 100 ^ 010 = 110)
    fmt.Println(a &^ b)   // Output: 4 (binary: 100 &^ 010 = 100)
    fmt.Println(a << 1)   // Output: 8 (binary: 100 << 1 = 1000)
    fmt.Println(a >> 1)   // Output: 2 (binary: 100 >> 1 = 10)
}

6. What is an expression in GoLang and how is it evaluated?

An expression in GoLang is a combination of values, variables, operators and function calls that the compiler evaluates to a single value. Evaluation order is generally left-to-right unless specified by parentheses or higher precedence rules.

Example:

func main() {
    a := 10 + 5 * 2       // Evaluation: 5*2 => 10, followed by 10 + 10 => 20
    b := (10 + 5) * 2     // Evaluation: 10 + 5 => 15, followed by 15*2 => 30
    fmt.Println(a, b)     // Output: 20 30
}

Here, * operator has higher precedence than +, hence evaluated first unless overridden by parentheses.

7. What is the difference between == and != in GoLang?

== is the equality operator, used to check whether two operands are equal. If they are, it returns true; otherwise, it returns false. Conversely, != is the inequality operator, returns true if two operands are not equal, otherwise false.

Example:

func main() {
    a, b := 5, 10
    fmt.Println(a == b)  // Output: false
    fmt.Println(a != b)  // Output: true
}

8. Can you describe the short-circuit behavior in GoLang logical operators?

GoLang uses short-circuit evaluation for logical operators. In short-circuit evaluation, the second operand of the operator is evaluated only if the result is not already determined by the first operand.

  • For &&: If the first operand is false, the result is false regardless of the second operand. So, the second operand is not evaluated.
  • For ||: If the first operand is true, the result is true regardless of the second operand. So, the second operand is not evaluated.

Example:

func main() {
    fmt.Println(true && (false || false))  // Output: false. Second part of && not evaluated.
    fmt.Println(false || (true && false)) // Output: true. Second part of || not evaluated.
}

9. What is the ternary operator in GoLang?

GoLang does not have a ternary operator (?:) like some other languages such as C, C++, and Java. Instead, you must use an if-else statement to achieve similar functionality.

Example:

func main() {
    a, b := 10, 20
    var max int
    if a >= b {
        max = a
    } else {
        max = b
    }
    fmt.Println(max)  // Output: 20
}

10. What are the increment and decrement operators in GoLang?

Increment (++) and Decrement (--) operators in Go are used to increase or decrease the value of a variable by 1.

Example:

func main() {
    a := 5
    a++                 // a is now 6
    fmt.Println(a)      // Output: 6
    a--                 // a is now 5
    fmt.Println(a)      // Output: 5
}

Note that these operators can be used either as prefix or postfix. However, unlike some languages, the prefix and postfix versions of these operators behave identically in Go and do not result in different outcomes in expressions.

You May Like This Related .NET Topic

📥 Download Code ▶️ Watch Online 📖 Read Description

Login to post a comment.