Andanhm Golang

GoLang Cheat Sheet
by Andan H M (andanhm) via cheatography.com/69306/cs/17474/
Go Companies Using Golang
Go (also referred to as GoLang) is an open source and lower level Google for “dozens of systems”
programming language designed and created at Google in 2009 by Docker a set of tools for deploying linux containers
Robert Griesemer, Rob Pike and Ken Thompson, to enable users to
Openshift a cloud computing platform as a service by Red Hat
easily write simple, reliable, and highly efficient computer programs
Dropbox migrated few of their critical components from Python to Go
Besides its better-known aspects such as built-in concurrency and
garbage collection Netflix for two portions of their server architecture
Go is a statically typed language, it is anti functional programming and anti Soundcloud for “dozens of systems”
OOP, as far as the designers concerned. ThoughtWorks some tools and applications around continuous delivery
https://golang.org/ and instant messages (CoyIM)
Uber for handling high volumes of geofence-based queries.

Feature BookMyShow for handling high volume of traffic, rapidly growing
Language is very concise, simple and safe. customer, to adapt new business solution and (cloud solution)
distribution tools
Compilation time is very fast.
https://www.qwentic.com/blog/companies-using-golang
Patterns which adapt to the surrounding environment similar to dynamic
languages.
Install
Inbuilt concurrency such as lightweight processes channels and select
statements. OSX brew install go
Supports the interfaces and the embedded types. Run the command below to view your Go version:
go version
https://golang.org/doc/faq
https://golang.org/doc/install
Lack of essential features
No ternary operator ?: Directory layout

No generic types
GOPATH=/home/user/go
No exceptions
/home/user/go/
No assertions
src/
No overloading of methods and operators hello/
main.go (package main)
GOPATH is a mess
bin/
Package dependence manage tool
hello (installed command)
https://github.com/ksimka/go-is-not-good pkg/
linux_amd64/ (installed package object)
github.com/ (3rd party dependencies)
By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

cheatography.com/andanhm/ Last updated 22nd October, 2018. Learn to solve cryptic crosswords!
andanhm.me Page 1 of 8. http://crosswordcheats.com
GoLang Cheat Sheet
Hello Word Built-in Types (cont)
package main float32 float64

import "fmt" complex64 complex128
func main() {
fmt.Println("Hello, World!!") Packages and Modules
}
Packages
Create a file named main.go in the directory src/hello inside your Go packages are folders that contain one more go files.
workspace/go path
Modules
go env Default go system environment
A modules (starting with vgo and go 1.11) is a versioned collection of
https://tour.golang.org packages.
go get github.com/andanhm/go-prettytimee
Running
go mod init github.com/andanhm/go-prettytime
$ cd $HOME/go/src/hello
$ go run main.go Variable & Function Declarations
Hello, World!!
const country = "india"
$ go build
// declaration without initialization
$ ./hello
var age int
Hello, World!!
// declaration with initialization
var age int = 23
Package
// declare and init multiple at once
Package declaration at top of every source file var age, pincode int = 23, 577002
Executables are should be in package main // type omitted, will be inferred
Upper case identifier: public (accessible from other packages) var age = 23
// simple function
Lower case identifier: private (not accessible from other packages)
func person() {
Built-in Types // shorthand, only within func bodies

// type is always implicit
bool
age := 23
string
}
int int8 int16 int32 int64
// Can have function with params
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32 ~= a character (Unicode code
point)

