promises

Node.js

  1. function asyncMethod(value) {
  2.   return new Promise((resolve, reject) => {
  3.     setTimeout(() => {
  4.       resolve('resolved: ' + value)
  5.     }, 1e3)
  6.   })
  7. }
  9. function main() {
  10.   asyncMethod('foo')
  11.     .then(result => console.log(result))
  12.     .catch(err => console.error(err))
  14.   Promise.all([
  15.     asyncMethod('A'),
  16.     asyncMethod('B'),
  17.     asyncMethod('C')
  18.   ])
  19.   .then(result => console.log(result))
  20.   .catch(err => console.error(err))
  21. }
  23. main()

Output

  1. resolved: foo
  2. [ 'resolved: A', 'resolved: B', 'resolved: C' ]

Go

(closest thing is to use channels)

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6.     "time"
  8.     "github.com/prometheus/common/log"
  9. )
  11. func asyncMethod(value string) chan interface{} {
  12.     ch := make(chan interface{}, 1)
  13.     go func() {
  14.         time.Sleep(1 * time.Second)
  15.         ch <- "resolved: " + value
  16.         close(ch)
  17.     }()
  19.     return ch
  20. }
  22. func resolveAll(ch ...chan interface{}) chan interface{} {
  23.     var wg sync.WaitGroup
  24.     res := make([]string, len(ch))
  25.     resCh := make(chan interface{}, 1)
  27.     go func() {
  28.         for i, c := range ch {
  29.             wg.Add(1)
  30.             go func(j int, ifcCh chan interface{}) {
  31.                 ifc := <-ifcCh
  32.                 switch v := ifc.(type) {
  33.                 case error:
  34.                     resCh <- v
  35.                 case string:
  36.                     res[j] = v
  37.                 }
  38.                 wg.Done()
  39.             }(i, c)
  40.         }
  42.         wg.Wait()
  43.         resCh <- res
  44.         close(resCh)
  45.     }()
  47.     return resCh
  48. }
  50. func main() {
  51.     var wg sync.WaitGroup
  52.     wg.Add(2)
  54.     go func() {
  55.         result := <-asyncMethod("foo")
  56.         switch v := result.(type) {
  57.         case string:
  58.             fmt.Println(v)
  59.         case error:
  60.             log.Errorln(v)
  61.         }
  63.         wg.Done()
  64.     }()
  66.     go func() {
  67.         result := <-resolveAll(
  68.             asyncMethod("A"),
  69.             asyncMethod("B"),
  70.             asyncMethod("C"),
  71.         )
  73.         switch v := result.(type) {
  74.         case []string:
  75.             fmt.Println(v)
  76.         case error:
  77.             log.Errorln(v)
  78.         }
  80.         wg.Done()
  81.     }()
  83.     wg.Wait()
  84. }

Output

  1. resolved: foo
  2. [resolved: A resolved: B resolved: C]