问题[go](coding)

我正在使用 Swaggo 来记录我的 Go API 端点。我有一个处理程序函数，其中我在 JSON 结构字段中定义了一个带有示例标签的结构，但这些示例并未出现在生成的 Swagger UI 中。

// @Summary Register a new user
// @Description Creates a new user account. In development environment, the user is activated immediately. Otherwise, an activation email is sent.
// @Tags users
// @Accept json
// @Produce json
// @Param request body main.application.registerUserHandler.input true "User registration details"
// @Success 202 {object} object{user=data.User}
// @Router /users [post]
func (app *application) registerUserHandler(w http.ResponseWriter, r *http.Request) {
    var input struct {
        Name     string `json:"name" example:"John Doe"`
        Email    string `json:"email" example:"[email protected]"`
        Password string `json:"password" example:"SecurePass123!"`
    }
    // ... rest of the handler ...
}

Swagger 文档生成正确，但结构中示例标签的示例值未显示在请求主体模式中。

有没有办法让 Swaggo 识别嵌套/内联结构中的示例标签？

我正在学习Go Channel。我在Go

package main
import "fmt"
func sample(mychan chan string) {
    fmt.Println("Go Go Go Go")
    fmt.Println("message received from channel is ", <-mychan)
}
func main() {
    messageChan := make(chan string)
    go sample(messageChan)
    messageChan <- "hello"
}

发生的情况是，有时它会显示“消息已收到...”语句。有时它不显示。它总是显示“Go Go Go ..”语句。那么为什么它会跳过“消息已收到”语句。这是怎么回事呢？我很困惑。

我有一个简单的条形图，上面叠加了一条线。条形和线是由不同的数据生成的，因此图表会歪曲条形的大小，因为线数据明显大于条形数据。我想在图表右侧为线条设置单独的 y 轴以防止这种情况发生，但我找不到有关如何执行此操作的 go-echarts 文档。

这是图表当前的图像。如您所见，条形几乎看不出来。

下面是我的代码。该行添加到代码底部。有人知道如何在该行的右侧添加 y 轴吗？

// Sort the dates so that the x-axis is ordered.
    var dates []string
    for date := range data {
        dates = append(dates, date)
    }
    sort.Strings(dates)

    // Build series data for the bars (profit) and line (transaction count).
    var barData []opts.BarData
    for _, date := range dates {
        stat := data[date]
        barData = append(barData, opts.BarData{Value: stat.Profit})
    }

    // Create the bar chart for profit.
    bar := charts.NewBar()
    bar.SetGlobalOptions(
        charts.WithTitleOpts(opts.Title{
            Title:    "Daily Profit",
            Subtitle: "Profit in USDT",
        }),
        charts.WithLegendOpts(opts.Legend{
            Show: opts.Bool(false),
        }),
        charts.WithDataZoomOpts(opts.DataZoom{
            Type:  "slider",
            Start: 50,
            End:   100,
        }),
        // First y-axis (index 0) for Profit USDT; no explicit index needed.
        charts.WithYAxisOpts(
            opts.YAxis{
                Type: "value",
            },
        ),
    )
    bar.SetXAxis(dates).AddSeries("Profit USDT", barData)

    // Build series data for the bars (profit) and line (transaction count).
    var lineData []opts.LineData
    for _, date := range dates {
        stat := data[date]
        lineData = append(lineData, opts.LineData{Value: stat.Count, YAxisIndex: 1})
    }

    // Create the bar chart for profit.
    line := charts.NewLine()
    line.SetXAxis(dates).
        AddSeries("Transaction Count", lineData)
    line.SetGlobalOptions(
        // First y-axis (index 0) for Profit USDT; no explicit index needed.
        charts.WithYAxisOpts(
            opts.YAxis{
                Type: "value",
                Position: "right",
            },
        ),
    )
    line.ExtendYAxis(opts.YAxis{Type: "value", Position: "right", Show: opts.Bool(true)})
    
    bar.Overlap(line)

    return bar

我有以下代码。这是一个学习练习，因此它没有做任何明显有用的事情。如果 wg.Add 值为 1，它就会起作用。如果 wg.Add 值为 2，它就会失败。如果我删除通道逻辑，它就会在 wg.Add 值为 2 的情况下起作用。