GoLang Cheat Sheet
Variable & Function Declarations (cont) If statement
func person(firstName string, lastName string) {} if age < 18 {

// Can have multiple params of the same type return errors.New("not allowed to enter")
func person(firstName, lastName string) {} }
// Can return type declaration // Conditional statement
func person() int { if err := Request("google.com"); err != nil {
return 23 return err
} }
// Can return multiple values at once // Type assertion inside
func person() (int, string) { var age interface{}
return 23, "vinay" age = 23
} if val, ok := age.(int); ok {
var age, name = person() fmt.Println(val)
// Can return multiple named results }
func person() (age int, name string) {
age = 23 Loop statement
name = "vinay"
for i := 1; i < 3; i++ {
return
}
}
// while loop syntax
var age, name = person()
for i < 3 {
// Can return function
}
func person() func() (string,string) {
// Can omit semicolons if there is only a condition
area:=func() (string,string) {
for i < 10 {
return "street", "city"
}
}
// while (true) like syntax
return area
for {
}
}
Go don't have while until

GoLang Cheat Sheet
Switch statement Arrays, Slices
// switch statement var a [3]int // declare an int array with length 3.

switch runtime.GOOS { var a = [3]int {1, 2, 3} // declare and initialize a
case "darwin": { slice
// cases break automatically a := [...]int{1, 2} // elipsis -> Compiler figures out
} array length
case "linux": { a[0] = 1 // set elements
} i := a[0] // read elements
default: var b = a[lo:hi] // creates a slice (view of the
} array) from index lo to hi-1
// can have an assignment statement before the switch var b = a[1:4] // slice from index 1 to 3
statement var b = a[:3] // missing low index implies 0
switch os := runtime.GOOS; os { var b = a[3:] // missing high index implies len(a)
case "darwin": a = append(a,17,3) // append items to slice a
default: c := append(a,b...) // concatenate slices a and b
}
// comparisons in switch cases // create a slice with make
os := runtime.GOOS a = make([]int, 5, 5) // first arg length, second
switch { capacity
case os == "darwin": a = make([]int, 5) // capacity is optional
default: // loop over an array/ slice / struct
} for index, element := range a {
// cases can be presented in comma-separated lists
switch os { }
case "darwin", "linux":
} Maps & Struct
Maps
Maps are Go’s built-in associative data type (hashes or dicts)
Struct
Structs are the way to create concrete user-defined types in Go. Struct
types are declared by composing a fixed set of unique fields.

GoLang Cheat Sheet
Example Example (cont)
type Address struct { },

