Início / coding / 问题

Perguntas[go](coding)

Martin Hope
Kendall Chenoweth
Asked: 2025-03-08 14:33:32 +0800 CST
  • 5

Eu tenho o seguinte código. É um exercício de aprendizado, então ele não faz nada obviamente útil. Se o valor wg.Add for 1, ele funciona. Se o valor wg.Add for 2, ele falha. Se eu remover a lógica do canal, ele funciona com um valor wg.Add de 2.

Alguma ideia do que estou fazendo errado?

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)
    }
}
go
Martin Hope
c0sx86
Asked: 2025-03-08 03:29:38 +0800 CST
  • 5

Tenho trabalhado em um pequeno aplicativo web e queria testar o nginx e o Golang para meu backend. Sou bem novo no Golang, pois este é meu primeiro projeto web Golang. De qualquer forma, estou tendo um problema com proxy reverso para minha página de login 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>

O arquivo nginx.conf é o seguinte:

   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;
   }
   }

e o arquivo Go é o seguinte:

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)
}

Ao enviar uma solicitação POST, o backend do Golang nunca a recebe, a menos que você especifique a porta 8080. (por exemplo, "http://IP/login" não funciona) ("http://IP:8080/login" funciona) Eu tentei ambos na máquina local e em outra máquina na rede. TLDR: o nginx não está enviando corretamente a solicitação POST do servidor web nginx (porta 80) para a porta onde o backend do Golang está escutando (porta 8080). Qualquer ajuda é muito apreciada, TYIA!

Editar: Provavelmente não é um problema de firewall, pois desabilitei o ufw no ambiente de teste.

go
Martin Hope
Taoist
Asked: 2025-03-05 23:43:33 +0800 CST
  • 9

Tenho uma função personalizada usando modelos Go da seguinte forma:

"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
},

Tenho outra função que opera em uma string:

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

Como posso chamar a primeira função, usando a segunda como parâmetro?

O copiloto me dá o seguinte

{{ listOperate . toCamel}}

o que faz sentido, mas não consegue analisar o erro

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

o que sugere que ele está tentando executar a função em vez de passá-la. O Google me dá muitas informações sobre funções personalizadas, mas nada responde a esse problema.

go
Martin Hope
ginad
Asked: 2025-02-19 01:51:36 +0800 CST
  • 6

Estou iniciando um novo projeto e vi uma biblioteca muito interessante para GO que é um pouco parecida com o fasthtml, chamada go-app.

Estou com dificuldades para executar comandos JS simples como console.log ou alert. Ou estou esquecendo de algo?

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)
}
go
Martin Hope
Runxi Yu
Asked: 2025-02-18 20:17:06 +0800 CST
  • 5

Ao escrever um serviço web acessado por navegadores web, um co-mantenedor sugeriu que permitíssemos que os usuários escolhessem fazer login em uma sessão sem usar cookies. (Usar formulários HTML ocultos é outra coisa que consideramos, mas não estou muito interessado na ideia. JavaScript não é aceitável.)

Usando o servidor HTTP da biblioteca padrão Go ou talvez outros mecanismos, ao definir Connection: keep-alive, é possível identificar de qual conexão de rede uma solicitação de entrada se originou?

  • Armazenar um ponteiro para http.Request.TLS(a tls.ConnectionState) não funcionará porque sua memória pode ser liberada e o endereço pode ser reutilizado, possibilitando o sequestro de sessões.
  • Não vejo valores úteis em http.Request.

É definitivamente possível implementar isso aceitando solicitações como uma conexão TCP/TLS/etc simples, armazenar algumas informações e construir o http.Requests eu mesmo; mas isso parece bem trabalhoso.

go
Martin Hope
user10089194
Asked: 2025-02-13 15:56:36 +0800 CST
  • 3

Entendo o seguinte ponto em relação ao recover()comportamento em Go. recover()Segue avaliação imediata, mas execução atrasada .

Então, se ele não for chamado dentro de uma função adiada (trecho de código 1), ele recover()será avaliado naquele momento e, nesse ponto, ele ainda estará lá nile, portanto, nosso código entra em pânico.

Se for chamado dentro de uma função adiada, a chamada da função será registrada, mas recover() será chamada depois que ocorrer panice será recuperada com sucesso.

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")

}

Agora, tendo isso em mente, escrevi o código abaixo.

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)
    }
}

Pesquisei online o raciocínio e obtive a mesma resposta que

O valor de retorno de recover é nulo se qualquer uma das seguintes condições for atendida:

  • o argumento do pânico era nulo;
  • a goroutine não está em pânico;
  • recover não foi chamado diretamente por uma função adiada.

