Switching from JavaScript to Golang

Image Source

Coming from a JavaScript background, I have always wanted to learn a static-typed programming language, earlier this year I picked up Golang after reading the reviews about the language, Golang is backed by Google. Oh, and of course popular DevOps tools such as Docker, Kubernetes, Terraform, are built with Golang, in this article I will be taking you through basic programming in Golang and Javascript.

Variables

Javascript

In Javascript variables can be declared using the let, const(ES6), and var(ES5) keyword.

  // using the const keyword
  const a = 10
  // using the let keyword
  let b = 10
  // using the var keyword
  var c = 10
  console.log(a, b, c) // returns 10, 10, 10

Javascript Variable Playground

Golang

In Go variables can be declared using the var, const keyword and also using the short variable declaration syntax.

  // using the var keyword
  var a = 10 // go detects the type here even though we don't specify
  fmt.Println(a) // returns 10
  fmt.Printf("variable a is of type: %T\n", a) // returns int

  // using the const keyword
  const b = 20  // It is important to note that the value of b must be known at compile-time
  fmt.Println(b) // returns 20

  // variable decalred but not assgined a value returns the zero value of the type
  var c bool
  fmt.Println(c) // returns the zero value(zero value of a boolean is false)

  // using the short variable declaration syntax
  d := "this is a variable" // go detects the type of this variable
  fmt.Println(d) // returns this is a variable
  fmt.Printf("d is of type: %T\n", d) // returns the type(string)

Go Variable Playground

Arrays

An array is a collection of items.

Javascript

In Javascript arrays are dynamic, items can be added and removed from the array, also Javascript being a loosely-typed language, it can hold values of different type in the array.

  let myArray = [1, "this is array", true, 100.30]
  console.log(myArray) // returns [1, "this is array", true, 100.30]

// we can remove the last item in an array using the pop method
  myArray.pop()
  console.log(myArray) // returns [1, "this is array", true]

// we can add to the end of the array using the push method
  myArray.push(20)
  console.log(myArray) // returns [1, "this is array", true, 20]

// we can remove the first item of the array using the shift method
  myArray.shift()
  console.log(myArray) // returns ["this is array", true, 20]

// we can add to the start of the array using the unshift method
  myArray.unshift(210)
  console.log(myArray) // returns [210, "this is array", true, 20]

Javascript Array Playground

Golang

Arrays are of fixed length in Go, you can't add nor remove from an array, also an array can only contain the specified type.

    a := [5]string{"a", "b", "c", "d", "e"} // length is 5
    fmt.Println(a) // returns [a b c d e]
    // But what happens if we don't specify exactly 5 items
    b := [5]string{"a", "b", "c"}
    fmt.Printf("%#v", b) // returns [5]string{"a", "b", "c", "", ""}
    // "" represents the zero value(zero value of a string is "")

Go Array Playground
In Golang we also have slices, they are dynamic and we don't need to specify the length, values can be added and removed from a slice.

    a := []string{"a", "b", "c"}
    fmt.Printf("%#v", a) //  returns []string{"a", "b", "c"}

    // adding to a slice, we can use the append method to add an item to a slice
    a = append(a, "d")   // append takes in the the array and the value we are adding
    fmt.Printf("%#v", a) // returns []string{"a", "b", "c", "d"}

    // removing from a slice by slicing
    a = append(a[0:3])   // 0 represents the index, while 3 represents the position
    fmt.Printf("%#v", a) // returns []string{"a", "b", "c"}

    // slices can also be created using the make method(in-built)
    // the first value is the type, the second and the third value is the length and maximum capacity of the slice
    b := make([]string, 3, 5)
    fmt.Printf("length of b is:%#v, and cap of b is:%#v\n", len(b), cap(b)) // returns length of b is:3, and cap of b is:5

Slice Playground

Function

Javascript

In Javascript a function expression can be written using the function keyword, arrow function(ES6) can also be used.

// using the function keyword
   function a(value) {
       return value
   }
   const val = a("this is the value")
   console.log(val)
// using arrow function
   const b = ((value) => value) 
   const val2 = b("this is another value")
   console.log(val2)

Javascript Function Playground

Golang

Using the func keyword, a function expression can be written in go.

  func a() {
   fmt.Println("this is a function")
}
  a() // returns "this is a function"
// parameters and return type can also be specified
  func b(a,b int) int { // takes in value of type int and returns an int
     result := a * b
   return result
}
  val := b(5,6)
  fmt.Println(val) // returns 30

