Introduction to Go Programming

• The document is an introductory guide to the Go programming language.
• Go is designed for building simple, fast, and reliable software.
• It emphasizes ease of use, efficiency, and readability.

Key Features of Go

• Go is easy to learn.
• It has built-in concurrency and a robust standard library.
• Go supports fast compilation and garbage collection.
• It is known for being simple, reliable, and efficient.

First Go Program

• A basic Go program consists of a package declaration, import statements, and a main function.
• package main declares the package as the entry point of the program.
• import "fmt" imports the "fmt" package, which provides formatted I/O functions.
• func main() {} is the main function where the program execution begins.
• fmt.Println("Hello, World") prints the "Hello, World" message to the console.

Running a Go Program

• Save the Go program in a file with a .go extension (e.g., hello.go).
• Open a command terminal and navigate to the directory where the file is saved.
• Run the program using the command go run hello.go.
• The program will compile and execute, printing the output to the console.

Go Syntax Fundamentals

• Go source code is written in UTF-8.
• Statements are terminated by semicolons, which are usually inserted automatically by the compiler.
• Comments can be single-line (//) or multi-line (/* ... */).

Data Types

• Go has several basic data types including int, float64, string, and bool.
• int represents integers.
• float64 represents floating-point numbers.
• string represents text.
• bool represents boolean values (true or false).

Variables

• Variables are declared using the var keyword followed by the variable name and type. For example: var age int.
• Variables can be initialized during declaration: var age int = 30.
• Type inference allows omitting the type when initializing a variable: var name = "John".
• Short variable declaration using := can be used inside functions: age := 30.
• Multiple variables can be declared together: var x, y int.

Constants

• Constants are declared using the const keyword: const PI = 3.14159.
• The value of a constant must be known at compile time.

Operators

• Go supports common arithmetic operators: +, -, *, /, %.
• It also includes assignment operators: =, +=, -=, *=, /=, %=.
• Comparison operators: ==, !=, >, <, >=, <=.
• Logical operators: && (AND), || (OR), ! (NOT).

Control Structures

• Go has if, else if, and else statements for conditional execution.
• for loops are used for iteration. Go does not have while loops.
• switch statements provide multi-way branching.

If Statements

• if condition { ... } executes the block if the condition is true.
• if condition { ... } else { ... } executes one block if the condition is true and another if it is false.
• if condition1 { ... } else if condition2 { ... } else { ... } provides multiple conditional checks.

For Loops

• A basic for loop: for i := 0; i < 10; i++ { ... }.
• Go only has one looping construct: the for loop.
• The for loop can also be used as a "while" loop by omitting the initialization and increment parts: for condition { ... }.
• An infinite loop: for { ... }.

Switch Statements

• switch variable { case value1: ... case value2: ... default: ... } executes the case matching the variable's value.
• The break statement is implicit in Go; execution does not fall through to the next case automatically.

Arrays

• An array is a fixed-size sequence of elements of the same type.
• Arrays are declared as: var arr [5]int.
• Array elements are accessed using their index: arr[0] = 1.
• The len() function returns the length of an array.

Slices

• A slice is a dynamically-sized, flexible view into the elements of an array.
• Slices are declared as: var slice []int.
• Slices can be created using the make() function: slice := make([]int, 5).
• You can append elements to a slice using the append() function: slice = append(slice, 10).
• Slices can be created from arrays, specifying a low and high bound: slice := arr[1:4].

Maps

• A map is a collection of key-value pairs.
• Maps are declared as: var m map[string]int.
• Maps are created using the make() function: m := make(map[string]int).
• Elements are added to a map as: m["age"] = 30.
• Retrieve values from a map like this: age := m["age"].
• You can check if a key exists in a map: age, ok := m["age"].

Functions

• Functions are declared using the func keyword.
• A function definition includes the function name, parameters, and return type.
• Example: func add(x int, y int) int { return x + y }.
• Multiple return values are supported: func divide(x, y float64) (float64, error) { ... }.

Pointers

• A pointer holds the memory address of a value.
• Pointers are declared using the * operator: var ptr *int.
• The address of a variable is obtained using the & operator: ptr = &age.
• The value pointed to by a pointer is accessed using the * operator: value := *ptr.

Structs

• A struct is a composite data type that groups together variables of different types.
• Structs are declared using the type and struct keywords: type Person struct { Name string; Age int }.
• Fields of a struct are accessed using the dot notation: person.Name = "John".

Methods

• A method is a function associated with a specific type.
• Methods are defined using a receiver: func (p Person) introduce() { fmt.Println("Hello, my name is", p.Name) }.

Interfaces

• An interface is a type that specifies a set of methods that a type must implement.
• Interfaces are declared using the type and interface keywords: type Speaker interface { Speak() string }.
• Any type that implements the methods defined in an interface implicitly satisfies the interface.

Concurrency

• Go provides built-in support for concurrency using goroutines and channels.
• A goroutine is a lightweight, concurrent function.
• Channels are used to communicate between goroutines.

Goroutines

• A goroutine is started using the go keyword: go myFunction().
• Goroutines run concurrently with the calling function.

Channels

• Channels are used to send and receive values between goroutines.
• Channels are declared using the chan keyword: ch := make(chan int).
• Values are sent to a channel using the <- operator: ch <- 42.
• Values are received from a channel using the <- operator: value := <-ch.

Buffered Channels

• Buffered channels have a capacity and can hold a certain number of values without a receiver.
• Buffered channels are created using the make() function with a capacity: ch := make(chan int, 10).

Error Handling

• Go uses the error type to indicate errors.
• Functions that can fail typically return an error as the last return value.
• Errors are checked using an if statement: if err != nil { ... }.

Defer

• The defer statement schedules a function call to be run after the surrounding function returns.
• defer is often used to ensure that resources are released.
• Example: defer file.Close().

Packages

• A package is a collection of related Go files.
• Packages are imported using the import keyword: import "fmt".
• The standard library provides many useful packages, such as fmt, os, and net/http.