Comparing Node.js to Go

Introduction

The approach of this article is this:

You are a seasoned Node.js developer and are looking to learn a new language, but you don’t want to go deep, just see how things compare with your current expertise, and then make a final decision.

Chances are, you were initially a PHP or Python developer, then you found your way into Node.js and now you feel like you want to expand your expertise. Of course, I might be wrong, but in this article, we are going to look at some common patterns when working with Node.js and how they compare in Go.

Why Go

The most common reasons to learn Go include the following:

• Go has only 25 keywords, and this can give you a clue on how simple it is to learn the language. We’ll be looking at the common language patterns, and we’ll see how cleaner and easier it is to do some common tasks as compared to other languages.
• The Go standard library has a lot of built-in functionality, that you will find yourself rarely relying on other external libraries.
• Go code will not compile if you have unused variables or syntax errors.
• Go has great support for concurrency. Other languages support concurrency too, but the approach Go takes is more intuitive, and as easier.
• Go is written in a self-documenting way, and so the documentation is quite clear to read and follow along

Here’s an example with the net/http package in the go documentation. Examples are provided, and there are even tabs for the source code files. Sweet!

Hello World

Here’s a “hello world” program in Node.js

console.log('Hello World');

Running this will produce Hello World in the terminal.

node app.js

Here’s an equivalent hello world program in Go

package main

import "fmt"

func main() {
    fmt.Println("Hello World")
}

Go follows a certain structure which involves:

• package name - this usually describes the general idea of what the code will be about (e.g., if we were using this to connect to Postgres, we may call the package postgres package postgres)
• **import statements - **this is where we add in external packages, either from the standard library, or the ones downloaded from the web
• code - this is the rest of the code, and includes functions, variables, constants, and all other language constructs that follow the syntax.

This code can be run by typing in the following or view it in GoPlay Space.

go run main.go

where main.go is the name of the file.

Data Types, Variables, and Constants

JavaScript is dynamically typed, which means you do not have to specify types when defining variables, and the variables can change their types as you program along.

That being said, JavaScript has the following types:

To define variables in JavaScript (Node.js) we’d write this:

const num = 3; // declaring a constant number
let flt = 2.34; // declaring a number (float)
let a = true; // declaring a boolean
let b = false;
var name = 'Scotch'; // declaring a string

Go, however, is statically typed, which means we have to define the types beforehand, or assign them and let them be inferred. Here’s a comprehensive list of Go Types.

An equivalent of the above JavaScript definitions in Go is

package main

const num = 3 // declaring a constant

func main() {
    var flt float64 = 2.34 // declaring a float
    var name string = "Scotch" // declaring a string
    a, b := true, false,  // shorthand declaration syntax
}

Assigning initial values in Go is done with the var keyword, a variable name, and a type. Additionally and more commonly the := shorthand syntax can be used. When declaring variables with :=, they are automatically assigned the correct type. Additionally, you can assign multiple values in one line as we have done in a, b := true, false. This will assign both a and b to the right-hand values respectively.

Here is an array of strings in JavaScript

const names = ['Scotch', 'IO'];

While Go has arrays, what we typically refer to as arrays in JavaScript are referred to as slices in Go. Here’s an example of a slice in Go:

package main

func main() {
    names := []string{"Scotch", "IO"}
}

As an example, we’ll write a small program that returns the substring of a string at index 10.

So a sentence like Luke, I'm not your father will end up being Luke, I'm

JavaScript

