标签 golang 下的文章

2024-08-14




package main
 
import (
    "fmt"
)
 
// 定义一个表示分数的结构体
type Fraction struct {
    Numerator   int // 分子
    Denominator int // 分母
}
 
// 创建一个新的分数
func NewFraction(numerator, denominator int) Fraction {
    return Fraction{
        Numerator:   numerator,
        Denominator: denominator,
    }
}
 
// 打印分数
func (f Fraction) String() string {
    return fmt.Sprintf("%d/%d", f.Numerator, f.Denominator)
}
 
func main() {
    // 创建并打印一个分数
    f := NewFraction(2, 4)
    fmt.Println(f.String()) // 输出: 2/4
}

这段代码定义了一个Fraction结构体来表示分数，并提供了创建新分数和将分数转换为字符串的函数。然后在main函数中创建了一个分数实例并打印出来。这个例子简单但完整，展示了Go语言中的基本语法和结构。

- 阅读更多 -

基于Go语言实现简易Web应用

System

2024-08-14

所有,golang

以下是一个使用Go语言和net/http标准库创建简易Web应用的示例代码：




package main
 
import (
    "fmt"
    "log"
    "net/http"
)
 
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}
 
func main() {
    http.HandleFunc("/hello", helloHandler)
 
    fmt.Println("Starting server on port :8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal(err)
    }
}

这段代码定义了一个简单的Web服务器，它监听本地的8080端口，并对于访问路径/hello的请求，使用helloHandler函数进行处理，返回字符串"Hello, World!"。如果你运行这个应用并访问http://localhost:8080/hello，你将看到相应的输出。

System

2024-08-14

所有,golang




package main
 
import (
    "github.com/therecipe/qt/widgets"
)
 
func main() {
    widgets.NewQApplication(len(os.Args), os.Args)
 
    tree := widgets.NewQTreeWidget()
    tree.SetColumnCount(2)
    tree.SetHeaderLabels([]string{"Key", "Value"})
 
    // 添加顶级项
    topLevelItem := tree.InvisibleRootItem().AddChild([]string{"Top Level", "Data"})
    
    // 添加子项
    childItem := topLevelItem.AddChild([]string{"Child", "ChildData"})
 
    // 设置列宽
    tree.SetColumnWidth(0, 200)
 
    // 展开所有项
    tree.ExpandAll()
 
    // 显示窗口
    tree.Resize(600, 400)
    tree.Show()
 
    widgets.QApplication_Exec()
}

这段代码演示了如何在Qt应用程序中使用QTreeWidget创建和配置一个简单的树形控件。首先，创建了一个QTreeWidget实例，并设置了列数和头标签。然后，添加了一个顶级项和一个子项，并设置了列宽。最后，使用ExpandAll方法展开了所有树节点，并且通过调用Show方法显示了窗口。

- 阅读更多 -

Golang-Map有序输出——使用orderedmap库实现

System

2024-08-14

所有,golang




package main
 
import (
    "fmt"
    "github.com/kr/pretty"
    "github.com/xiaostudy/go-ordered-map"
)
 
func main() {
    // 创建一个有序的map
    orderedMap := orderedmap.NewOrderedMap()
 
    // 往有序map中插入键值对
    orderedMap.Set("z", 100)
    orderedMap.Set("a", 1)
    orderedMap.Set("b", 2)
 
    // 遍历有序map并打印键值对
    for _, key := range orderedMap.Keys() {
        value, _ := orderedMap.Get(key)
        fmt.Println(key, value)
    }
 
    // 使用pretty库打印有序map的内容
    fmt.Println("Pretty Print:")
    pretty.Println(orderedMap)
}

这段代码首先导入了必要的库，然后创建了一个有序map，向其中添加了几个键值对，并遍历打印了键值对。最后，使用了pretty.Println来格式化并打印整个有序map的内容，以便更清晰地查看键值对的顺序。

- 阅读更多 -

vscode 搭建 golang 开发环境

System

2024-08-14

所有,golang

在VSCode中搭建Go语言开发环境，你需要安装Go语言的编译器和VSCode的Go插件。以下是简要步骤：