Mas não consigo entender por que o segundo snippet não está funcionando?!?

Ela satisfaz todas as 3 condições estritamente falando. Há alguma ressalva que eu esteja esquecendo? Acho que a 3ª condição não é satisfeita porque ela não é chamada diretamente, mas por meio de uma chamada de função aninhada. Mas por que ela precisa estar dentro de deferred somente?

Perguntas semelhantes: aqui , aqui , aqui e aqui .

go
Martin Hope
user10089194
Asked: 2025-02-07 00:03:37 +0800 CST
  • 5

Lendo simultaneidade em Go .

Tentando entender o padrão do canal or-done .

Estou com dificuldade para entender o fluxo de execução.

Mencionei o número na linha de onde vem minha dúvida.

  1. Por que nenhuma returndeclaração em inner <-donecomo temos em outer select? Por causa de nenhuma returndeclaração, a próxima iteração será executada e se nessa iteração tivermos ambos <- donee <-cdisponíveis. Sabemos select-caseque escolheremos qualquer um dos casos arbitrariamente se vários casos estiverem disponíveis. Isso significa que há uma possibilidade de que <-cserá executado mesmo se <-doneestiver disponível?

  2. Já que select-casearbitrariamente escolhe um caso quando vários casos estão disponíveis, é correto assumir que o <- doneserá escolhido eventualmente , mas não é necessário que seja escolhido imediatamente assim que for fechado. Claro, essa dúvida é quando ambos os casos, ie <-donee <-cestavam disponíveis.

  3. Existe uma possibilidade que <- vnão está escrita valStreamquando doneé fechada e é perdida para sempre, correto?

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
}

insira a descrição da imagem aqui

Basicamente, corrija-me se eu estiver errado ou confirme que meu entendimento da execução está correto. De fato, há "brechas" no código e isso é apenas comportamento do canal aqui.

Pergunta semelhante aqui

go
Martin Hope
the_endian
Asked: 2025-01-22 15:51:24 +0800 CST
  • 8

Eu escrevi o seguinte programa golang para main.goaprender dbus em Go:

package main

import (
    "fmt"
    "github.com/godbus/dbus/v5"
    "time"
)

// Listener function to listen for D-Bus signals
func runListener() {
    // Create a new D-Bus connection for the listener
    conn, err := dbus.SessionBus()
    if err != nil {
        fmt.Println("Listener: Failed to connect to session bus:", err)
        return
    }
    defer conn.Close()

    // Request a unique name for the listener
    busName := "org.example.Listener"
    if _, reqErr := conn.RequestName(busName, dbus.NameFlagDoNotQueue); reqErr != nil {
        fmt.Println("Listener: Failed to request name:", reqErr)
        return
    }
    fmt.Println("Listener: Listening for messages on", busName)

    // Add a match rule for the specific signal
    err = conn.AddMatchSignal(
        dbus.WithMatchInterface("org.example.ListenerInterface"), // Match interface
        dbus.WithMatchMember("Message"),                          // Match signal member
    )
    if err != nil {
        fmt.Println("Listener: Failed to add match rule:", err)
        return
    }

    // Create a channel to receive signals
    c := make(chan *dbus.Signal, 10)
    conn.Signal(c)

    // Listen for messages
    fmt.Println("Listener: Waiting for D-Bus messages...")
    for signal := range c {
        fmt.Printf("Listener: Received message: %v\n", signal.Body)
    }
}

// Sender function to send a D-Bus signal
func runSender() {
    // Wait briefly to ensure the listener is ready
    time.Sleep(2 * time.Second)

    // Create a new D-Bus connection for the sender
    conn, err := dbus.SessionBus()
    if err != nil {
        fmt.Println("Sender: Failed to connect to session bus:", err)
        return
    }
    defer conn.Close()

    // Define the signal details
    objectPath := dbus.ObjectPath("/org/example/Listener") // Convert string to ObjectPath
    interfaceName := "org.example.ListenerInterface"
    signalName := interfaceName + ".Message"

    // Emit the signal
    fmt.Println("Sender: Sending message to listener...")
    err = conn.Emit(objectPath, signalName, "Hello from the sender!")
    if err != nil {
        fmt.Println("Sender: Failed to send message:", err)
        return
    }

    fmt.Println("Sender: Message sent successfully!")
}

func main() {
    // Run the listener and sender as separate goroutines
    go runListener()
    go runSender()

    // Prevent the program from exiting immediately
    select {}
}

O problema que estou tendo é que o programa gera com sucesso:

Listener: Listening for messages on org.example.Listener Listener:
Waiting for D-Bus messages... Sender: Sending message to listener...
Sender: Message sent successfully!

