Go application, 云原生开发

yesplease

Go 云原生开发实践指南

在当今的云计算时代，云原生技术栈已成为构建现代分布式应用的核心。Go语言凭借其出色的并发性能、简洁的语法和强大的标准库，成为云原生开发的首选语言。本文将深入探讨如何使用Go语言进行云原生应用开发，重点关注Kubernetes Operator开发、服务网格集成以及可观测性实现。

Read more

Go application, 分布式系统设计

yesplease

Go应用与分布式系统设计实战

在现代分布式系统架构中，Go语言凭借其出色的并发性能和简洁的语法设计，成为了构建高可用、高性能分布式系统的首选语言之一。本文将深入探讨如何使用Go语言实现分布式系统中的核心组件，包括一致性协议、高并发架构设计和分布式锁机制。

Read more

Go fundamentals, how to play?

yesplease

Go Fundamentals 是更多的Go基础知识，涵盖了数据结构（基础数据结构、数组、slice、map）、语言基础（函数、接口、反射）、关键字和并发等方面。掌握这些概念和技术将帮助您编写高效、可靠和复杂的Go程序。

Read more

Go Proverbs, how to play?

yesplease

需要牢记这些谚语，在使用过程中感受谚语带来的变化

  • Don’t communicate by sharing memory, share memory by communicating.
package main

import "fmt"

func main() {
    channel := make(chan int) // 创建一个通道

    go func() {
        value := 42
        channel <- value // 将值发送到通道
    }()

    receivedValue := <-channel // 从通道接收值
    fmt.Println(receivedValue) // 输出：42
}
  • Concurrency is not parallelism
package main

import (
    "fmt"
    "sync"
    "time"
)

func printNumbers(wg *sync.WaitGroup) {
    defer wg.Done()

    for i := 0; i < 5; i++ {
        fmt.Println(i)
        time.Sleep(100 * time.Millisecond)
    }
}

func printLetters(wg *sync.WaitGroup) {
    defer wg.Done()

    for i := 'a'; i < 'e'; i++ {
        fmt.Printf("%c\n", i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    var wg sync.WaitGroup

    wg.Add(2)
    go printNumbers(&wg)
    go printLetters(&wg)

    wg.Wait()
}
  • Channels orchestrate; mutexes serialize
package main

import (
    "fmt"
    "sync"
)

func increment(counter *int, wg *sync.WaitGroup) {
    defer wg.Done()

    for i := 0; i < 1000; i++ {
        *counter++
    }
}

func main() {
    var wg sync.WaitGroup
    counter := 0

    wg.Add(2)
    go increment(&counter, &wg)
    go increment(&counter, &wg)

    wg.Wait()

    fmt.Println(counter) // 输出：2000
}
  • The bigger the interface, the weaker the abstraction
package main

import "fmt"

type Animal interface {
    Eat()
    Sleep()
}

type Dog struct{}

func (d Dog) Eat() {
    fmt.Println("Dog is eating")
}

func (d Dog) Sleep() {
    fmt.Println("Dog is sleeping")
}

type Cat struct{}

func (c Cat) Eat() {
    fmt.Println("Cat is eating")
}

func (c Cat) Sleep() {
    fmt.Println("Cat is sleeping")
}

func main() {
    animals := []Animal{Dog{}, Cat{}}

    for _, animal := range animals {
        animal.Eat()
        animal.Sleep()
    }
}
  • Make the zero value useful
package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    var person Person
    fmt.Println(person.Name) // 输出空字符串
    fmt.Println(person.Age)  // 输出0

    person.Name = "Alice"
    person.Age = 30
    fmt.Println(person.Name) // 输出：Alice
    fmt.Println(person.Age)  // 输出：30
}
  • Don’t just check errors, handle them gracefully
package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    // 在这里进行文件操作
    fmt.Println("File opened successfully")
}
  • Don’t panic
package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()

    panic("Something went wrong") // 引发恐慌
}
Read more

docker, net?

yesplease
Read more