手写一套Go语言基础实例代码

手写一套Go语言基础实例代码

Go语言，又称Golang，是一种由Google开发并广泛使用的静态类型、编译型编程语言。Go语言具有简洁、高效、并发性好等特点，特别适用于构建高性能、高并发的网络服务。以下是一些高端Go语言基础的实例代码，旨在展示Go语言的特性和能力。

实例一：并发执行HTTP请求

Go语言的并发特性非常出色，可以使用goroutine和channel轻松实现并发执行HTTP请求。

go
package main  
  
import (  
    "fmt"  
    "io/ioutil"  
    "net/http"  
    "sync"  
)  
  
func fetchURL(url string, wg *sync.WaitGroup, ch chan<- string) {  
    defer wg.Done()  
    resp, err := http.Get(url)  
    if err != nil {  
        ch <- fmt.Sprintf("Error fetching %s: %v", url, err)  
        return  
    }  
    defer resp.Body.Close()  
    body, err := ioutil.ReadAll(resp.Body)  
    if err != nil {  
        ch <- fmt.Sprintf("Error reading response from %s: %v", url, err)  
        return  
    }  
    ch <- fmt.Sprintf("%s: %s", url, string(body))  
}  
  
func main() {  
    var wg sync.WaitGroup  
    ch := make(chan string, 2) // Buffered channel to avoid blocking  
  
    urls := []string{  
        "https://golang.org/",  
        "https://example.com/",  
    }  
  
    for _, url := range urls {  
        wg.Add(1)  
        go fetchURL(url, &wg, ch)  
    }  
  
    go func() {  
        wg.Wait()  
        close(ch) // Close the channel once all goroutines are done  
    }()  
  
    for result := range ch {  
        fmt.Println(result)  
    }  
}

在这个例子中，我们定义了一个fetchURL函数来并发地获取网页内容，并使用sync.WaitGroup来等待所有goroutine完成。main函数中创建了一个带缓冲的channel来避免阻塞，然后并发地调用fetchURL函数，并在所有goroutine完成后关闭channel。最后，通过遍历channel来打印每个URL的响应内容。

实例二：使用结构体和接口

Go语言中的结构体和接口是构建复杂应用的重要工具。下面是一个简单的例子，展示了如何定义结构体和接口，并实现多态性。

go
package main  
  
import (  
    "fmt"  
)  
  
// 定义一个接口  
type Shape interface {  
    Area() float64  
    Perimeter() float64  
}  
  
// 定义一个圆形结构体，并实现Shape接口  
type Circle struct {  
    radius float64  
}  
  
func (c Circle) Area() float64 {  
    return 3.14 * c.radius * c.radius  
}  
  
func (c Circle) Perimeter() float64 {  
    return 2 * 3.14 * c.radius  
}  
  
// 定义一个矩形结构体，并实现Shape接口  
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)  
}  
  
// 使用接口的多态性  
func printShapeInfo(s Shape) {  
    fmt.Printf("Area: %f\n", s.Area())  
    fmt.Printf("Perimeter: %f\n", s.Perimeter())  
}  
  
func main() {  
    circle := Circle{radius: 5}  
    rectangle := Rectangle{width: 4, height: 6}  
  
    shapes := []Shape{circle, rectangle}  
  
    for _, shape := range shapes {  
        printShapeInfo(shape)  
        fmt.Println()  
    }  
}

在这个例子中，我们定义了一个Shape接口，它要求实现Area和Perimeter方法。接着，我们定义了两个实现了Shape接口的结构体：Circle和Rectangle。最后，我们创建了一个包含这些形状切片的切片，并遍历它来调用printShapeInfo函数，该函数接收任何实现了Shape接口的类型作为参数。这种多态性允许我们编写通用的代码来处理不同类型的形状。