Mas observe que não há saída "Listener: Received message"...

Também tentei fazer isso usando dois main.goarquivos separados em dois diretórios de projeto separados (Listener, Sender), mas não consegui configurar corretamente o GoLand para executar os dois main.goarquivos ao mesmo tempo, pois recebi um erro do GoLand: package dbus_messenger is not in std (/usr/lib/golang/src/dbus_messenger) .

go
Martin Hope
nagylzs
Asked: 2025-01-18 21:12:51 +0800 CST
  • 5

Aqui está um exemplo mínimo de funcionamento:

package main

import (
    "fyne.io/fyne/v2/app"
    "fyne.io/fyne/v2/container"
    "fyne.io/fyne/v2/layout"
    "github.com/fyne-io/terminal"
    "log/slog"
    "os"
    "os/exec"
    "sync"
)

func main() {
    err := runMain()
    if err != nil {
        slog.Error(err.Error())
        os.Exit(1)
    }
}

func runMain() error {
    wg := sync.WaitGroup{}
    wg.Add(1)

    term := terminal.New()
    go func() {
        var err error

        // This works
        // err = term.RunLocalShell()

        // This does not work, blank screen...
        cmd := exec.Command("/usr/bin/bash")
        si, err := cmd.StdinPipe()
        if err != nil {
            slog.Error(err.Error())
            os.Exit(1)
        }
        so, err := cmd.StdoutPipe()
        if err != nil {
            slog.Error(err.Error())
            os.Exit(1)
        }
        err = cmd.Start()
        if err != nil {
            slog.Error(err.Error())
            os.Exit(1)
        }
        slog.Info("started", "pid", cmd.Process.Pid)
        err = term.RunWithConnection(si, so)

        if err != nil {
            slog.Error(err.Error())
        }

        wg.Done()
    }()

    a := app.New()
    go func() {
        wg.Wait()
        a.Quit()
    }()
    w := a.NewWindow("Test")
    w.SetContent(container.New(layout.NewStackLayout(), term))
    w.ShowAndRun()
    return nil
}

Então term.RunLocalShell()funciona, mas a conexão manual stdout e stdin de uma chamada os.Exec para term.RunWithConnection(in, out)não funciona. Ele exibe uma tela em branco, e não há nenhuma mensagem de erro.

O que há de errado aqui?

Posso ver que terminal.RunLocalShell chama terminal.open() e que usa github.com/creack/pty para criar um pty. No entanto, terminal.pty não é um campo público, ele não pode ser acessado de fora. Meu objetivo é executar um comando shell remotamente e exibi-lo em um emulador de terminal local. Por exemplo, o exemplo dado é realmente mínimo, na realidade stdin e stdout são pipes conectados com TCP a um processo remoto.

go
Martin Hope
SYKO
Asked: 2025-01-09 12:35:52 +0800 CST
  • 8

Sobre o programa: Estou tentando implementar o padrão pipeline por meio do meu próprio tipo de primeira classe intJob. A função main, que agrega os pipelines, é ExecutePipeline2e, como posso dizer, exatamente ela está causando problemas.

Por que continuo tendo deadlocks? Para mim, parece que fecho todos os canais que são usados ​​pelos leitores após cada goroutine. Além disso, criar canais com buffer não ajuda, então fiquei completamente sem ideias e ficarei muito grato pela sua ajuda.

IMPORTANTE : Não posso alterar a mainfunção e implementar essa ideia somente a partir de outras funções, quando a base (função mencionada) permanece constante e inalterada.

type intJob func(a, b chan int)

func ExecutePipeline2(jobs ...intJob) {
    outs := make([]chan int, len(jobs)+1)
    wg := sync.WaitGroup{}

    for i := 0; i < len(outs); i++ {
        outs[i] = make(chan int)
    }

    for i, job := range jobs {
        job := job
        in, out := outs[i], outs[i+1]
        i := i
        wg.Add(1)
        go func() {
            job(in, out)
            fmt.Printf("job %d closed\n", i)
            close(out)
            wg.Done()
        }()
    }

    wg.Wait()
}

func pipe(_, b chan int) {
    for i := 0; i < 5; i++ {
        b <- i
    }
}

func main() {
    inputData := []int{0, 1, 1, 2, 3, 5, 8}

    hashSignJobs := []intJob{
        intJob(func(in, out chan int) {
            for _, fibNum := range inputData {
                out <- fibNum
            }
        }),
        intJob(pipe),
        intJob(func(in, out chan int) {
            for val := range in {
                fmt.Println(val)
            }
        }),
    }

    ExecutePipeline2(hashSignJobs...)
}
go