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)
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]
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
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
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}
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}
Top comments (15)
I am not sure Google backing is a plus
From a realistic standpoint, having a behemoth like Google backing it helps with longevity and adoption. See C# and Java as examples of this.
don't fall for the big company illusion, Google has a track record of killing good projects: killedbygoogle.com/
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!
The main reason to adopt go is its concurrency model. Go uses a concept of
Green Threads
which it callsgoroutines
. Thesegoroutines
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.
Don't fall for hype.
Google can't "kill" Go because Go is an open source language entrenched in a world-wide community.
Where all decisions are taken by them without listening the community
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.
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.
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.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.
yeah, it is nice, added it to the helpful resources.
This ain't ever gonna happen. Google indoctrination to the fullest it's for the left.
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.
I suspect it's the only language for you :-)