Go Function Playground

Objects

Javascript

In JavaScript we can write Objects by specifying the key and the value in curly braces separated by a comma.

  const music = {
   genre: "fuji",
   title: "consolidation",
   artist: "kwam 1",
   release: 2010,
   hit: true
}
console.log(music) // returns {genre: "fuji", title: "consolidation", artist: "kwam 1", release: 2010, hit: true}

Javascript Object Playground

Golang

In Golang there is Structs which holds a field and the field type

  type Music struct {
    genre   string
    title   string
    artist  string
    release int
    hit     bool
}
ms := Music{
    genre:   "hiphop",
    title:   "soapy",
    artist:  "naira marley",
    release: 2019,
    hit:     true,
}
fmt.Printf("%#v\n", ms) // returns main.Music{genre:"hiphop", title:"soapy", artist:"naira marley", release:2019, hit:true}

Go Struct Playground

Helpful Golang resources

Tour of go
Complete go bootcamp
RunGo
gobyexample

Comments

[José Muñoz]

I am not sure Google backing is a plus

[Charles Clinton Pustejovsky III]

From a realistic standpoint, having a behemoth like Google backing it helps with longevity and adoption. See C# and Java as examples of this.

[José Muñoz]

don't fall for the big company illusion, Google has a track record of killing good projects: killedbygoogle.com/

[josh-sea]

Not planning to learn go currently but love how you laid out how they overlap. Would love to see more tutorials like this, essentially basic components of a language in comparison to a language one currently knows, i.e. here is an array in ruby and this is what arrays are like in javascript... etc. Would help facilitate learning!

[Noorain Panjwani]

The main reason to adopt go is its concurrency model. Go uses a concept of Green Threads which it calls goroutines. These goroutines lets you perform blocking calls (like network operations) without having to block the underlying OS thread! Greatly simplifies concurrency in a multi-threaded environment.

It would be really nice if you could mention that as well.

[Ricardo N Feliciano]

Don't fall for hype.

Google can't "kill" Go because Go is an open source language entrenched in a world-wide community.

[Carlos Merchán]

Where all decisions are taken by them without listening the community

[Freedom]

Had that impact your decision before you even tried to use Go for your research purpose? If you have probably not even touch Go, perhaps, try it without the noise or negative opinions you heard in the community. Does it make your learning process or projects a lot challenging? Once I tried and found it's exactly what Go can do for my backends... and the next release 1.14 onwards will get more performant in certain areas that we thought it was already fast, there more to optimize.

Because some community said so should not impact the curious minds, you are a different individual, live in different countries and it's what you can do for your community with your creative inspirations and ideas just like your avatar.

There is no hype in Go language and it's a time saver with cross-compile binaries.

Remember, products can get obsolete, programming language does not, or C/C++/Ruby/etc would have been obsolete. It's not, because the Go's performance and productivity makes it worthwhile to invest that can replace many small different tasks and CI/CD.

Now "Defer" in v1.14 costs an extra 1 nanosecond compare to normal method calls without defer keyword, that's crazy fast.

[Carlos Merchán]

I'm working moving some nodejs code to go because of performance and ease of code reading. What I'm missing are generic and I'm sure many people like me want this feature implemented in go. I know that they have their reasons to not implement generics, but it was a reason that the community is angry with google.

It's a Google language and they do whatever they consider better.

[Ulf Byskov]

IMO the only good thing about Go is go routines.
The simplicity of the language causes you to write too much boiler plate.
For example the need to have if err != nil { simply because there are no exceptions.

[jsrios]

Great tutorial. I found quii.gitbook.io/learn-go-with-tests/ to be a great resource for picking up Go if you want to check it out.

[/[Abejide Femi Jr]\s/]

yeah, it is nice, added it to the helpful resources.

[codelitically_incorrect]

This ain't ever gonna happen. Google indoctrination to the fullest it's for the left.

[Jackyeoh]

Great article! I wish I’d found this article earlier as it could save me so much time poking around golang!

I’ve recently been trying to transfer some work done in js into golang and I’ve found that the major obstacle when it comes to switching between js and golang is on how you model your data.

For example, one of the very common use case is if I wanted to store different data in an array. You can do this very easily in js and even in some other static type language like java thru class inheritance. However, golang doesn’t fully support inheritance, which could drastically impact how we design our data model. Though you might want to add this in as personally felt that this is quite important.

[Lluís Josep Martínez]

I suspect it's the only language for you :-)