Was ist die nodejs setTimeout-Entsprechung in Golang?

Question

Ich lerne gerade, und ich vermisse setTimeout von Nodejs in Golang. Ich habe noch nicht viel gelesen, und ich frage mich, ob ich dasselbe wie ein Intervall oder eine Loopback implementieren könnte.

Gibt es eine Möglichkeit, dass ich dies von Knoten zu Golang schreiben kann? Ich habe gehört, dass Golang sehr gut mit Nebenläufigkeit umgehen kann, und das könnten einige Goroutines sein oder sonst?

//Nodejs 
function main() { 

//Do something 

setTimeout(main, 3000) 
console.log('Server is listening to 1337') 
} 

Vielen Dank im Voraus!

//Go version 

func main() { 
    for t := range time.Tick(3*time.Second) { 
    fmt.Printf("working %s \n", t) 
    } 

    //basically this will not execute.. 
    fmt.Printf("will be called 1st") 
} 

Answer 1

Der nächste Äquivalent ist die time.AfterFunc Funktion:

import "time" 

... 
time.AfterFunc(3*time.Second, somefunction) 

Dies wird eine neue goroutine und führen Sie die gegebene Funktion nach der angegebenen Menge an Zeit laichen. Es gibt noch andere verwandte Funktionen in dem Paket, das von Nutzen sein kann:

• time.After: Diese Version wird einen Kanal zurück, die einen Wert nach der vorgegebenen Zeit sendet. Dies kann in Verbindung mit der Anweisung select nützlich sein, wenn Sie ein Timeout beim Warten auf einen oder mehrere Kanäle haben möchten.

• time.Sleep: diese Version wird einfach blockiert, bis der Timer abläuft. In Go ist es üblicher, synchronen Code zu schreiben und sich auf den Scheduler zu verlassen, um zu anderen goroutines zu wechseln, deshalb ist manchmal einfach Blockieren die beste Lösung.

Es gibt auch die time.Timer und time.Ticker-Typen, die für weniger trivial Fällen verwendet werden können, wo Sie den Timer abzubrechen benötigen.

Answer 2

könnte eine andere Lösung sein, eine

Sofort-Ausgeführt Funktion Ausdruck (IIFE) Funktion wie zu implementieren:

go func() { 
    time.Sleep(time.Second * 3) 
    // your code here 
}() 

Answer 3

Dieses website ist ein interessantes Beispiel und Erklärung von Timeouts Kanäle und die Auswahlfunktion beteiligt sind.

// _Timeouts_ are important for programs that connect to 
// external resources or that otherwise need to bound 
// execution time. Implementing timeouts in Go is easy and 
// elegant thanks to channels and `select`. 

package main 

import "time" 
import "fmt" 

func main() { 

    // For our example, suppose we're executing an external 
    // call that returns its result on a channel `c1` 
    // after 2s. 
    c1 := make(chan string, 1) 
    go func() { 
     time.Sleep(2 * time.Second) 
     c1 <- "result 1" 
    }() 

    // Here's the `select` implementing a timeout. 
    // `res := <-c1` awaits the result and `<-Time.After` 
    // awaits a value to be sent after the timeout of 
    // 1s. Since `select` proceeds with the first 
    // receive that's ready, we'll take the timeout case 
    // if the operation takes more than the allowed 1s. 
    select { 
    case res := <-c1: 
     fmt.Println(res) 
    case <-time.After(1 * time.Second): 
     fmt.Println("timeout 1") 
    } 

    // If we allow a longer timeout of 3s, then the receive 
    // from `c2` will succeed and we'll print the result. 
    c2 := make(chan string, 1) 
    go func() { 
     time.Sleep(2 * time.Second) 
     c2 <- "result 2" 
    }() 
    select { 
    case res := <-c2: 
     fmt.Println(res) 
    case <-time.After(3 * time.Second): 
     fmt.Println("timeout 2") 
    } 
} 

Sie können es auch auf die james Go Playground