对我做错的事情有什么想法吗？

package main

import (
    "fmt"
    "sync"
)

func popMessage(wg *sync.WaitGroup, m *sync.Mutex, i *int, c chan<- int) {
    m.Lock()
    *i++
    c <- *i
    m.Unlock()
    fmt.Printf("pop %d\n", *i)
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    var m sync.Mutex
    var intPtr *int

    c := make(chan int, 1)
    wg.Add(2)

    intPtr = new(int)
    *intPtr = 1
    go popMessage(&wg, &m, intPtr, c)
    go popMessage(&wg, &m, intPtr, c)
    go popMessage(&wg, &m, intPtr, c)
    wg.Wait()
    fmt.Printf("final %d\n", *intPtr)
    for x := range c {
        fmt.Printf("channel %d\n", x)
    }
}

一直在开发一个小型 Web 应用程序，想尝试使用 nginx 和 Golang 作为后端。这是我的第一个 Golang Web 项目，因此对 Golang 还很陌生。无论如何，我的 HTML 登录页面的反向代理存在问题：

<!DOCTYPE html>
<html>

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link rel="stylesheet" href="loginStyle.css">
  <title>Cosmic Cloud Login</title>
</head>

<body>

  <div class="loginContainer">
    <h1 class="headerText">Login</h1>
    <p>Please enter your login information</p>
    <form action="/login" method="POST">
      <div class="inputGroup">
        <label for="Username">Username</label>
        <input type="Username" id="Username" name="Username" placeholder="Enter your username" required>
      </div>

      <div class="inputGroup">
        <label for="Password">Password</label>
        <input type="Password" id="Password" name="Password" placeholder="Enter your password" required>
      </div>
      <button type="submit" class="loginButton">Login</button>
    </form>


  </div>

</body>

</html>

nginx.conf文件如下：

   server {
          listen 80;
   location / {
          root /var/www/html;
          index index.html;
   }

   location /login {
          proxy_pass http://0.0.0.0:8080;
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
   }
   }

Go文件如下：

package main 


import (
    "fmt"
    "net/http"
)



var validUsername = "test"
var validPassword = "test1234"

func loginHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Invalid Request method", http.StatusMethodNotAllowed)
        return 
    }

    username := r.FormValue("Username")
    password := r.FormValue("Password")

    if username == validUsername && password == validPassword {
        fmt.Fprint(w, "Login Successfull!")
    } else {
        http.Error(w, "Invalid Username or Password", http.StatusUnauthorized)

    }
}

func main() {
    http.HandleFunc("/login", loginHandler)
    fmt.Println("Server is running on :8080")
    http.ListenAndServe(":8080", nil)
} 

发送 post 请求时，除非您指定端口 8080，否则 golang 后端永远不会收到它。（例如“http://IP/login”不起作用）（“http://IP:8080/login”起作用）我在本地计算机和网络上的另一台计算机上都尝试过。TLDR：nginx 无法正确将 POST 请求从 nginx Web 服务器（端口 80）发送到 Golang 后端正在监听的端口（端口 8080）。非常感谢您的帮助，谢谢！

编辑：此外，这可能不是防火墙问题，因为我在测试环境中禁用了 ufw。

我有一个使用 Go 模板的自定义函数，如下所示：

"listOperate": func(lst []string, fn func(string) string) (result []string) {
    result = make([]string, len(lst))
    for i, item := range lst {
        result[i] = fn(item)
    }
    return result
},

我有另一个对字符串进行操作的函数：

"toCamel": func(str string) (result string) {
        return strcase.ToCamel(str)
    }

如何使用第二个函数作为参数来调用第一个函数？

副驾驶给了我以下

{{ listOperate . toCamel}}

这是有道理的，但解析失败，出现错误

at <toCamel>: wrong number of args for toCamel: want 1 got 0" (template.ExecError)

这表明它正在尝试执行该函数而不是传递它。Google 为我提供了大量有关自定义函数的信息，但没有一个能解决这个问题。

我正在启动一个新项目，并且看到了一个非常有趣的 GO 库，它有点类似于 fasthtml，名为 go-app。

我无法执行简单的 JS 命令，例如 console.log 或 alert。还是我遗漏了什么？

type Button struct {
    app.Compo
}

