Go Operators

« Previous Next »

Go Operators

Operators in Go are special symbols used to perform operations on variables and values. They form the foundation of expressions and are essential for writing efficient and logical programs.

What Are Operators in Go?

An operator performs a specific task such as addition, comparison, or logical evaluation.

For example, the + operator is used to add values:

Example: Basic Addition

package main import "fmt" func main() { result := 12 + 8 fmt.Println("Result:", result) }

Result: 20

Using Operators with Variables

Operators can also work with variables and expressions, not just fixed values.

Example: Operations with Variables

package main import "fmt" func main() { base := 50 increment := 25 total := base + increment double := total + total fmt.Println("Total:", total) fmt.Println("Double Total:", double) }

Total: 75 Double Total: 150

Types of Operators in Go

Go provides several categories of operators, each designed for a specific purpose.

1. Arithmetic Operators

These operators perform basic mathematical calculations.

Operator	Description	Example
+	Addition	a + b
-	Subtraction	a - b
*	Multiplication	a * b
/	Division	a / b
%	Modulus (remainder)	a % b

Example

package main import "fmt" func main() { a := 20 b := 6 fmt.Println("Addition:", a+b) fmt.Println("Subtraction:", a-b) fmt.Println("Multiplication:", a*b) fmt.Println("Division:", a/b) fmt.Println("Remainder:", a%b) }

Addition: 26 Subtraction: 14 Multiplication: 120 Division: 3 Remainder: 2

2. Assignment Operators

Assignment operators are used to assign values to variables.

Operator	Example	Equivalent To
=	x = 10	Assign value
+=	x += 5	x = x + 5
-=	x -= 3	x = x - 3
*=	x *= 2	x = x * 2
/=	x /= 4	x = x / 4

Example

package main import "fmt" func main() { value := 10 value += 5 value *= 2 fmt.Println("Final Value:", value) }

Final Value: 30

3. Comparison Operators

These operators compare two values and return a boolean result (true or false).

Operator	Description	Example
==	Equal to	a == b
!=	Not equal to	a != b
>	Greater than	a > b
<	Less than	a < b
>=	Greater or equal	a >= b
<=	Less or equal	a <= b

Example

package main import "fmt" func main() { x := 15 y := 10 fmt.Println("x > y:", x > y) fmt.Println("x == y:", x == y) fmt.Println("x != y:", x != y) }

x > y: true x == y: false x != y: true

4. Logical Operators

Logical operators are used to combine multiple conditions.

Operator	Description	Example
&&	Logical AND	a > 5 && b < 10
||	Logical OR	a > 5 || b < 10
!	Logical NOT	!(a > b)

Example

package main import "fmt" func main() { age := 20 hasID := true fmt.Println("Eligible:", age >= 18 && hasID) }

Eligible: true

5. Bitwise Operators

Bitwise operators work at the binary level and are useful for low-level programming.

Operator	Description
&	AND
|	OR
^	XOR
<<	Left shift
>>	Right shift

Example

