• Golang Setup
• net/http with Go
• encoding/json
• dependency management
• build tooling

• Things You Should Know About Golang as a Node.js Developer
• Before We Start this Tutorial: Tour of Go
• Getting Started With Golang
• Taking net/http for a Spin with Go
• Standard Go Libraries: Print and friends
• Variables and Constants in Golang
• The Handler
• Config and env vars in Go
• Config in Node.js vs Go
• Using Envconfig to Manage Configuration Data from env vars
  • Struct tags
  • Rewriting the config file with envconfig
• Making it RESTful with Queries
• Encoding JSON in Golang
• Tidying it Up
• Dependency Management with go.mod
• Sneak Peek to our next Golang Tutorial

Things You Should Know About Golang as a Node.js Developer The latter will be mended in the coming v2.0, but until then we have to use what we have, which is more than enough.
Before We Start this Tutorial: Tour of Go
Getting Started With Golang

export GOROOT=$HOME/go
export PATH=$PATH:$GOROOT/bin

$ go get golang.org/dl/go1.10.7
$ go1.10.7 download

$GOROOT/
├── api
├── bin
│   ├── go
│   ├── godoc
│   └── gofmt
├── doc
│   ├── articles
│   ⋮
│  
├── lib
│   └── time
├── misc
│   ├── android
│   ⋮
│  
├── pkg
│   ├── include
│   ⋮
│  
├── src
│   ├── bufio
│   ├── bytes
│   ├── compress
│   ├── container
│   ├── context
│   ├── crypto
│   ├── database
│   ├── debug
│   ├── encoding
│   ├── errors
│   ├── expvar
│   ├── flag
│   ├── fmt
│   ⋮
│  
└── test
    ├── 235.go
    ⋮

$ mkdir -p $HOME/projects/go/bin $HOME/projects/go/src

export GOROOT=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Taking net/http for a Spin with Go

// main.go
package main

import (
  "fmt"
  "log"
  "net/http"
)

func main() {
  const port = 8000
  listenAt := fmt.Sprintf(":%d", port)
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, World!")
  })

  log.Printf("Open the following URL in the browser: http://localhost:%d\n", port)
  log.Fatal(http.ListenAndServe(listenAt, nil))
}

Go does not support template strings, so we need to use the Sptrintf function of the fmt package.
Standard Go Libraries: Print and friends

• If there is no "suffix", the function will print strings and stringified values that it receives, separated by spaces.

• The suffix ln means that an ending \n will be added to the string that will be printed.

• Lastly, the suffix f means we can use formatting verbs in our strings.

it is useful to befriend them as early as possible.
Variables and Constants in Golang

// main.go
package main

import (
  "fmt"
  "log"
  "net/http"
)

const port = 8000

func main() {
  listenAt := fmt.Sprintf(":%d", port)
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, World!")
  })

  log.Printf("Open the following URL in the browser: http://localhost:%d\n", port)
  log.Fatal(http.ListenAndServe(listenAt, nil))
}

• var <name> <type> = <value>, eg var port int = 8000 or var listenAt string = fmt.Sprintf(":%d", port)
  • Assigns a value to a new variable
  • Assigning to an existing variable is a compilation error
  • Use simple = for assignment
  • Needs type annotation
  • Can assign literal or function return value
  • Can be present outside of a function
• const <name> = <value> eg. const port = 8000
  • Assigns a value to a new constant
  • Assigning to existing constant is a compilation error
  • Use simple = for assignment
  • Does not need type annotation
  • Only literals can be assigned
  • Can be present outside of a function
• <name> := <value> eg. port := 8000 or listenAt := fmt.Sprintf(":%d", port)
  • Assigns a value to a new variable
  • Assigning to an existing variable is a compilation error
  • Use := for assignment
  • Type is inferred
  • Can assign literal or function return value
  • Can only be present inside a function
• <name> = <value> eg. port = 8000 or listenAt := fmt.Sprintf(":%d", port)
  • Reassigns value of an existing variable
  • Assigning to a new variable is a compilation error
  • Use single = for assignment
  • Type is inferred
  • Can assign literal or function return value
  • Can only be present inside a function

// ...
const port = 8000

func main() {
  listenAt := fmt.Sprintf(":%d", port)
  // ...
}

The Handler

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprint(w, "Hello, World!")
})

server.listen(8000, (err) =r {
  if (err) {
    throw err
  }
  console.log('Server is listening at port 8000')
})

log.Printf("Open the following URL in the browser: http://localhost:%d\n", port)
log.Fatal(http.ListenAndServe(listenAt, nil))

let's just accept that passing nil is fine.
Config and env vars in Go

// config.go
package main

import (
  "fmt"
  "os"
  "strconv"
)

type config struct {
  port int
}

func readConfig() config {
  portString := os.Getenv("PORT")

  if portString == "" {
    portString = "8000"
  }

  port, err := strconv.Atoi(portString)

  if err != nil {
    panic(fmt.Sprintf("Could not parse %s to int", portString))
  }

  return config{
    port: port,
  }
}

while reducing the number of necessary imports.
Config in Node.js vs Go

'use strict'

const joi = require('joi')

const portSchema = joi.number().port().default(8000)

