Go-lang with all Topics and sub-topics in simple words

Singaraju SaitejaSingaraju Saiteja
28 min read

What is Go?

Imagine Go as a fast, efficient, and easy-to-learn programming language created by Google. It's great for building all sorts of things, from websites and apps to tools for managing servers. Think of it as a language that's both powerful and friendly.

Let's dive into the topics:

1. Basics - Getting Started

  • 1.1 Installation:

    • Simple words: First, you need to download and install Go on your computer. It's like installing any software.

    • Example: Go to the official Go website (https://go.dev/dl/) and download the version for your operating system (Windows, macOS, Linux). Follow the installation instructions.

  • 1.2 "Hello, World!" Program:

    • Simple words: The first program everyone writes! It just displays "Hello, World!" on the screen.

    • Example:

              package main // Every Go program starts with a package declaration

  import "fmt" // Import the "fmt" package for printing

  func main() { // The main function is the entry point of your program
      fmt.Println("Hello, World!") // Print "Hello, World!" to the console
  }

      • Explanation:

        • package main: Tells Go this code is the main program.

        • import "fmt": Brings in the fmt package, which has functions for formatting and printing text (like Println).

        • func main() { ... }: Defines the main function where the program execution begins.

        • fmt.Println("Hello, World!"): Uses the Println function from the fmt package to print the text inside the quotes.

    • To run it:

      1. Save this code in a file named hello.go.

      2. Open your terminal or command prompt.

      3. Navigate to the folder where you saved hello.go using the cd command (e.g., cd Documents/GoProjects).

      4. Run the command: go run hello.go

      5. You should see "Hello, World!" printed on your screen.

  • 1.3 Basic Syntax:

    • Simple words: The rules of writing Go code. Like grammar in English.

    • Key things:

      • Packages: Code is organized into packages. main is for executables, other packages are for libraries of code you can reuse.

      • Imports: Use import to bring in code from other packages (like fmt).

      • Functions: Blocks of code that do specific tasks, defined with func. main is a special function.

      • Statements: Instructions that do something (like fmt.Println(...)).

      • Comments: Explanations in your code that Go ignores.

        • Single-line comments: // This is a comment

        • Multi-line comments: /* This is a multi-line comment */

      • Case Sensitivity: Go is case-sensitive! myVar is different from MyVar.

  • 1.4 Variables:

    • Simple words: Containers to store data. Like labeled boxes to put things in.

    • Declaration: You need to declare a variable before using it, telling Go its name and type.

    • Types: Go is statically typed, meaning you must specify the type of data a variable will hold (e.g., number, text, true/false).

    • Example:

              package main

  import "fmt"

  func main() {
      var age int // Declare a variable named 'age' of type integer (whole number)
      age = 30    // Assign the value 30 to the variable 'age'

      var name string = "Alice" // Declare 'name' of type string (text) and initialize it with "Alice"

      city := "New York" // Short declaration - Go infers the type (string in this case)

      fmt.Println("Name:", name)
      fmt.Println("Age:", age)
      fmt.Println("City:", city)
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Explanation:

        • var age int: Declares a variable named age to hold integer values.

        • age = 30: Assigns the value 30 to age.

        • var name string = "Alice": Declares name as a string and immediately assigns it the value "Alice".

        • city := "New York": A shorter way to declare and initialize. Go figures out that city should be a string because you're assigning text to it. This only works inside functions.

  • 1.5 Constants:

    • Simple words: Like variables, but their values cannot be changed after you set them. Think of them as fixed labels.

    • Declaration: Use the const keyword.

    • Example:

              package main

  import "fmt"

  func main() {
      const pi float64 = 3.14159 // Declare a constant named 'pi' of type float64 (decimal number)

      fmt.Println("Value of Pi:", pi)

      // pi = 3.14 // This would cause an error because you can't change a constant
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

2. Data Types

  • Simple words: Different kinds of data you can work with in Go. Like different types of LEGO bricks.

  • 2.1 Basic Data Types:

    • Integers (Numbers without decimals):

      • int: General integer type (size depends on your system, usually 32-bit or 64-bit).

      • int8, int16, int32, int64: Integers with specific sizes (8, 16, 32, 64 bits). int32 is also called rune and is often used for representing characters.

      • uint, uint8, uint16, uint32, uint64: Unsigned integers (only positive numbers and zero). uint8 is also called byte.

    • Floating-point Numbers (Numbers with decimals):

      • float32: Single-precision floating-point.

      • float64: Double-precision floating-point (more accurate). Often preferred.

    • Booleans (True or False):

      • bool: Represents logical values, either true or false.

    • Strings (Text):

      • string: Sequences of characters enclosed in double quotes "...".

    • Example:

              package main

  import "fmt"

  func main() {
      var age int = 35
      var price float64 = 99.99
      var isAdult bool = true
      var message string = "Hello, Go!"

      fmt.Println("Age:", age, ", Type:", "%T\n", age) // %T prints the type
      fmt.Println("Price:", price, ", Type:", "%T\n", price)
      fmt.Println("Is Adult:", isAdult, ", Type:", "%T\n", isAdult)
      fmt.Println("Message:", message, ", Type:", "%T\n", message)
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 2.2 Composite Data Types (More complex types built from basic types):

    • Arrays:

      • Simple words: Fixed-size list of elements of the same type. Like a row of identical LEGO bricks.

      • Example:

                package main

  import "fmt"

  func main() {
      var numbers [5]int // Declare an array named 'numbers' that can hold 5 integers

      numbers[0] = 10
      numbers[1] = 20
      numbers[2] = 30
      numbers[3] = 40
      numbers[4] = 50

      fmt.Println("Array:", numbers)
      fmt.Println("First element:", numbers[0])
      fmt.Println("Length of array:", len(numbers)) // 'len' function gets the length of arrays and slices
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

    • Slices:

      • Simple words: Flexible, dynamically sized list of elements of the same type. Like a flexible LEGO strip that can grow or shrink.

      • Example:

                package main

  import "fmt"

  func main() {
      // Create a slice using a slice literal
      fruits := []string{"apple", "banana", "orange"}

      fmt.Println("Slice:", fruits)
      fmt.Println("First fruit:", fruits[0])
      fmt.Println("Length of slice:", len(fruits))
      fmt.Println("Capacity of slice:", cap(fruits)) // Capacity is how much it can grow before needing to reallocate memory

      fruits = append(fruits, "grape") // Add "grape" to the end of the slice

      fmt.Println("Slice after append:", fruits)
      fmt.Println("New Length:", len(fruits))
      fmt.Println("New Capacity:", cap(fruits)) // Capacity might have increased
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

      • Key difference from arrays: Slices are much more commonly used in Go because they are dynamic (can grow and shrink). Arrays have fixed size.

    • Maps:

      • Simple words: Key-value pairs. Like a dictionary where you look up a word (key) to find its definition (value). Keys must be of a comparable type (like strings, integers), and values can be of any type.

      • Example:

                package main

  import "fmt"

  func main() {
      // Create a map where keys are strings and values are integers
      ages := map[string]int{
          "Alice": 30,
          "Bob":   25,
          "Charlie": 32,
      }

      fmt.Println("Map:", ages)
      fmt.Println("Age of Alice:", ages["Alice"])

      ages["David"] = 28 // Add a new key-value pair

      fmt.Println("Map after adding David:", ages)

      delete(ages, "Bob") // Remove the entry for "Bob"

      fmt.Println("Map after deleting Bob:", ages)

      age, exists := ages["Bob"] // Check if a key exists (optional second return value)
      if exists {
          fmt.Println("Age of Bob:", age)
      } else {
          fmt.Println("Bob's age not found in the map")
      }
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

    • Structs:

      • Simple words: Custom data types that group together related fields. Like creating your own LEGO brick with different parts.

      • Example:

                package main

  import "fmt"

  // Define a struct named 'Person'
  type Person struct {
      Name string
      Age  int
      City string
  }

  func main() {
      // Create a variable of type 'Person'
      person1 := Person{
          Name: "Eve",
          Age:  28,
          City: "London",
      }

      fmt.Println("Person 1:", person1)
      fmt.Println("Name of Person 1:", person1.Name) // Access fields using dot (.) notation

      person2 := Person{"Frank", 40, "Paris"} // Another way to initialize if you know the order
      fmt.Println("Person 2:", person2)
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

3. Control Flow

  • Simple words: How you control the order in which your code is executed. Like traffic lights for your code.

  • 3.1 if, else if, else Statements:

    • Simple words: Make decisions based on conditions. "If" something is true, do this; "else if" something else is true, do that; "else" if none of the above are true, do this other thing.

    • Example:

              package main

  import "fmt"

  func main() {
      age := 20

      if age >= 18 {
          fmt.Println("Adult") // Executed if age is 18 or older
      } else {
          fmt.Println("Minor")  // Executed if age is less than 18
      }

      score := 75

      if score >= 90 {
          fmt.Println("Excellent")
      } else if score >= 80 {
          fmt.Println("Very Good")
      } else if score >= 70 {
          fmt.Println("Good")
      } else {
          fmt.Println("Average or Below")
      }
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 3.2 for Loop:

    • Simple words: Repeat a block of code multiple times. Like doing the same LEGO building step many times.

    • Types of for loops in Go:

      • Basic for loop (like for in C, Java, etc.):

                package main

  import "fmt"

  func main() {
      for i := 0; i < 5; i++ { // Initialize i to 0; loop as long as i is less than 5; increment i after each loop
          fmt.Println("Iteration:", i)
      }
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

      • for loop as a while loop (condition only):

                package main

  import "fmt"

  func main() {
      count := 0
      for count < 3 { // Loop continues as long as count is less than 3
          fmt.Println("Count:", count)
          count++
      }
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

      • Infinite for loop (no condition - use break to exit):

                package main

  import "fmt"

  func main() {
      counter := 0
      for { // Loop forever until 'break' is encountered
          fmt.Println("Counter:", counter)
          counter++
          if counter > 2 {
              break // Exit the loop when counter becomes greater than 2
          }
      }
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

      • for...range loop (for iterating over collections like arrays, slices, maps, strings):

                package main

  import "fmt"

  func main() {
      fruits := []string{"apple", "banana", "orange"}

      for index, fruit := range fruits { // Iterate over the 'fruits' slice
          fmt.Println("Index:", index, ", Fruit:", fruit)
      }

      // You can also iterate over maps:
      ages := map[string]int{"Alice": 30, "Bob": 25}
      for name, age := range ages {
          fmt.Println("Name:", name, ", Age:", age)
      }

      // Or strings (iterates over runes - Unicode code points):
      message := "Go is fun!"
      for index, char := range message {
          fmt.Printf("Index: %d, Character: %c\n", index, char) // %c for character
      }
  }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

  • 3.3 switch Statement:

    • Simple words: Choose one block of code to execute from several options, based on the value of a variable. Like choosing a path at a fork in the road.

    • Example:

              package main

  import "fmt"

  func main() {
      day := "Tuesday"

      switch day {
      case "Monday":
          fmt.Println("It's Monday")
      case "Tuesday":
          fmt.Println("It's Tuesday")
      case "Wednesday":
          fmt.Println("It's Wednesday")
      default: // If none of the above cases match
          fmt.Println("It's some other day")
      }

      // Switch with multiple values in a case:
      grade := 'B'
      switch grade {
      case 'A', 'B', 'C': // Multiple cases can be grouped
          fmt.Println("Passing grade")
      case 'D', 'F':
          fmt.Println("Failing grade")
      default:
          fmt.Println("Invalid grade")
      }

      // Switch without a condition (like if-else if-else chain):
      number := 15
      switch { // No expression after 'switch'
      case number > 20:
          fmt.Println("Number is greater than 20")
      case number > 10:
          fmt.Println("Number is greater than 10 but not greater than 20")
      default:
          fmt.Println("Number is 10 or less")
      }
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 3.4 defer Statement:

    • Simple words: Schedule a function call to be executed later, right before the surrounding function exits. Think of it as saying "do this cleanup task at the very end."

    • Example:

              package main

  import "fmt"

  func main() {
      fmt.Println("Start")
      defer fmt.Println("Deferred statement 1") // This will run last in main()
      defer fmt.Println("Deferred statement 2") // This will run second to last in main()
      fmt.Println("Middle")
      fmt.Println("End")
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Output:

                Start
  Middle
  End
  Deferred statement 2
  Deferred statement 1

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.

        IGNORE_WHEN_COPYING_END

      • Explanation: defer statements are executed in reverse order of when they are encountered. They are very useful for cleanup tasks like closing files or releasing resources.

4. Functions

  • Simple words: Reusable blocks of code that perform specific tasks. Like having pre-built LEGO modules that you can use in different parts of your creation.

  • 4.1 Function Definition:

    • Simple words: Creating a function. You need to give it a name, specify what inputs it takes (parameters), and what it returns (return values).

    • Syntax:

              func functionName(parameterName1 parameterType1, parameterName2 parameterType2) (returnType1, returnType2) {
      // Function body (code to be executed)
      // ...
      return returnValue1, returnValue2 // Optional return statement
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

    • Example:

              package main

  import "fmt"

  // Function to add two integers
  func add(a int, b int) int { // Takes two integers 'a' and 'b' as input, returns an integer
      sum := a + b
      return sum
  }

  // Function to greet a person (no return value)
  func greet(name string) { // Takes a string 'name' as input, returns nothing (void-like)
      fmt.Println("Hello,", name, "!")
  }

  func main() {
      result := add(5, 3) // Call the 'add' function with arguments 5 and 3, store the result in 'result'
      fmt.Println("Sum:", result)

      greet("Alice") // Call the 'greet' function with argument "Alice"
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 4.2 Calling Functions:

    • Simple words: Using a function you've defined. You just write the function's name followed by parentheses () and provide the necessary inputs (arguments).

    • Example: See the main function in the example above where add(5, 3) and greet("Alice") are function calls.

  • 4.3 Parameters and Return Values:

    • Parameters: Inputs to a function. They are like placeholders for the data you'll give to the function when you call it. You specify their names and types in the function definition.

    • Return Values: Outputs from a function. A function can return one or more values (or no value at all). You specify the types of the return values in the function definition.

    • Example: In the add function, a and b are parameters, and int after the parentheses is the return type.

  • 4.4 Multiple Return Values:

    • Simple words: Go functions can return more than one value at once! This is very useful for returning both a result and an error status.

    • Example:

              package main

  import (
      "fmt"
      "errors" // Package for creating error values
  )

  // Function to divide two numbers, returning both the quotient and an error if division by zero occurs
  func divide(numerator int, denominator int) (int, error) {
      if denominator == 0 {
          return 0, errors.New("division by zero") // Create a new error
      }
      return numerator / denominator, nil // Return the quotient and 'nil' (no error)
  }

  func main() {
      quotient, err := divide(10, 2) // Call 'divide' and get both return values
      if err != nil { // Check if an error occurred
          fmt.Println("Error:", err)
      } else {
          fmt.Println("Quotient:", quotient)
      }

      quotient2, err2 := divide(5, 0)
      if err2 != nil {
          fmt.Println("Error:", err2)
      } else {
          fmt.Println("Quotient 2:", quotient2) // This won't be printed because of the error
      }
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 4.5 Variadic Functions:

    • Simple words: Functions that can take a variable number of arguments of the same type. Like a function that can sum up any number of input numbers.

    • Syntax: Use ... before the parameter type to indicate it's variadic.

    • Example:

              package main

  import "fmt"

  // Function to sum up any number of integers
  func sumNumbers(numbers ...int) int { // 'numbers' is a variadic parameter of type 'int' (it becomes a slice inside the function)
      total := 0
      for _, num := range numbers { // Iterate over the 'numbers' slice
          total += num
      }
      return total
  }

  func main() {
      result1 := sumNumbers(1, 2, 3, 4, 5) // Call with 5 arguments
      fmt.Println("Sum 1:", result1)

      result2 := sumNumbers(10, 20) // Call with 2 arguments
      fmt.Println("Sum 2:", result2)

      result3 := sumNumbers() // Call with no arguments
      fmt.Println("Sum 3:", result3)
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 4.6 Anonymous Functions (Function Literals):

    • Simple words: Functions without names. They are often used for short, one-off tasks, especially as callbacks or closures.

    • Example:

              package main

  import "fmt"

  func main() {
      // Assign an anonymous function to a variable
      addFunc := func(a int, b int) int {
          return a + b
      }

      result := addFunc(8, 2) // Call the anonymous function through the variable
      fmt.Println("Anonymous function result:", result)

      // Immediately invoke an anonymous function (self-executing function)
      func(message string) {
          fmt.Println("Message from anonymous function:", message)
      }("Hello from anonymous function!") // Pass "Hello..." as an argument
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

5. Pointers

  • Simple words: A pointer is like an address that tells you where a variable is stored in the computer's memory. Think of it as a street address pointing to a house (the variable).

  • 5.1 Declaration and Dereferencing:

    • Declaration: To declare a pointer variable, use * before the type.

    • Dereferencing: To get the value stored at the memory address pointed to by a pointer, use * before the pointer variable name (dereferencing).

    • Address-of Operator (&): To get the memory address of a variable, use & before the variable name.

    • Example:

              package main

  import "fmt"

  func main() {
      var num int = 10
      var ptr *int // Declare a pointer variable 'ptr' that can point to an integer

      ptr = &num // Assign the memory address of 'num' to 'ptr' (ptr now points to num)

      fmt.Println("Value of num:", num)     // Output: 10
      fmt.Println("Address of num:", &num) // Output: Memory address of num (will vary)
      fmt.Println("Value of ptr:", ptr)     // Output: Same memory address as &num
      fmt.Println("Value pointed to by ptr:", *ptr) // Dereference ptr to get the value at that address (Output: 10)

      *ptr = 25 // Change the value at the memory address pointed to by ptr (this changes the value of num!)

      fmt.Println("Value of num after changing through pointer:", num) // Output: 25 (num has been changed)
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 5.2 Passing Pointers to Functions:

    • Simple words: You can pass pointers as arguments to functions. This allows the function to directly modify the original variable outside the function. This is called "pass-by-reference" (though Go is technically always pass-by-value, pointers allow similar behavior).

    • Example:

              package main

  import "fmt"

  // Function that takes an integer pointer as input and modifies the value it points to
  func modifyValue(ptr *int) {
      *ptr = 100 // Change the value at the address pointed to by 'ptr'
  }

  func main() {
      number := 50
      fmt.Println("Value before modification:", number) // Output: 50

      modifyValue(&number) // Pass the memory address of 'number' to 'modifyValue'

      fmt.Println("Value after modification:", number)  // Output: 100 (number has been changed by the function)
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Without Pointers (Pass-by-Value): If you passed number directly to modifyValue (without &), the function would only modify a copy of number, and the original number in main would remain unchanged. Pointers allow functions to work with the original data.

6. Methods and Interfaces

  • These are related to object-oriented programming concepts, but Go takes a slightly different approach.

  • 6.1 Methods:

    • Simple words: Functions associated with a specific type (like structs). They operate on values of that type. Think of them as actions that objects of a certain type can perform.

    • Receiver: Methods have a receiver – the value of the type that the method is called on. It's like the "subject" of the method call.

    • Example:

              package main

  import "fmt"

  // Define a struct 'Rectangle'
  type Rectangle struct {
      Width  float64
      Height float64
  }

  // Method for 'Rectangle' to calculate its area
  func (r Rectangle) Area() float64 { // '(r Rectangle)' is the receiver - 'r' is the receiver variable name, 'Rectangle' is the receiver type
      return r.Width * r.Height // Access fields of the receiver 'r' using dot notation
  }

  // Method for 'Rectangle' to calculate its perimeter
  func (r Rectangle) Perimeter() float64 {
      return 2 * (r.Width + r.Height)
  }

  func main() {
      rect := Rectangle{Width: 5, Height: 3}

      area := rect.Area()       // Call the 'Area' method on the 'rect' variable
      perimeter := rect.Perimeter() // Call the 'Perimeter' method on 'rect'

      fmt.Println("Rectangle Area:", area)
      fmt.Println("Rectangle Perimeter:", perimeter)
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 6.2 Interfaces:

    • Simple words: A contract that defines a set of methods that a type must implement. Think of it as saying "any type that wants to be considered 'Shape' must have methods to calculate 'Area' and 'Perimeter'." Interfaces define what a type can do, not how it does it.

    • Implicit Implementation: In Go, types implement interfaces implicitly. If a type has all the methods defined in an interface, it automatically implements that interface. No need to explicitly declare it.

    • Example:

              package main

  import (
      "fmt"
      "math"
  )

  // Define an interface 'Shape'
  type Shape interface {
      Area() float64
      Perimeter() float64
  }

  // Rectangle struct (already defined in the Methods example)
  type Rectangle struct {
      Width  float64
      Height float64
  }
  func (r Rectangle) Area() float64 { return r.Width * r.Height }
  func (r Rectangle) Perimeter() float64 { return 2 * (r.Width + r.Height) }

  // Circle struct
  type Circle struct {
      Radius float64
  }
  func (c Circle) Area() float64 { return math.Pi * c.Radius * c.Radius }
  func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.Radius }

  // Function that takes a 'Shape' interface as input
  func printShapeInfo(s Shape) { // 's' is of type 'Shape' interface
      fmt.Println("Area:", s.Area())
      fmt.Println("Perimeter:", s.Perimeter())
  }

  func main() {
      rect := Rectangle{Width: 5, Height: 3}
      circ := Circle{Radius: 4}

      printShapeInfo(rect) // 'Rectangle' implements 'Shape', so it can be passed to 'printShapeInfo'
      printShapeInfo(circ) // 'Circle' also implements 'Shape'
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Explanation: Both Rectangle and Circle have Area() and Perimeter() methods that return float64. Therefore, they both implicitly implement the Shape interface. The printShapeInfo function can accept any value that implements the Shape interface.

  • 6.3 Empty Interface interface{}:

    • Simple words: An interface with no methods. This means any type in Go implements the empty interface. It's like a universal type that can hold values of any type.

    • Usefulness: Useful when you need to work with values of unknown types, but you lose type safety at compile time. You'll often need type assertions or type switches to work with the underlying value.

7. Concurrency

  • Simple words: Doing multiple things at the same time. Go is excellent at concurrency, making it easy to write programs that can handle many tasks efficiently.

  • 7.1 Goroutines:

    • Simple words: Lightweight, concurrently executing functions. Think of them as threads, but much cheaper and easier to manage. You launch a goroutine using the go keyword before a function call.

    • Example:

              package main

  import (
      "fmt"
      "time"
  )

  func printNumbers() {
      for i := 1; i <= 5; i++ {
          fmt.Println("Numbers:", i)
          time.Sleep(time.Millisecond * 200) // Pause for 200 milliseconds
      }
  }

  func printLetters() {
      for i := 'a'; i <= 'e'; i++ {
          fmt.Println("Letters:", string(i)) // Convert rune to string for printing
          time.Sleep(time.Millisecond * 300)
      }
  }

  func main() {
      go printNumbers() // Launch 'printNumbers' as a goroutine
      go printLetters() // Launch 'printLetters' as another goroutine

      time.Sleep(time.Second * 2) // Wait for 2 seconds to allow goroutines to run
      fmt.Println("Main function finished")
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Explanation: go printNumbers() and go printLetters() start these functions as goroutines. They run concurrently with the main function. time.Sleep(time.Second * 2) in main is crucial to give the goroutines time to execute before the main function exits (otherwise, the program might end before the goroutines finish).

  • 7.2 Channels:

    • Simple words: A way for goroutines to communicate and synchronize with each other. Think of them as pipes through which goroutines can send and receive data. Channels help prevent race conditions (where multiple goroutines try to access and modify shared data at the same time, leading to unpredictable results).

    • Declaration: make(chan dataType) creates a channel that can carry values of dataType.

    • Send Operation (<-): channel <- value sends a value into the channel.

    • Receive Operation (<-): value := <-channel receives a value from the channel and assigns it to value.

    • Example:

              package main

  import (
      "fmt"
      "time"
  )

  func sender(channel chan string) {
      messages := []string{"Hello", "Channels", "in", "Go"}
      for _, msg := range messages {
          fmt.Println("Sender sending:", msg)
          channel <- msg          // Send message to the channel
          time.Sleep(time.Millisecond * 500)
      }
      close(channel) // Close the channel when done sending (important for range loops over channels)
  }

  func receiver(channel chan string) {
      for msg := range channel { // Receive messages from the channel until it's closed
          fmt.Println("Receiver received:", msg)
          time.Sleep(time.Millisecond * 200)
      }
  }

  func main() {
      messageChannel := make(chan string) // Create a channel that carries strings

      go sender(messageChannel)   // Start sender goroutine
      go receiver(messageChannel) // Start receiver goroutine

      time.Sleep(time.Second * 3) // Wait for 3 seconds to allow goroutines to communicate
      fmt.Println("Main function finished")
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Explanation:

        • messageChannel := make(chan string) creates a channel for strings.

        • sender goroutine sends messages into messageChannel.

        • receiver goroutine receives messages from messageChannel.

        • close(channel) in sender signals that no more messages will be sent. The range channel loop in receiver will terminate when the channel is closed.

  • 7.3 Buffered Channels:

    • Simple words: Channels with a limited capacity. They can hold a certain number of values before blocking the sender. Think of them as pipes with a small buffer.

    • Creation: make(chan dataType, bufferSize) creates a buffered channel with a buffer of bufferSize.

    • Example:

              package main

  import "fmt"

  func main() {
      bufferedChannel := make(chan int, 2) // Create a buffered channel that can hold 2 integers

      bufferedChannel <- 1 // Send 1 to the channel (won't block yet because buffer has space)
      bufferedChannel <- 2 // Send 2 to the channel (buffer is now full)

      // bufferedChannel <- 3 // This would block because the buffer is full and no receiver is ready

      fmt.Println(<-bufferedChannel) // Receive 1 (frees up space in the buffer)
      fmt.Println(<-bufferedChannel) // Receive 2 (buffer is now empty)

      // fmt.Println(<-bufferedChannel) // This would block because the channel is empty and no sender is sending
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

  • 7.4 select Statement (for Channel Operations):

    • Simple words: Allows a goroutine to wait on multiple channel operations. It blocks until one of the channels is ready to send or receive. If multiple channels are ready, it chooses one randomly. Useful for handling timeouts and multiple communication paths.

    • Example:

              package main

  import (
      "fmt"
      "time"
  )

  func main() {
      channel1 := make(chan string)
      channel2 := make(chan string)

      go func() {
          time.Sleep(time.Second * 1)
          channel1 <- "Message from channel 1"
      }()

      go func() {
          time.Sleep(time.Second * 2)
          channel2 <- "Message from channel 2"
      }()

      select { // Wait for the first channel to receive a message
      case msg1 := <-channel1:
          fmt.Println("Received from channel 1:", msg1)
      case msg2 := <-channel2:
          fmt.Println("Received from channel 2:", msg2)
      case <-time.After(time.Millisecond * 1500): // Timeout case - wait for 1.5 seconds
          fmt.Println("Timeout: No message received within 1.5 seconds")
      }
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Explanation: select waits for either channel1 or channel2 to receive a message, or for the timeout (time.After) to occur. The first case that becomes ready is executed.

8. Error Handling

  • Simple words: How to deal with problems that happen during program execution. Like catching errors and preventing your program from crashing.

  • 8.1 error Type:

    • Simple words: Go's standard way to represent errors. It's an interface with a single method Error() string that returns an error message. Functions that might fail often return an error as the last return value.

    • Example: We saw errors.New("division by zero") earlier in the "Functions" section.

  • 8.2 panic and recover:

    • panic: Signals a serious, unrecoverable error. It stops the current function's execution and starts unwinding the call stack (going back up the chain of function calls). If a panic is not handled, the program crashes. Think of it as a "fire alarm" for critical errors.

    • recover: A built-in function that can be used to regain control after a panic. It can only be called inside a deferred function. It stops the panic unwinding and returns the value that was passed to panic. If recover is called outside a deferred function, it does nothing and returns nil. Think of it as a "fire extinguisher" that can be used to handle the "fire alarm".

    • Example:

              package main

  import "fmt"

  func riskyFunction() {
      fmt.Println("Risky function started")
      panic("Something went wrong!") // Trigger a panic
      fmt.Println("This line will not be reached") // This line is not executed
  }

  func main() {
      fmt.Println("Main function started")

      defer func() { // Deferred function to handle panic
          if r := recover(); r != nil { // 'recover' returns the panic value if a panic occurred
              fmt.Println("Recovered from panic:", r)
          }
      }() // Immediately invoke the deferred function

      riskyFunction() // Call the function that might panic

      fmt.Println("Main function continues after recover") // This line is executed because of 'recover'
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

      • Explanation:

        • riskyFunction calls panic("Something went wrong!"), causing a panic.

        • The defer func() { ... }() in main is executed after the panic occurs but before the program crashes.

        • recover() inside the deferred function catches the panic.

        • The program recovers and continues execution from after the recover call.

  • 8.3 Custom Errors:

    • Simple words: You can create your own error types to provide more specific error information. Often done by creating structs that implement the error interface.

    • Example:

              package main

  import (
      "fmt"
      "time"
  )

  // Define a custom error type 'ValidationError'
  type ValidationError struct {
      FieldName string
      Message   string
      Timestamp time.Time
  }

  // Implement the 'error' interface for 'ValidationError'
  func (e ValidationError) Error() string {
      return fmt.Sprintf("Validation Error: Field '%s', Message: '%s', Time: %v", e.FieldName, e.Message, e.Timestamp)
  }

  func validateInput(input string) error {
      if len(input) < 5 {
          return ValidationError{
              FieldName: "input",
              Message:   "Input too short",
              Timestamp: time.Now(),
          }
      }
      return nil // No error
  }

  func main() {
      err := validateInput("abc")
      if err != nil {
          // Type assertion to check if it's a ValidationError
          if validationErr, ok := err.(ValidationError); ok {
              fmt.Println("Validation Error Details:")
              fmt.Println("Field:", validationErr.FieldName)
              fmt.Println("Message:", validationErr.Message)
              fmt.Println("Time:", validationErr.Timestamp)
          } else {
              fmt.Println("Generic Error:", err) // Handle other types of errors
          }
      } else {
          fmt.Println("Input is valid")
      }
  }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

9. Packages and Modules

  • Simple words: Ways to organize your Go code into reusable pieces. Packages are like folders to group related code files. Modules manage dependencies (external libraries your code uses).

  • 9.1 Packages:

    • Simple words: Collections of Go source files in the same directory. Packages help organize code and provide namespaces (preventing name clashes).

    • Package Declaration: Every Go file starts with package packageName. package main is for executable programs. Other packages are for libraries.

    • Importing Packages: Use import "packageName" to use code from another package.

    • Example (Creating and using a package):

      1. Create a folder named mypackage in your Go project's src directory (or wherever your Go code is organized).

      2. Inside mypackage, create a file named math_utils.go with the following content:

               package mypackage // Package declaration

 // Exported function (starts with a capital letter)
 func Add(a int, b int) int {
     return a + b
 }

 // Unexported function (starts with a lowercase letter) - only accessible within the 'mypackage' package
 func subtract(a int, b int) int {
     return a - b
 }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

      3. Create another file (e.g., main.go) in your project's root directory with this content:

               package main

 import (
     "fmt"
     "mypackage" // Import your custom package
 )

 func main() {
     sum := mypackage.Add(10, 5) // Call the exported function 'Add' from 'mypackage'
     fmt.Println("Sum:", sum)

     // subtraction := mypackage.subtract(10, 5) // This would cause an error - 'subtract' is unexported
 }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

      4. Run go run main.go from your project's root directory.

  • 9.2 Modules:

    • Simple words: Manage dependencies (external libraries) for your Go projects and ensure reproducible builds. Introduced in Go 1.11.

    • go.mod file: At the root of your project, create a go.mod file using go mod init yourModuleName (e.g., go mod init myproject). This file tracks your project's dependencies.

    • Adding Dependencies: When you import an external package (e.g., import "github.com/gorilla/mux"), Go will automatically download it and update your go.mod and go.sum files (which record the specific versions and checksums of your dependencies).

    • Example (Using a module and an external package):

      1. Create a project folder (e.g., gomodule-example).

      2. Navigate into the folder in your terminal.

      3. Initialize a module: go mod init gomodule-example (this creates go.mod).

      4. Create a file main.go:

               package main

 import (
     "fmt"
     "net/http"

     "github.com/gorilla/mux" // Example external package - a popular HTTP router
 )

 func homeHandler(w http.ResponseWriter, r *http.Request) {
     fmt.Fprintln(w, "Welcome to the homepage!")
 }

 func main() {
     r := mux.NewRouter() // Use the mux router from the external package
     r.HandleFunc("/", homeHandler)

     fmt.Println("Server starting on :8080")
     http.ListenAndServe(":8080", r)
 }

        IGNORE_WHEN_COPYING_START

        content_copy download

        Use code with caution.Go

        IGNORE_WHEN_COPYING_END

      5. Run go run main.go. Go will automatically download the github.com/gorilla/mux package and its dependencies.

      6. Open your browser and go to http://localhost:8080. You should see "Welcome to the homepage!".

10. Standard Library

  • Simple words: Go comes with a rich set of built-in packages (the standard library) that provide a lot of functionality "out of the box." No need to write everything from scratch.

  • Examples of useful standard library packages:

    • fmt: Formatting and printing (we've used this a lot!).

    • net/http: Building web servers and clients.

    • os: Operating system functions (file system, environment variables, etc.).

    • io: Input/output operations.

    • strings: String manipulation.

    • strconv: String conversions (to numbers, etc.).

    • time: Working with time and dates.

    • math: Mathematical functions.

    • encoding/json, encoding/xml: Encoding and decoding JSON and XML data.

    • sync: Synchronization primitives for concurrent programming (like sync.WaitGroup, sync.Mutex).

11. Testing

  • Simple words: Writing code to automatically check if your Go code works correctly. Good testing is crucial for writing reliable software.

  • testing package: Go has a built-in testing package.

  • Test files: Test files are named *_test.go (e.g., my_function_test.go).

  • Test functions: Test functions in test files start with Test (e.g., func TestAdd(t testing.T) { ... }). They take a testing.T argument, which provides methods for reporting test failures (t.Errorf, t.Fatalf).

  • Example:

    1. Create a file math_utils.go (or reuse the one from the "Packages" example) with an Add function:

             package math_utils

 func Add(a int, b int) int {
     return a + b
 }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

    2. Create a test file math_utils_test.go in the same directory:

             package math_utils_test // Important: package name should be 'packageName_test'

 import (
     "testing"
     "mypackage" // Import the package you want to test (adjust path if needed)
 )

 func TestAdd(t *testing.T) { // Test function for the 'Add' function
     result := mypackage.Add(2, 3)
     expected := 5
     if result != expected {
         t.Errorf("Add(2, 3) returned %d, expected %d", result, expected) // Report an error if result is not as expected
     }

     result2 := mypackage.Add(-1, 1)
     expected2 := 0
     if result2 != expected2 {
         t.Errorf("Add(-1, 1) returned %d, expected %d", result2, expected2)
     }
 }

      IGNORE_WHEN_COPYING_START

      content_copy download

      Use code with caution.Go

      IGNORE_WHEN_COPYING_END

    3. Run tests: In your terminal, navigate to the directory containing math_utils_test.go and run go test. Go will find and run all test functions in that directory and its subdirectories.

0
Subscribe to my newsletter

Read articles from Singaraju Saiteja directly inside your inbox. Subscribe to the newsletter, and don't miss out.

Go LanguagegogolangGolang developerGolang web developmentGolang Web Frameworkgolang slices

Written by

Singaraju Saiteja
Singaraju Saiteja

I am an aspiring mobile developer, with current skill being in flutter.