const sentence = '`Luke, I\'m not your Father';`
console.log(sentence.substr(0,10));

Go

package main

import "fmt"

func main() {
    sentence := "Luke, I'm not your Father"
    fmt.Println(sentence[:10])
}

You can run the app in Goplay Space

Conditional Statements

Conditional statements include if else and switch statements. Here’s an example in Node.js.

const cats = 10;

if (cats > 10) {
    console.log('you have many cats');
} else {
    console.log('you have few cats');
}

const cat_fur = "calico";

switch (cat_fur) {
    case 'tabby':
        console.log('tabby cat');
        break;
    case 'calico':
        console.log('calico cat');
        break;;
    default:
        ///
}

Here’s an equivalent in Go

package main

import "fmt"

func main() {
    cats := 10
    if cats > 10 {
        fmt.Println("you have many cats")
    } else {
        fmt.Println("you have few cats")
    }

    cat_fur := "calico"
    switch cat_fur {
    case "tabby":
        fmt.Println("tabby cat")
    case "calico":
        fmt.Println("calico cat")
    default:
        ///
    }
}

You can run the app in GoPlay Space.

You’ll notice the conditionals are a bit cleaner in Golang, with fewer brackets.

Loops

JavaScript has 3 loops: for loop, while loop, and a do while loop. Here’s a for loop example.

// normal for loop
for (i = 0; i < 10; i++) {
    console.log(i);
}

// key, value loop
for (var key in p) {
    if (p.hasOwnProperty(key)) {
        console.log(key + ' -> ' + p[key]);
    }
}

// another key value loop
Object.keys(obj).forEach(function(key) {
    console.log(key, obj[key]);
})

// there's also a `for...of`

Go has only one type of loop, and it’s the for loop. Don’t let that deceive you though as the for loop in Go is very versatile and can emulate almost any type of loop. Let’s look at a simple example:

package main

import (
    "fmt"
)

func main() {
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }

    // key value pairs
    kvs := map[string]string{
        "name":    "Scotch",
        "website": "https://scotch.io",
    }

    for key, value := range kvs {
        fmt.Println(key, value)
    }
}

You can run the app in GoPlay Space.

Objects

Objects are a big part of JavaScript and exist in almost every program. Here’s an Object in JavaScript.

// an object
const Post = {
    ID: 300
    Title: "Moving from Node.js to Go",
    Author: "Christopher Ganga",
    Difficulty: "Beginner",
}

console.log(Post)

// access values
console.log(Post.ID)
console.log(Post.Title)
console.log(Post.Author)
// ....

// we can also define classes in javascript.

Since Go is statically typed, we need to do a little extra to define objects. There are two ways to do this, and it involves using map. A map is a key-value data structure, where the keys are a set (does not contain duplicates).

package main

import (
    "fmt"
)

func main() {
    Post := map[string]interface{}{
        "ID":         300,
        "Title":      "Moving from Node.js to Go",
        "Author":     "Christopher Ganga",
        "Difficulty": "Beginner",
    }

    fmt.Println(Post)

    // to access values
    fmt.Println(Post["ID"])
    fmt.Println(Post["Title"])
    fmt.Println(Post["Author"])
    // ....
}

You can run this example in Goplay Space

The other way to write objects in Go is by using Structs. A struct is an abstract data structure, with properties and methods. It’s a close equivalent to a Class in Javascript.

package main

import (
    "fmt"
)

type Post struct {
    ID         int
    Title      string
    Author     string
    Difficulty string
}

func main() {
    // create an instance of the Post
    p := Post{
        ID:         300,
        Title:      "Moving from Node.js to Go",
        Author:     "Christopher Ganga",
        Difficulty: "Beginner",
    }

    fmt.Println(p)

    // to access values
    fmt.Println(p.ID)
    fmt.Println(p.Title)
    fmt.Println(p.Author)
    // ....
}

Struct defines the name of the type and its properties together with the types. We can then create an instance of the type (Post).

HTTP Server

Now that we know a little about the similarities and differences in language constructs, we can have a look at servers. Since we are coming from Node.js it’s likely that we’re building a server, that returns JSON for instance.

In Node.js, chances are while writing a server, you are using Express as the base library for your server. It’s the most common, comes with a router, and is the most battle-tested. Here’s a Node.js server.

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello from Express!');
})

app.listen(3000, err => {
  if (err) {
    return console.log('something bad happened', err);
  }

  console.log('`server is listening on 3000'`);
})

The Go standard library provides everything we need to get a server up and running without any external dependencies. The net/http package provides most of this functionality.

When building larger applications, however, expanding on the base net/http package with third-party packages is common, and one popular package that provides greatly a lot of functionality is the Gorilla Web Toolkit.

Here’s an equivalent Server in Go.

package main

import (
    "net/http"
)

func Hello(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
}

func main() {
    http.HandleFunc("/", Hello)
    if err := http.ListenAndServe(":8080", nil); err != nil {
        panic(err)
    }
}

We call http.HandleFunc and give it a route and a handler. Almost similar to the callback we give to express routes.

You can test this by running go run main.go, assuming your file was named main.go

Now, let’s introduce a router library, because, if we don’t, we’ll have to test whether a request came as a POST, GET, or the likes, and use if statements to match specific routes. Something like this:

if req.Method == "POST" {
    // do this
}

To get packages with Golang, you usually use a go get <github-link>.

To get Gorilla Mux from the Gorilla Web Toolkit we mentioned earlier, we would write the following in our terminal:

go get -u github.com/gorilla/mux

Then we are able to do this. I pulled this directly from Gorilla mux documentation.

package main

import (
     "fmt"
     "net/http"

     "github.com/gorilla/mux"
)
func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    r.HandleFunc("/products", ProductsHandler)
    r.HandleFunc("/articles", ArticlesHandler)

    // details
    r.HandleFunc("/products/{key}", ProductHandler)
    r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler)
    r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)

    http.Handle("/", r)
}

// example handler
func ArticlesCategoryHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "Category: %v\n", vars["category"])
}

We see that the same way express accepts patterns, Gorilla mux allows us to use the same patterns. It can get a little complicated than what I’ve described, but I hope you get the idea.

Gorilla mux also comes with helper functions that npm’s body-parser helps us achieve. Go purist can however claim that these functions can easily be written.

Middleware

Middleware are a great part of Node.js servers.

