Switching from JavaScript to Golang
Tags: go, javascript, development, gopher
Published: 2019-09-30 09:07:27

---
title: Switching from JavaScript to Golang
published: true
description: 
tags: #go #js #development #gopher
---
![Image](http://static.velvetcache.org/talks/2018/03/[NEJS]%20Go,%20JavaScript%20and%20You/Go,%20JavaScript%20and%20You_files/gopherjs.png)<figcaption>[Image Source](https://static.velvetcache.org/talks/2018/03/[NEJS]%20Go,%20JavaScript%20and%20You/index.html#1)</figcaption>
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 <b>let, const(ES6)</b>, and <b>var(ES5)</b> keyword.
```javascript
  // 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](https://codepen.io/Bjhaid_93/pen/gOYNLev)
####Golang
In Go variables can be declared using the <b>var</b>, <b>const</b> keyword and also using the <b>short variable declaration syntax</b>.

```go
  // 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](https://play.golang.org/p/dCB9Ojmg9Nn)
###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.
```javascript
  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](https://codepen.io/Bjhaid_93/pen/bGbPBQQ)
####Golang
<b>Arrays</b> are of fixed length in Go, you can't add nor remove from an array, also an array can only contain the specified type.
```go
    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](https://play.golang.org/p/35ZCIiUzFQx)
In Golang we also have <b>slices</b>, they are dynamic and we don't need to specify the length, values can be added and removed from a <b>slice</b>.
```go
    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](https://play.golang.org/p/f4OKfupSXBb)

###Function
####Javascript
In Javascript a function expression can be written using the <b>function</b> keyword, <b>arrow function(ES6)</b> can also be used.
```javascript
// 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](https://codepen.io/Bjhaid_93/pen/QWLXGzP)
####Golang
Using the <b>func</b> keyword, a function expression can be written in go.
```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](https://play.golang.org/p/0Rw0LNOxGoO)
###Objects
####Javascript
In JavaScript we can write Objects by specifying the key and the value in curly braces separated by a comma.
```javascript
  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](https://codepen.io/Bjhaid_93/pen/ExYBNJg)
####Golang
In Golang there is <b>Structs</b> which holds a field and the field type
```go
  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](https://play.golang.org/p/ArfhLFlpO1I)

###Helpful Golang resources
[Tour of go](tour.golang.com)
[Complete go bootcamp](https://www.udemy.com/course/learn-go-the-complete-bootcamp-course-golang)
[RunGo](https://medium.com/rungo)
[gobyexample](https://gobyexample.com/)