Repository files navigation

• Overview
• Introduction to Go
• Pros and Cons
• Basic Code Syntax
• Go Print Statements
• Go Format Specifiers
• String in Go
• String methods
• Slice in Go
• Slice methods
• Array vs Slice
• Go map
• Projects in Repository

Welcome to theGo Practice Document, where we'll explore the features and benefits of the Go programming language. This document aims to provide a professional overview of Go and highlight its important aspects.

Go is a statically typed programming language that compiles code into binary executables. It offers several key advantages that make it a popular choice among developers:

• Pros:

  • Statically Typed Language:
    • Type checks before compilation
    • Variable types are known before compilation like C, C++ & Java
  • Efficient Memory Management:
    • Fast and reliable
    • Great garbage collector for memory management
  • Extensive Standard Library:
    • Includes packages for HTTP, JSON, file I/O, and more
    • Reduces the need for external dependencies
  • Cross-Compilation:
    • Code can be compiled for different platforms without hassle
  • Concurrency:
    • Uses goroutines and channels for lightweight and efficient concurrency

• Cons:

  • Smaller Community compared to other languages/frameworks
  • Limited GUI Support
  • Smaller Libraries compared to languages like Ruby
  • Minimalistic Syntax

To provide a taste of Go, here's an example of the classic"Hello, World!" program in Go:

package mainimport"fmt"funcmain() {fmt.Println("Hello, World!")}

Output:

Hello, World!

The Go programming language provides several print statement options that allow you to output text and values to the console. Here are three commonly used print statements in Go:

1. fmt.Println(): This statement prints the given arguments to the console, adding a new line after each print.

2. fmt.Print(): This statement prints the given arguments to the console without adding a new line. Subsequent prints will be displayed on the same line.

3. fmt.Printf(): This statement provides more control over the output by using format specifiers. It allows you to format and print values based on their type.

package mainimport"fmt"funcmain() {fmt.Println("Hello, World!")fmt.Println("Hello, Sparta!")}

Output:

Hello, World!Hello, Sparta!

package mainimport"fmt"funcmain() {fmt.Print("Hello ")fmt.Print("Sparta!")}

Output:

Hello Sparta!

package mainimport"fmt"funcmain() {fmt.Printf("%s\n","Hello, Sparta!")fmt.Printf("%d\n",12345)fmt.Printf("%g\n",12.50)fmt.Printf("%t\n",true)}

Output:

Hello, Sparta!1234512.50true

In the last example, we used format specifiers such as%s for strings,%d for integers,%g for floating-point numbers, and%t for booleans. The\n represents a new line character, which adds a line break after each print statement.

These print statements are essential for displaying output and debugging in Go, allowing you to communicate with the user and inspect the values of variables during program execution.

• A string in Go is asequence of bytes.
• Strings areenclosed in double quotes ("like this") or backticks (`like this`).
• Strings in Go areimmutable, meaning they cannot be changed once created.
• Go provides arich set of string manipulation functions in thestrings package for tasks likesearching, replacing, splitting, and more.
• Strings can becompared using the== or!= operators forequality or inequality.