安装Go编译器：
- 访问Go官网下载页面：https://golang.org/dl/
- 根据你的操作系统下载并安装相应的安装包。
设置Go环境变量：
- 安装完成后，设置GOROOT和GOPATH环境变量。GOROOT通常是Go编译器的安装目录，GOPATH是你的工作目录，用于存放Go代码和第三方库。
安装VSCode：
- 访问VSCode官网下载并安装VSCode。
安装Go插件：
- 打开VSCode，按Ctrl+Shift+X打开扩展市场。
- 搜索并安装Go扩展。
配置VSCode：
- 打开VSCode设置(Ctrl+,)，搜索go.gopath，确保它设置为你的GOPATH。
- 搜索go.goroot，确保它设置为你的GOROOT。
测试安装：
- 创建一个Go文件，例如hello.go，写入以下代码：
```
package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, VSCode!")
}
```
- 在VSCode中打开终端(Ctrl+``)，运行go run hello.go\`，看是否输出了正确的结果。

以上步骤完成后，你就可以在VSCode中愉快地编写Go代码了。

- 阅读更多 -

Rust Vs Go:从头构建一个web服务

System

2024-08-14

所有,golang

在这个比较中，我们将使用Rust和Go来创建一个简单的web服务，并展示两种语言的基本语法和结构。

Rust:




extern crate hyper;
 
use hyper::{Body, Response, Server};
use hyper::service::{service_fn, service_fn_ok};
 
async fn hello_world(_req: hyper::Request<Body>) -> Result<Response<Body>, hyper::Error> {
    Ok(Response::new(Body::from("Hello World from Rust!")))
}
 
#[tokio::main]
async fn main() {
    let addr = ([127, 0, 0, 1], 3000).into();
 
    let make_svc = service_fn_ok(hello_world);
 
    let server = Server::bind(&addr).serve(make_svc);
 
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
}

Go:




package main
 
import (
    "fmt"
    "log"
    "net/http"
)
 
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World from Go!")
}
 
func main() {
    http.HandleFunc("/", helloHandler)
 
    log.Fatal(http.ListenAndServe(":3000", nil))
}

在这两个例子中，我们都创建了一个简单的web服务，监听本地的3000端口，并对所有的HTTP请求返回"Hello World"消息。虽然语言和语法细节不同，但是核心的web服务创建过程是相似的。在Rust中，我们使用了hyper库来创建服务，并通过异步的方式处理请求。在Go中，我们直接使用了标准库中的net/http包来处理HTTP请求。两种语言都展示了如何启动一个简单的web服务器，并响应HTTP请求。

System

2024-08-14

所有,golang




package main
 
import (
    "fmt"
    "github.com/didi/gendry/builder"
    "github.com/morgine/godi"
)
 
// 定义一个简单的结构体作为BEAN
type MyBean struct {
    Value string
}
 
// 实现BEAN的初始化方法
func (b *MyBean) AfterPropertiesSet() error {
    b.Value = "Initialized"
    return nil
}
 
func main() {
    // 创建BEAN容器
    container := godi.NewBeanContainer()
 
    // 注册BEAN
    err := container.RegisterBean(&MyBean{}).ExportAs("myBean")
    if err != nil {
        panic(err)
    }
 
    // 启动容器
    err = container.Start()
    if err != nil {
        panic(err)
    }
 
    // 获取并使用BEAN
    myBean, err := container.GetBean("myBean")
    if err != nil {
        panic(err)
    }
 
    myBeanInstance, ok := myBean.(*MyBean)
    if !ok {
        panic("Bean is not of type MyBean")
    }
 
    fmt.Println(myBeanInstance.Value) // 输出: Initialized
}

这段代码展示了如何使用godi库创建一个简单的依赖注入容器，注册一个BEAN，并在BEAN上执行初始化方法。然后启动容器并获取该BEAN，最后使用它。这个过程是工业级应用中依赖注入的基本使用方式。

- 阅读更多 -

Golang并发编程-Goroutine

System

2024-08-14

所有,golang




package main
 
import (
    "fmt"
    "sync"
    "time"
)
 
func worker(id int, wg *sync.WaitGroup) {
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(2 * time.Second)
    fmt.Printf("Worker %d done\n", id)
    wg.Done()
}
 
func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg) // 启动goroutine
    }
    wg.Wait() // 等待所有goroutine完成
}

这段代码使用了sync.WaitGroup来同步主goroutine和工作goroutine。主goroutine启动了5个工作goroutine，并使用wg.Add(1)来跟踪goroutine的数量。每个工作goroutine完成后通过调用wg.Done()来通知wg.Wait()它已经完成。这确保了主goroutine会等待所有工作goroutine完成后再继续执行。

- 阅读更多 -

client-go实战之五：DiscoveryClient

System

2024-08-14

所有,golang




package main
 
import (
    "context"
    "fmt"
    "log"
 
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/discovery"
    "k8s.io/client-go/rest"
    "k8s.io/client-go/tools/clientcmd"
)
 
func main() {
    // 使用kubeconfig配置文件创建一个配置对象
    config, err := clientcmd.BuildConfigFromFlags("", "/path/to/kubeconfig")
    if err != nil {
        log.Fatalf("Error building kubeconfig: %s", err.Error())
    }
 
    // 创建一个DiscoveryClient实例
    discoveryClient, err := discovery.NewDiscoveryClientForConfig(config)
    if err != nil {
        log.Fatalf("Error building DiscoveryClient: %s", err.Error())
    }
 
    // 使用DiscoveryClient获取集群的GroupVersion列表
    groupList, err := discoveryClient.ServerGroups()
    if err != nil {
        log.Fatalf("Error discovering server groups: %s", err.Error())
    }
 
    // 打印获取到的GroupVersion列表
    for _, group := range groupList.Groups {
        fmt.Printf("Group: %s, Versions: %v\n", group.Name, group.Versions)
    }
}

这段代码展示了如何使用client-go库中的DiscoveryClient来获取Kubernetes集群支持的GroupVersion列表。首先，它通过kubeconfig文件配置了一个*rest.Config对象，然后使用这个配置对象创建了一个DiscoveryClient实例。接下来，它调用ServerGroups方法获取集群的GroupVersion信息，并打印出来。这个过程对于理解Kubernetes集群的API组件是非常有用的。

- 阅读更多 -

Golang gin Context 详解

System

2024-08-14

所有,golang

Gin是一个用Go语言编写的HTTP web框架，它提供了一种简单的方式来创建WEB应用。Gin框架的核心对象是Context，它提供了一种方式来访问http请求和响应以及其他数据。

以下是Gin框架中Context的一些常用方法：

JSON：用于将数据以JSON格式返回给客户端。




func JSON(ctx *Context, code int, obj interface{}) {
    ctx.Render(-1, render.Data{
        "ContentType": "application/json",
        "Data":        obj,
    })
    ctx.AbortWithStatus(code)
}

IndentedJSON：用于以缩进格式将数据以JSON格式返回给客户端。




func IndentedJSON(ctx *Context, code int, obj interface{}) {
    ctx.Render(-1, render.Data{
        "ContentType": "application/json",
        "Data":        obj,
        "Indent":      "    ",
    })
    ctx.AbortWithStatus(code)
}

XML：用于将数据以XML格式返回给客户端。




func XML(ctx *Context, code int, obj interface{}) {
    ctx.Render(-1, render.Data{
        "ContentType": "application/xml",
        "Data":        obj,
    })
    ctx.AbortWithStatus(code)
}

YAML：用于将数据以YAML格式返回给客户端。




func YAML(ctx *Context, code int, obj interface{}) {
    ctx.Render(-1, render.Data{
        "ContentType": "application/x-yaml; charset=utf-8",
        "Data":        obj,
    })
    ctx.AbortWithStatus(code)
}

ProtoBuf：用于将数据以ProtoBuf格式返回给客户端。




func ProtoBuf(ctx *Context, code int, obj interface{}) {
    ctx.Render(-1, render.Data{
        "ContentType": "application/x-protobuf",
        "Data":        obj,
    })
    ctx.AbortWithStatus(code)
}

String：用于将字符串返回给客户端。




func String(ctx *Context, code int, format string, values ...interface{}) {
    str := fmt.Sprintf(format, values...)
    ctx.Render(-1, render.Data{
        "ContentType": "text/plain",
        "Data":        []byte(str),
    })
    ctx.AbortWithStatus(code)
}

HTML：用于将HTML模板返回给客户端。




func HTML(ctx *Context, code int, name string, obj interface{}) {
    if code != -1 {
        ctx.Writer.WriteHeader(code)
    }
    ctx.Render(code, render.Data{
        "ContentType": "text/html",
        "Data":        obj,
        "Name":        name,
    })
}

Data：用于将二进制数据返回给客户端。




func Data(ctx *Context, code int, contentType string, data []byte) {
    ctx.Render(-1, render.Data{
        "ContentType": contentType,
        "Data":        data,
    })
    ctx.AbortWithStatus(code)
}

Redirect：用于重定向URL。




func Redirect(ctx *Context, status int, location string) {
    ctx.Render(-1, render.Data{
        "ContentType": "text/ht

- 阅读更多 -