package main import "fmt" func main() { a := 5 // 0101 b := 3 // 0011 fmt.Println("AND:", a&b) fmt.Println("OR:", a|b) fmt.Println("XOR:", a^b) fmt.Println("Left Shift:", a<<1) fmt.Println("Right Shift:", a>>1) }

AND: 1 OR: 7 XOR: 6 Left Shift: 10 Right Shift: 2

Go Arithmetic Operators

Arithmetic operators in Go are used to perform basic mathematical calculations such as addition, subtraction, multiplication, and more. These operators are essential for building expressions and handling numeric data in your programs.

List of Arithmetic Operators in Go

Operator	Name	Description	Example
+	Addition	Adds two values	x + y
-	Subtraction	Subtracts one value from another	x - y
*	Multiplication	Multiplies two values	x * y
/	Division	Divides one value by another	x / y
%	Modulus	Returns the remainder of division	x % y
++	Increment	Increases a variable’s value by 1	x++
--	Decrement	Decreases a variable’s value by 1	x--

Example: Using Arithmetic Operators in Go

package main import "fmt" func main() { a := 18 b := 4 fmt.Println("Addition:", a+b) fmt.Println("Subtraction:", a-b) fmt.Println("Multiplication:", a*b) fmt.Println("Division:", a/b) fmt.Println("Modulus:", a%b) counter := 5 counter++ // increment fmt.Println("After Increment:", counter) counter-- // decrement fmt.Println("After Decrement:", counter) }

Addition: 22 Subtraction: 14 Multiplication: 72 Division: 4 Modulus: 2 After Increment: 6 After Decrement: 5

Important Notes

1. Integer Division

When both operands are integers, division returns an integer result (decimal part is truncated):

result := 7 / 2 // result = 3

To get a floating-point result, use float64:

result := float64(7) / float64(2) // result = 3.5

2. Increment and Decrement Restrictions

In Go, ++ and --:

• Can only be used as statements, not expressions
• Cannot be used inside other operations like y = x++

Go Assignment Operators

Assignment operators in Go are used to assign values to variables and update them efficiently. They are fundamental to managing data and performing operations in a concise way.

What Are Assignment Operators?

An assignment operator assigns a value to a variable. The most basic operator is =.

Example: Basic Assignment

package main import "fmt" func main() { score := 95 fmt.Println("Score:", score) }

Score: 95

Compound Assignment Operators

Go provides compound assignment operators that combine arithmetic or bitwise operations with assignment. These operators make code shorter and more readable.

Example: Using Compound Assignment

package main import "fmt" func main() { points := 20 points += 10 // add and assign points *= 2 // multiply and assign fmt.Println("Final Points:", points) }

Final Points: 60

List of Assignment Operators in Go

Operator	Example	Equivalent Expression
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 3	x = x - 3
*=	x *= 3	x = x * 3
/=	x /= 3	x = x / 3
%=	x %= 3	x = x % 3
&=	x &= 3	x = x & 3
|=	x |= 3	x = x | 3
^=	x ^= 3	x = x ^ 3
>>=	x >>= 2	x = x >> 2
<<=	x <<= 2	x = x << 2

Example: Multiple Assignment Operations

package main import "fmt" func main() { value := 12 value -= 2 // 10 value *= 3 // 30 value /= 5 // 6 value %= 4 // 2 fmt.Println("Final Value:", value) }

Final Value: 2

Bitwise Assignment Example

package main import "fmt" func main() { flags := 6 // binary: 110 flags &= 3 // binary: 011 → result: 010 (2) fmt.Println("Updated Flags:", flags) }

Updated Flags: 2

Key Benefits of Assignment Operators

• Reduce code verbosity
• Improve readability
• Combine operations efficiently
• Commonly used in loops and calculations

Go Comparison Operators

Comparison operators in Go are used to compare two values or expressions. These operators are essential for decision-making in programs, especially when working with conditions such as if, else, and loops.

What Are Comparison Operators?

A comparison operator evaluates the relationship between two values and returns a boolean result:

• true → if the condition is satisfied
• false → if the condition is not satisfied

Note: In Go, the result is strictly true or false (not 1 or 0 as in some other languages).

Example: Basic Comparison

package main import "fmt" func main() { a := 12 b := 7 fmt.Println("Is a greater than b?", a > b) }

Is a greater than b? true

List of Comparison Operators in Go

Operator	Name	Example
==	Equal to	x == y
!=	Not equal to	x != y
>	Greater than	x > y
<	Less than	x < y
>=	Greater than or equal to	x >= y
<=	Less than or equal to	x <= y

Example: Using Multiple Comparison Operators

package main import "fmt" func main() { marks := 75 passMark := 50 fmt.Println("Passed:", marks >= passMark) fmt.Println("Perfect score:", marks == 100) fmt.Println("Needs improvement:", marks < 60) }

Passed: true Perfect score: false Needs improvement: false

Using Comparison Operators in Conditions

package main import "fmt" func main() { age := 18 if age >= 18 { fmt.Println("Eligible to vote") } else { fmt.Println("Not eligible to vote") } }

Eligible to vote

Go Logical Operators

Logical operators are essential in programming for combining and evaluating multiple conditions. They allow you to build complex decision-making logic by working with boolean values (true or false).

These operators are commonly used in conditional statements such as if, while, and for loops.

Types of Logical Operators

Most programming languages, including C, C++, Java, and Go, support the following three logical operators:

Operator	Name	Description
&&	Logical AND	Returns true only if both conditions are true
||	Logical OR	Returns true if at least one condition is true
!	Logical NOT	Reverses the result (true becomes false, false becomes true)

1. Logical AND (&&)

The Logical AND operator evaluates to true only when all conditions are true.

Example:

#include <stdio.h> int main() { int age = 20; int hasID = 1; if (age >= 18 && hasID) { printf("Entry allowed.\n"); } else { printf("Entry denied.\n"); } return 0; }

Entry allowed.

Explanation:

• The condition checks whether the person is at least 18 years old and has an ID.
• Both conditions must be true for access to be granted.

2. Logical OR (||)

The Logical OR operator returns true if any one of the conditions is true.

Example:

#include <stdio.h> int main() { int isMember = 0; int hasCoupon = 1; if (isMember || hasCoupon) { printf("Discount applied.\n"); } else { printf("No discount available.\n"); } return 0; }

Discount applied.

Explanation:

• The discount is applied if the user is a member or has a coupon.
• Only one condition needs to be true.

3. Logical NOT (!)

The Logical NOT operator is used to invert a condition.

Example:

#include <stdio.h> int main() { int isRaining = 0; if (!isRaining) { printf("You can go outside.\n"); } else { printf("Stay indoors.\n"); } return 0; }

You can go outside.

Explanation:

• !isRaining means “it is NOT raining.”
• The result is reversed: 0 (false) becomes true.

Combining Logical Operators

Logical operators can be combined to form more complex conditions.

Example:

#include <stdio.h> int main() { int marks = 85; int attendance = 75; if ((marks > 80 && attendance > 70) || marks > 90) { printf("Eligible for reward.\n"); } else { printf("Not eligible.\n"); } return 0; }

Eligible for reward.

Explanation:

• A student is eligible if:
• They have good marks and attendance, or
• They have exceptionally high marks.

Go Bitwise Operators

Bitwise operators allow you to perform operations directly on the binary (bit-level) representation of integers. These operators are commonly used in low-level programming, performance optimization, embedded systems, and tasks involving flags or masks.

Unlike logical operators, which work with boolean values, bitwise operators manipulate individual bits (0s and 1s) within a number.

Why Use Bitwise Operators?

Bitwise operations are:

• Fast and efficient (executed at the hardware level)
• Useful for memory optimization
• Widely used in system programming, encryption, and data compression

Types of Bitwise Operators

Operator	Name	Description
&	Bitwise AND	Sets each bit to 1 if both corresponding bits are 1
|	Bitwise OR	Sets each bit to 1 if at least one bit is 1
^	Bitwise XOR	Sets each bit to 1 if the bits are different
<<	Left Shift	Shifts bits to the left, filling with 0s from the right
>>	Right Shift	Shifts bits to the right (preserves sign in signed types)

1. Bitwise AND (&)

The AND operator compares each bit of two numbers and returns 1 only if both bits are 1.

Example:

#include <stdio.h> int main() { int a = 6; // Binary: 110 int b = 3; // Binary: 011 int result = a & b; // 010 (2) printf("Bitwise AND result: %d\n", result); return 0; }

Bitwise AND result: 2

Explanation:

  110  (6)
& 011  (3)
------
  010  (2)

2. Bitwise OR (|)

The OR operator returns 1 if at least one of the bits is 1.

Example:

#include <stdio.h> int main() { int a = 5; // Binary: 101 int b = 2; // Binary: 010 int result = a | b; // 111 (7) printf("Bitwise OR result: %d\n", result); return 0; }

Bitwise OR result: 7

Explanation:

  101  (5)
| 010  (2)
------
  111  (7)

3. Bitwise XOR (^)

The XOR (exclusive OR) operator returns 1 only when the bits are different.

Example:

#include <stdio.h> int main() { int a = 7; // Binary: 111 int b = 4; // Binary: 100 int result = a ^ b; // 011 (3) printf("Bitwise XOR result: %d\n", result); return 0; }

Bitwise XOR result: 3

Explanation:

  111  (7)
^ 100  (4)
------
  011  (3)

4. Left Shift (<<)

The left shift operator moves bits to the left and fills the right side with zeros. Each shift left effectively multiplies the number by 2.

Example:

#include <stdio.h> int main() { int value = 4; // Binary: 100 int result = value << 2; // 10000 (16) printf("Left shift result: %d\n", result); return 0; }

Left shift result: 16

Explanation:

  00000100  (4)
<< 2
----------
  00010000  (16)

5. Right Shift (>>)

The right shift operator moves bits to the right. For signed integers, the leftmost bit (sign bit) is preserved.

Example:

#include <stdio.h> int main() { int value = 16; // Binary: 10000 int result = value >> 2; // 00100 (4) printf("Right shift result: %d\n", result); return 0; }

Right shift result: 4

Explanation:

  00010000  (16)
>> 2
----------
  00000100  (4)

Practical Use Case: Bit Masking

Bitwise operators are often used to set, clear, and check specific bits.

Example:

#include <stdio.h> int main() { int flags = 0; // Set bit 1 (turn ON) flags = flags | (1 << 1); // Check if bit 1 is set if (flags & (1 << 1)) { printf("Bit 1 is ON\n"); } // Clear bit 1 (turn OFF) flags = flags & ~(1 << 1); printf("Final flags value: %d\n", flags); return 0; }

Bit 1 is ON Final flags value: 0

« Previous Next »

AI Code Explanation Go Language

Powered by Gocourse AI