package mainimport ("fmt""strings")funcmain() {// Define a string variablemessage:="hello world"// Compare two stringsresult:=strings.Compare("abc","abd")fmt.Println(result)// Output: -1// Check if a string contains another stringresult=strings.Contains(message,"world")fmt.Println(result)// Output: true// Convert a string to uppercaseresult=strings.ToUpper(message)fmt.Println(result)// Output: HELLO WORLD// Convert a string to lowercaseresult=strings.ToLower(message)fmt.Println(result)// Output: hello world// Replace all occurrences of a substring with another substringresult=strings.Replace(message,"world","everyone",-1)fmt.Println(result)// Output: hello everyone// Split a string into an array of substringsresultArray:=strings.Split(message," ")fmt.Println(resultArray)// Output: [hello world]// Join an array of substrings into a single stringresult=strings.Join(resultArray,",")fmt.Println(result)// Output: hello,world}

• Aslice in Go is avariable-size sequence of elements that provides a moreflexible and powerful alternative to arrays.
• Slices are builton top of arrays and provide adynamic view into the underlying array.
• Unlike arrays, slices cangrow or shrink in size as needed, allowing for moreefficient memory usage.
• Slices are represented by athree-part structure: apointer to the underlying array, alength indicating the number of elements in the slice, and acapacity representing the maximum number of elements the slice can hold.
• Slices are widely used in Go to work withcollections of data, such as lists, buffers, or dynamic arrays.

package mainimport"fmt"funcmain() {// Create a slicenumbers:= []int{1,2,3,4,5}// Accessing elements of a slicefmt.Println(numbers[0])// Output: 1fmt.Println(numbers[2])// Output: 3// Modifying elements of a slicenumbers[1]=10fmt.Println(numbers)// Output: [1 10 3 4 5]// Slicing a sliceslice:=numbers[2:4]fmt.Println(slice)// Output: [3 4]}

• When passing an array to a function, Go makes a copy of the array, and the function works on the copy. So, any modifications to the array inside the function do not affect the original array in the calling function.
• On the other hand, when passing a slice to a function, Go passes a reference to the underlying array, which means that the function can modify the original array.

Here's an example demonstrating the differences:

package mainimport ("fmt")funcmodifyArray(arr [3]int) {arr[0]=100fmt.Println("Inside modifyArray:",arr)}funcmodifySlice(slc []int) {slc[0]=100fmt.Println("Inside modifySlice:",slc)}funcmain() {arr:= [3]int{1,2,3}slc:= []int{1,2,3}fmt.Println("Before modifyArray:",arr)modifyArray(arr)fmt.Println("After modifyArray:",arr)fmt.Println("\nBefore modifySlice:",slc)modifySlice(slc)fmt.Println("After modifySlice:",slc)}

OUTPUTBefore modifyArray: [1 2 3]Inside modifyArray: [100 2 3]After modifyArray: [1 2 3]Before modifySlice: [1 2 3]Inside modifySlice: [100 2 3]After modifySlice: [100 2 3]

In summary, when passing an array to a function, you're working with a copy, while when passing a slice, you're working with a reference to the original data. This is the primary difference when passing arrays and slices to functions in Go.

Go maps are a built-in data structure that associate keys with values. They are similar to dictionaries in Python or hash tables in other programming languages. Some key features of Go maps include:

• Dynamic size: Maps in Go can grow or shrink in size as needed.
• Unordered: The order in which elements are stored in a map is not guaranteed, and iterating over a map may yield different orders.
• Reference type: Maps are reference types, which means that when you assign a map to another variable, they both point to the same underlying data. Modifying one will affect the other.
• Zero value: The zero value of a map isnil. Anil map has no keys, nor can keys be added.

Here's a summary of common map operations in Go:

• Create a map: To create a map, you can use themake function or initialize it with key-value pairs.
• Add/Update an entry: To add or update a key-value pair in the map, use the assignment operator (=).
• Delete an entry: To remove a key-value pair from the map, use thedelete function.
• Get an entry: To retrieve the value of a key in the map, use the index operator ([]).
• Check if key exists: To verify if a key is in the map, use the, ok idiom when getting an entry.
• Length of the map: To get the number of entries in the map, use thelen function.
• Iterate over the map: To loop through the map's key-value pairs, use therange keyword in afor loop.

This repository also contains several projects that you can explore and use. Each project focuses on a different aspect of software development. Here is a list of the projects included along with a brief explanation:

• blog_post_orm_system: A blog post management system with an ORM (Object-Relational Mapping) approach.
• Updated migrations of blog_post_orm_system: Updated migrations for the blog post management system using ORM.
• budget_management_system_orm: A budget management system implemented using an ORM approach.
• education-management-system: A system for managing educational resources and information.
• library_management_api: An API for managing library resources and operations.
• simple_blog_api: A simple API for creating and managing blog posts.
• task_management_api_graphql: An API for managing tasks using GraphQL.
• task_manager_api: An API for managing tasks and tracking progress.
• task_manager_api_with_bun: An API for task management using the Bun ORM.
• task_tracker_api_with_graphql_and_bun: An API for tracking tasks using GraphQL and the Bun ORM.

Each project has its ownREADME file in its respective repository. You can navigate to each project's repository to find more information about the project, its purpose, and instructions on how to use it. Feel free to explore and utilize these projects according to your requirements.