Street string },
City string // Determains the the length of the map
} _ = len(bookmyshow)
type Employee struct { // read the item from the map
Name string employees := bookmyshow["Bangalore"]
Age int // loop over an array, slice, struct array
Address Address for index, element := range employees {
} // read the element from the struct
// Can declare methods on structs. fmt.Println(index, element.Display())
func (emp Employee) Display() string { }
// accessing member // Delete the key from the map
name:=emp.Name delete(bookmyshow, "Pune")
return fmt.Sprintf("Name %s",name)
} Interfaces
// Initialize the map with the type
Interface type that specifies zero methods is known as
// map key is city value employees working
the empty interface
bookmyshow := make(map[string][]Employee)
var i interface{}
// Create new/updates the key value pair
i = 42
bookmyshow["Pune"] = []Employee{}
// Reflection: type switch specify types
bookmyshow["Bangalore"] = []Employee{
switch v := i.(type) {
Employee{
case int:
Name: "Andan H M",
fmt.Printf("(%v, %T)\n", i, i)
Age: 23,
case string:
Address: Address{
fmt.Printf("(%v, %T)\n", i, i)
Street: "KB Extension",
default:
City: "Davanagere",
fmt.Printf("Unknow type %T!\n", v)
},
}
Interfaces are named collections of method
signatures.
type error interface {

GoLang Cheat Sheet
Interfaces (cont) Unit Test
Error() string Go has a built-in testing command called go test and a package testing
} which combine to give a minimal but complete testing experience.
Standard tool-chain also includes benchmarking and code coverage

Accept interfaces, return structs
https://github.com/andanhm/gounittest
Error
Concurrency
The error type is an interface type.
Goroutines
error variable represents description of the error string
Goroutines are lightweight threads managed by Go
errors.New('user not found')
Channels
fmt.Errorf("%s user not found", "foo")
https://blog.golang.org/error-handling-and-go Channels are a typed conduit through which you can send and receive
values with the channel operator ( <- )
HTTP Handler
package main Example
import ( package main

"io" import "fmt"
"net/http" func main() {
) n := 2
func health(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK) // "make" the channel, which can be used
io.WriteString(w, "Ok") // to move the int datatype
} out := make(chan int)
func main() { // run this function as a goroutine
http.HandleFunc("/health", health) // the channel that we made is also provided
http.ListenAndServe(":8080", nil) go Square(n, out)
} // Any output is received on this channel
// print it to the console and proceed
A mini-toolkit/micro-framework to build web apps; with handler chaining,
middleware and context injection, with standard library compliant HTTP fmt.Println(<-out)
handlers(i.e. http.HandlerFunc). }
func Square(n int, out chan<- int) {
https://github.com/bnkamalesh/webgo result := n * n

GoLang Cheat Sheet
Example (cont) Example
//pipes the result into it package main

out <- result import (
} "encoding/json"
"encoding/xml"
select statement lets a goroutine wait on multiple communication
operations. "fmt"
)
sync go build-in package provides basic synchronization primitives such type Employee struct {
as mutual exclusion locks. Name string `json:"name" xml:"name"`
https://golang.org/pkg/sync/
Age int `json:"age" xml:"age"`
}
Defer, Panic, and Recover
func main() {
Defer emp := Employee{
A defer statement pushes a function call onto a Last In First Out order Name: "andan.h",
list. The list of saved calls is executed after the surrounding function Age: 27,
returns }
Panic // Marshal: refers to the process of converting

// the data or the objects into a byte-stream
Panic is a built-in function that stops the ordinary flow of control and
begins panicking. jsonData, _ := json.Marshal(emp)
fmt.Println(string(jsonData))
Recover
xmlData, _ := xml.Marshal(emp)
Recover is a built-in function that regains control of a panicking
fmt.Println(string(xmlData))
goroutine
// Unmarshal: refers to the reverse process of
func main() { // converting the byte-stream back to data or object
defer func() { json.Unmarshal(jsonData, &emp)
if r := recover(); r != nil { fmt.Println(emp)
fmt.Println("Recovered", r) }
}
}()
panic("make panic")
}
Encoding
encoding is a built-in package defines interfaces shared by other

packages that convert data to and from byte-level and textual
representations
Go offers built-in support for encoding/gob, encoding/json, and

encoding/xml
https://golang.org/pkg/encoding/

GoLang Cheat Sheet
Tool
https://godoc.org/golang.org/x/tools
https://dominik.honnef.co/posts/2014/12/an_incomplete_list_of_go_tools/
https://github.com/campoy/go-tooling-workshop


Andanhm Golang

Uploaded by

Copyright:

Available Formats

Andanhm Golang

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Andanhm Golang

Uploaded by

Copyright:

Available Formats

GoLang Cheat Sheet

by Andan H M (andanhm) via cheatography.com/69306/cs/17474/

Go Companies Using Golang

https:​//g​ola​ng.org/ and instant messages (CoyIM)

Uber for handling high volumes of geofen​ce-​based queries.

No ternary operator ?: Directory layout

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

Hello Word Built-in Types (cont)

package main float32 float64

Built-in Types // shorthand, only within func bodies

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

Variable & Function Declar​ations (cont) If statement

func person​(fi​rstName string, lastName string) {} if age < 18 {

Go don't have while until

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

Switch statement Arrays, Slices

// switch statement var a [3]int // declare an int array with length 3.

Maps are Go’s built-in associ​ative data type (hashes or dicts)

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

Example Example (cont)

type Address struct { },

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

Interfaces (cont) Unit Test

Standard tool-chain also includes benchm​arking and code coverage

package main Example

import ( package main

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

Example (cont) Example

​//pipes the result into it package main

Panic // Marshal: refers to the process of converting

encoding is a built-in package defines interfaces shared by other

Go offers built-in support for encodi​ng/gob, encodi​ng/​json, and

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

By Andan H M (andanhm) Published 21st October, 2018. Sponsored by CrosswordCheats.com

You might also like

https://golang.org/ and instant messages (CoyIM)

Uber for handling high volumes of geofence-based queries.

Variable & Function Declarations (cont) If statement

func person(firstName string, lastName string) {} if age < 18 {

Maps are Go’s built-in associative data type (hashes or dicts)

Standard tool-chain also includes benchmarking and code coverage

//pipes the result into it package main

Go offers built-in support for encoding/gob, encoding/json, and