const port = joi.attempt(process.env.PORT, portSchema)

module.exports = { port }

type config struct {
  port int
}

func readConfig() config {
  // ...

  if portString == "" {
    portString = "8000"
  }

  // ...
}

func readConfig() config {
  portString := os.Getenv("PORT")

  // ...

  port, err := strconv.Atoi(portString)

  if err != nil {
    panic(fmt.Sprintf("Could not parse %s to int", portString))
  }

  // ...
}

func readConfig() config {
  // ...

  return config{
    port: port,
  }
}

// main.go

// ...
func main() {
  conf := readConfig()

  listenAt := fmt.Sprintf(":%d", conf.port)
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, World!")
  })

  log.Printf("Open the following URL in the browser: http://localhost:%d\n", conf.port)
  log.Fatal(http.ListenAndServe(listenAt, nil))
}

Using Envconfig to Manage Configuration Data from env vars

$ go get github.com/kelseyhightower/envconfig

import (
  "fmt"
  "os"
  "strconv"

  "github.com/kelseyhightower/envconfig"
)

export MYAPP_PORT=8000

type config struct {
  Port int
}

func readConfig() {
  var c config
  err := envconfig.Process("myapp", %c)
}

Another feature is the use of struct tags to specify required env vars or default values for them. But what are struct tags?

Struct tags

type mytype struct {
  Foo int `tag:"mytag",another`
}

So let's get back to our config file!

Rewriting the config file with envconfig

package main

import (
  "github.com/kelseyhightower/envconfig"
)

type config struct {
  Port int `default:"8000"`
}

func readConfig() config {
  var c config

  err := envconfig.Process("", &c)

  if err != nil {
    panic(err)
  }

  return c
}

func main() {
  conf := readConfig()

  listenAt := fmt.Sprintf(":%d", conf.Port)
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, World!")
  })

  log.Printf("Open the following URL in the browser: http://localhost:%d\n", conf.Port)
  log.Fatal(http.ListenAndServe(listenAt, nil))
}

To my mind, this is a drawback of Go, but in the meantime, this practice makes it more visible if a value is exported or not, so it is definitely a matter of opinion.
Making it RESTful with Queries

  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    responseFormat := r.URL.Query().Get("format")
    if responseFormat == "json" {
      w.Header().Set("Content-Type", "application/json;charset=utf-8")
      fmt.Fprintf(w, "{\"foo\": \"Hello, World!\"}")
      return
    }
    fmt.Fprintf(w, "Hello, World!")
  })

send back the response then return.
Encoding JSON in Golang

import (
  "encoding/json"
  "fmt"
  "log"
  "net/http"
)

// ...

  if responseFormat == "json" {
    // ...
    json.NewEncoder(w).Encode(struct {
      Foo string
    }{
      Foo: "Hello, World!",
    })
    return

// ...

struct {
  Foo string
}{
  Foo: "Hello, World!",
})

type Hello struct {
  Foo string
}

func main() {
  hello: := Hello{"Hello, World!"}
  fmt.Println(hello.Foo)
}

import (
  "encoding/json"
  "fmt"
  "log"
  "net/http"
)

// ...

  if responseFormat == "json" {
    // ...
    json.NewEncoder(w).Encode(struct {
      Foo string `json:"foo"`
    }{
      Foo: "Hello, World!",
    })
    return
  
// ...

package main

import (
  "encoding/json"
  "fmt"
  "log"
  "net/http"
)

func main() {
  conf := readConfig()

  listenAt := fmt.Sprintf(":%d", conf.Port)
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    responseFormat := r.URL.Query().Get("format")
    if responseFormat == "json" {
      w.Header().Set("Content-Type", "application/json;charset=utf-8")
      json.NewEncoder(w).Encode(struct {
        Foo string `json:"foo"`
      }{
        Foo: "Hello, World!",
      })
      return
    }
    fmt.Fprintf(w, "Hello, World!")
  })

  log.Printf("Open the following URL in the browser: http://localhost:%d\n", conf.Port)
  log.Fatal(http.ListenAndServe(listenAt, nil))
}

Tidying it Up

call plug#begin('~/.vim/bundle')

Plug 'fatih/vim-go', { 'do': ':GoUpdateBinaries' }
Plug 'vim-scripts/vim-auto-save'

call plug#end()

" vim-go
" ======

let g:go_fmt_command = "goimports"

" Autosave
" ========

let g:auto_save = 1
let g:auto_save_in_insert_mode = 0

Dependency Management with go.mod

$ GO111MODULE=on

$ go mod init
go: creating new go.mod: module github.com/RisingStack/go-gorilla-example

$ GO111MODULE=auto

Otherwise, you might see go get and the overall build behaves strangely when you're inside your GOPATH.
Sneak Peek to our next Golang Tutorial

We've been working on this longform tutorial (almost 5K words!) for quite a while, and now we're happy to share it with you! 😋

If you're a #nodejs or #javascript dev who's interested in learning @golang , we got you covered 👇https://t.co/lztvbT6t3j

— RisingStack 👉 Node.js, K8S & Microservices (@RisingStack) June 26, 2019

Learning Go as a Node developer from node