They are functions that sit somewhere, and are run before or after the actual request is run. In Node.js, this is a simple snippet for a middleware that retrieves a secret from the env and uses it to authenticate a user. When reading variables from Node.js, dotenv is commonly used.

const express = require('express');
const app = express();

// add server_name middleware
function authenticate((req, res, next) => {
    const secret = process.ENV.SECRET;
    if (secret == "") {
        return res.send("secret not found");
    }

    if (!isAuthenticated(req, secret)) {
        return res.send("invalid authentication");
    }

    return next();
})

// use middleware
app.get('/', authenticate, (req, res) => {
  res.send('Hello from Express!');
})

app.listen(3000, err => {
  if (err) {
    return console.log('something bad happened', err);
  }

  console.log('`server is listening on 3000'`);
})

Go takes a similar approach. Since all a middleware does is take in a request, do something with it, and decide whether the request should proceed.

package main

import (
    "net/http"
    "os"
)

// our sample authenticate middleware
func Authenticate(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r _http.Request) {
        secret := os.Getenv('SECRET')
        if secret == "" {
            w.Write(_[_]byte("secret not found")
            return
        }

        if !isAuthenticated(r, secret) {
            w.Write(_[]byte("invalid authentication"))
            return
        }
        next.ServeHTTP(w, r)
    }
}

func Hello(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
}

func main() {
    http.HandleFunc("/", Authenticate(Hello)) // call the middeware by wrapping
    if err := http.ListenAndServe(":8080", nil); err != nil {
        panic(err)
    }
}

If you are a seasoned JavaScript developer, you’ve probably noticed functions are first-class citizens in Go, too.

We’ve just written a function that takes in a http.HandlerFunc which is a function type, and the function structure is type HandlerFunc func(ResponseWriter, *Request), just like the Handler we wrote.

The advantage is that the http.HandlerFunc type has a function ServeHTTP which takes in the response and the request pointer we passed, and executes the handle call.

Some people call this approach wrapping functions, but this is the general idea. Again, you can easily write your own middlewares, but there are a couple of libraries out there to help you like

• http://www.gorillatoolkit.org/pkg/handlers
• https://github.com/urfave/negroni.

Consuming APIs

Most of the time, our servers usually depend on an external API to get some data it needs. Let’s say for example we are getting users from Github.

This is the approach you would take in a Node.js app.

You’ll first install a HTTP request module, such as axios.

npm install axios

const axios = require('axios');
const url = 'https://api.github.com/users';

axios.get(url).then(res => {
    // do something with the response
}).catch(err => {
    // do something with the error
})

This piece of code can either be in your service or anywhere you like.

In Go, however, the net/http package can help us with this scenario.

package main

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

func main() {
    URL := "https://api.github.com/users"
    res, err := http.Get(URL)
    if err != nil {
        log.Println(err)
        return
    }
    defer res.Body.Close() // for garbage collection

    responseBodyBytes, err := ioutil.ReadAll(res.Body)
    if err != nil {
        log.Println(err)
        return
    }

    fmt.Println(string(responseBodyBytes))
}

We use http.Get to make requests, and check errors. The response is usually in bytes, and we have to read it first, then convert it to string with string([]bytes).

You can add this to a main.go file and run go run main.go.

This code can also easily be converted to a func, and called repeatedly when needed.

Here’s an example showing various ways to use the http package from the net/http documentation page.

resp, err := http.Get("http://example.com/")
...
resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
...
resp, err := http.PostForm("http://example.com/form",
    url.Values{"key": {"Value"}, "id": {"123"}})

Database Connections

Node.js has various npm modules to help in database connections depending on the databases that you are using.

These libraries most of the time come with their own methods, that try to make it easier for you to work with them, and some even offer ORM-like features.

Go however takes a different approach. The standard library provides an interface for working with databases called database/sql which RDBMS package authors can use to implement drivers for various databases. Authors following the standard interface ensure greater interoperability for their packages.

Common database driver packages include:

• https://github.com/jmoiron/sqlx.
• https://github.com/jinzhu/gorm.
• https://github.com/gobuffalo/pop

Frameworks

We all know how JavaScript has a lot of frameworks and libraries, and we use them occasionally to avoid reinventing the wheel.

The Go community however prefers using libraries instead of frameworks, so you will rarely find a team committing to a particular framework when building their applications.

That being said, there is one Framework I’d recommend since it is built by combining a lot of the commonly used packages and file structures.

• GoBuffalo

Conclusion

Go’s files must be written within packages, and this usually affects your file structure.

In JavaScript, you’ll see a lot of require statements at the beginning of files, while in Golang, the first line is always a package name, which will then be used as an import path in a file where it’s required import package_path/package_name.

I hope you’ve gotten a gist of what it’s like to write Go, and you’d like to get into action. Golang is really praised for its concurrency and performance, and if you are building a large application, this would be a preferred choice.

One language is not better than the other. It’s about choosing the right tool for the job.

I’ve been following this transitional journey for a while now, and would gladly answer any questions you may have. Just leave a comment.

Happy Go-ing!