What is the nodejs setTimeout equivalent in Golang?

I am currently studying, and I miss setTimeout from Nodejs in golang. I haven't read much yet, and I'm wondering if I could implement the same in go like an interval or a loopback.

Is there a way that I can write this from node to golang? I heard golang handles concurrency very well, and this might be some goroutines or else?

//Nodejs
function main() {

 //Do something

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

Thank you in advance!

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

The closest equivalent is the time.AfterFunc function:

import "time"

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

This will spawn a new goroutine and run the given function after the specified amount of time. There are other related functions in the package that may be of use:

• time.After: this version will return a channel that will send a value after the given amount of time. This can be useful in combination with the select statement if you want a timeout while waiting on one or more channels.

• time.Sleep: this version will simply block until the timer expires. In Go it is more common to write synchronous code and rely on the scheduler to switch to other goroutines, so sometimes simply blocking is the best solution.

There is also the time.Timer and time.Ticker types that can be used for less trivial cases where you may need to cancel the timer.

This website provides an interesting example and explanation of timeouts involving channels and the select function.

// _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")
    }
}

You can also run it on the Go Playground

another solution could be to implement an

Immediately-Invoked Function Expression (IIFE) function like:

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

you can do this by using sleep function
and give your duration you need

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("First")
	time.Sleep(5 * time.Second)
	fmt.Println("second")
}