func (b *Button) OnClick(ctx app.Context, e app.Event) {
    // NONE of these codes works when clicking the button.

    //e.JSValue().Call("alert", "e jsvalue call Button clicked!")
    //ctx.JSSrc().Call("alert", "ctx jssrc call Button clicked!")

    //app.Window().Get("alert").Call("window get call Hello world")
    //app.Window().Call("alert", "window call Button clicked!")
    app.Window().Get("console").Call("log", "window get call log")
}

func (b *Button) Render() app.UI {
    return app.Button().
        ID("button").
        Text("Click me!").
        OnClick(b.OnClick)
}

在编写通过 Web 浏览器访问的 Web 服务时，一位共同维护者建议我们允许用户选择不使用 Cookie 登录到一个会话。（使用隐藏的 HTML 表单也是我们考虑过的事情，但我不太喜欢这个想法。JavaScript 是不可接受的。）

使用 Go 标准库的 HTTP 服务器或者其他机制，在设置时Connection: keep-alive，是否可以识别传入的请求来自哪个网络连接？

• 存储指向http.Request.TLS（a tls.ConnectionState）的指针是行不通的，因为它的内存可能会被释放，而且地址可能会被重用，从而可能劫持会话。
• 我没有看到有用的价值http.Request。

通过以普通的 TCP/TLS/etc 连接接受请求、存储一些信息并http.Request自己构建 s 来实现这一点绝对是可能的；但这似乎相当痛苦。

recover()我理解关于Go 中的行为 的以下观点。recover()遵循立即评估 但 延迟执行。

因此，如果它没有在延迟函数（代码片段 1）中调用，那么recover()就会在当时对其进行评估，此时它仍然处于静止状态nil，因此我们的代码会出现混乱。

如果它在延迟函数内部被调用，那么该函数调用会被注册，但 在发生之后recover()才会被调用，并且我们会成功恢复。panic

package main

import "fmt"

func main() {
    defer recover() // since not called inside a deferred func, it will not recover successfully

    panic("This is a panic")

}

考虑到这一点，我编写了下面的代码。

import (
    "fmt"
)

func main() {

    defer func(){
        customRecover()
    }()

    panic("This is a panic")

}

func customRecover(){
    if r:= recover(); r!= nil{
        fmt.Println("Custom Recovery for: ",r)
    }
}

我在网上搜索了原因，得到了同样的答案

如果满足以下任一条件，则 recovery 的返回值为 nil：

• panic 的参数为 nil；
• goroutine 没有发生恐慌；
• 延迟函数没有直接调用恢复。

但我不明白为什么第二个片段不起作用？！？

严格来说，它满足所有 3 个条件。我是否遗漏了什么注意事项？我猜想第 3 个条件不满足，因为它不是直接调用的，而是通过嵌套函数调用调用的。但为什么它只需要在 deferred 内部呢？

类似问题： 这里、这里、这里和这里。

阅读Go 中的并发。

尝试理解或完成通道模式。

我无法理解执行流程。

我已经提到了我产生疑问的那条线上的数字。

1. 为什么returninner 中没有<-done像 outer 中那样的语句select？因为没有return语句，所以下一次迭代将运行，如果在该迭代中我们同时拥有<- done和<-c可用，会怎么样？我们知道select-case如果有多个可用案例，我们将任意选择其中任何一种案例。这是否意味着<-c即使<-done可用，也有可能运行？

2. 由于select-case在有多个案件可用时任意选择一个案件，因此是否可以假设最终<- done会选择，但不一定在结案后立即选择。当然，这种疑问是在两个案件即和都可用的情况下。<-done<-c

3. 有可能关闭时<- v不会写入并且会永远丢失，对吗？valStreamdone

orDone := func(done, c <-chan interface{}) <-chan interface{} {
    valStream := make(chan interface{})
    go func() {
        defer close(valStream)
        for {
            select {                   //2
            case <-done:
                return
            case v, ok := <-c:
                if ok == false {
                    return
                }
                select {
                case valStream <- v:   //3
                case <-done:           //1
                }
            }
        }
    }()
    return valStream
}

基本上，如果我错了，请纠正我，或者确认我对执行的理解是正确的。代码确实存在“漏洞”，这只是这里的渠道行为。

类似问题在这里