Scribd
Upload
54 views6 pages

# Go Programming Course

Uploaded by

tung
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
54 views6 pages

# Go Programming Course

Uploaded by

tung
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

# Go Programming Course

## Week 3: Custom Types and Interfaces


Version 1.0 - January 2025

## Table of Contents

1. Collection Types
- Arrays
- Slices
- Maps

2. Module 05: Structs


- Basic Concepts
- Methods
- Composition
- Tags and Serialization

3. Module 06: Interfaces


- Interface Basics
- Empty Interface
- Type Assertions
- Common Patterns

---

# Collection Types in Go

## Arrays
Arrays in Go provide fixed-size, ordered collections of elements. Understanding arrays is
fundamental to working with more complex data structures.

### Key Concepts


1. Fixed Size
2. Zero-based Indexing
3. Type Consistency
4. Value Semantics

### Basic Array Operations


```go
// Declaration and initialization
var numbers [5]int // Zero-valued array
cities := [4]string{
"New York",
"London",
"Tokyo",
"Paris",
}
// Accessing elements
firstCity := cities[0] // "New York"
cities[1] = "Berlin" // Modifying an element

// Array length
length := len(cities) // 4
```

## Slices
Slices provide dynamic, flexible views into arrays. They are the most commonly used
collection type in Go.

### Key Features


1. Dynamic Size
2. Reference Type
3. Built-in Append Function
4. Capacity Management

### Working with Slices


```go
// Creating slices
numbers := []int{1, 2, 3, 4, 5}
subset := numbers[1:4] // [2, 3, 4]

// Using make
dynamicSlice := make([]int, 3, 5) // Length 3, Capacity 5

// Appending elements
numbers = append(numbers, 6, 7)
```

## Maps
Maps implement key-value pair storage, providing fast lookups and flexible data
organization.

### Essential Operations


```go
// Map creation
ages := map[string]int{
"Alice": 30,
"Bob": 25,
}

// Adding and accessing


ages["Charlie"] = 35
aliceAge := ages["Alice"]

// Checking existence
value, exists := ages["David"]
if !exists {
fmt.Println("David not found")
}
```

---

# Module 05: Structs

## Basic Struct Concepts

### Definition and Creation


Structs group related data into a single unit, forming the basis for custom types in Go.

```go
type Person struct {
Name string
Age int
Address Address
}

type Address struct {


Street string
City string
Country string
}

// Creating instances
person := Person{
Name: "Alice Johnson",
Age: 30,
Address: Address{
Street: "123 Go Lane",
City: "Techville",
Country: "Gopher Land",
},
}
```

### Methods and Receivers


```go
// Value receiver
func (p Person) GetFullName() string {
return p.Name
}

// Pointer receiver
func (p *Person) Birthday() {
p.Age++
}
```

## Struct Composition
Go uses composition over inheritance, allowing for flexible type creation.

```go
type Employee struct {
Person // Embedded struct
Position string
Salary float64
}

func (e Employee) GetSalaryDetails() string {


return fmt.Sprintf("%s earns %.2f", e.Name, e.Salary)
}
```

---

# Module 06: Interfaces

## Interface Basics
Interfaces define behavior through method signatures, enabling polymorphic code design.

### Definition and Implementation


```go
type Writer interface {
Write([]byte) (int, error)
}

type FileWriter struct {


filename string
}

func (fw FileWriter) Write(data []byte) (int, error) {


return len(data), nil
}
```

## Empty Interface and Type Assertions


The empty interface (`interface{}`) can hold values of any type, requiring type assertions for
specific operations.

```go
func processValue(v interface{}) {
switch val := v.(type) {
case int:
fmt.Printf("Integer: %d\n", val)
case string:
fmt.Printf("String: %s\n", val)
default:
fmt.Printf("Unknown type\n")
}
}
```

## Best Practices

### Struct Best Practices


1. Keep structs focused and cohesive
2. Use pointer receivers for methods that modify state
3. Leverage composition for code reuse
4. Document exported fields and methods

### Interface Best Practices


1. Keep interfaces small and focused
2. Design interfaces for behavior, not data
3. Use composition to build larger interfaces
4. Implement interfaces implicitly

## Practice Exercises

### Struct Exercises


1. Create a Library Management System
- Design book and member structs
- Implement checkout system
- Handle due dates and fines

2. Build a Shape Calculator


- Define different shapes using structs
- Implement area and perimeter methods
- Use composition for complex shapes

### Interface Exercises


1. Implement a Logging System
- Define logger interface
- Create multiple logger implementations
- Support different output formats

2. Design a Payment System


- Create payment processor interface
- Implement different payment methods
- Handle transaction validation
## Additional Resources
1. Go Documentation: https://golang.org/doc/
2. Go by Example: https://gobyexample.com/
3. Effective Go: https://golang.org/doc/effective_go
4. Go Playground: https://play.golang.org/

---

© 2025 Go Programming Course. All rights reserved.

You might also like