Golang

Question 1

Basic Types

Answer 1

bool
string
int (8, 16, 32, 64)
uint (8, 16, 32, 64), uintptr - pointer
byte (uint8)
rune (uint32) like a char
float (32, 64)
complex (64, 128)

Question 2

Other Types

Answer 2

Array
Slice
Struct
Pointer
Function
Interface
Map
Channel

Question 3

Variable Declaration

Answer 3

var foo string
foo = “Hello World”

var bar = “Hello World” => same as above interprets the type automatically

baz := “Hello World” => no need to type in var

Question 4

Pointers

Answer 4

ptr -> var

string pointer cannot point to int pointer
pointer holds memory address

if we pass a pointer to a function then if the value changes outside of function then it also effects the value inside of the function.

message := “Hello World….”
var greeting *string = &message

Note: *string is required to store pointer value
&message => gets back address of message - this has to be stored inside a string pointer

• now greeting is a string pointer which points to message
• greeting store location of string message

fmt.Println(greeting, *greeting)
output => 0x123423, Hello World….

Question 5

User Defined Types

Answer 5

type Customer struct {
name string
age int
}

func main(){
  c1 = Customer{}
  c1.name = "Foo"
  c1.age = 10

c2 = Customer {name: “Bar”, age: 20}
c3 = Customer {“Bar”, 20}
}

Notes:

• no getters and setters
• no access specifiers

Question 6

Constants

Answer 6

const {
  PI = 3.14 => float const
  Language = "Go" => string const
}

const {
  A = iota
  B = iota
  C = iota
}

fmt.Println(A, B, C)
0, 1, 2

const {
  A = iota
  B
  C
}

fmt.Println(A, B, C)
0, 1, 2

• don’t have to initialize, it defaults to previous initialization

Question 7

Functions

Answer 7

func Greet (s Salutation){
  fmt.Println(CreateMessage(s.name, s.age))
}

func CreateMessage(name string, age int) string {
  return "hello " + name + ", your age is " + age
}

Question 8

Functions with multiple return types

Answer 8

func Greet (s Salutation){
  m1, m2 = CreateMessage(s.name, s.age)
  fmt.Println(m1, m2)
}

func CreateMessage (s Salutation) (string, string){
  return "foo", "bar"
}

===
s = Salutation {“foo”, 10}
Greet(s)

output
foo, bar

if you do not use a variable its an ERROR, so just use _ if you do not want a variable

i.e. _, m2 = CreateMessage(s.name, s.age)

Question 9

Functions with names multiple return types

Answer 9

func CreateMessage(s Salutation) (message string, alternate string){
  message = "foo"
  alternate = "bar"
  return
}

Question 10

Variadic Functions

Answer 10

• functions with variable input

func foo(name string, options ...string){
   fmt.Println(name, options[0], options[1])
}

foo(“hello world”, “foo”, “bar”)

Question 11

Function Types

Answer 11

• passing functions to other functions

func foo (name string, myfun string(int) (string)){
  "Hello " + name + ", drinking age? " + myfun(10)
}

func DrinkingEligible (age int) (string){
  if (age > 18){
   return "Yes"
  }
  else{
    return "No"
  }
}

==
foo(“hello “, DrinkingEligible)

Question 12

Func Type 2

Answer 12

type DrikingEligibilityCalculator string(int) (string)

func foo (name string, cal DrinkingEligibilityCalculator){
  "Hello " + name + ", drinking age? " + cal(10)
}

func DrinkingEligibilityUS (age int) (string){
  if (age > 21){
   return "Yes"
  }
  else{
    return "No"
  }
}

func DrinkingEligibilityUK (age int) (string){
  if (age > 18){
   return "Yes"
  }
  else{
    return "No"
  }
}
==
foo("hello ", DrinkingEligibleUS)
foo("hello ", DrinkingEligibleUK)

Question 13

If statements

Answer 13

if age := 100 alive {
  print("still alive at ", age)
}
else{
  print("not alive at ", age)
}

age is defined in scope of the if statement.

Question 14

Switch statement

Answer 14

switch name{
  case "bob":
     print("Hello Bob")
  case "sally":
    print("hello sally")
  default:
     print("No name")  
}

no switching param needed, it will switch on bool

switch {
  case name == "bob":
     print("Hello Bob")
  case name == "sally":
    print("hello sally")
  default:
     print("No name")  
}

Question 15

Loops

Answer 15

only have one type of loop i.e. FOR

for i := 0; i < 10; i++{

}

// similar to while loop
i := 0
for i < 10 {
  i ++
}

for {
break;
}

Question 16

Ranges

Answer 16

slice := [] foo {
“one”, “two”, “three”
}

for index, val := range slice {
print (“index: “ + index + “, value: “ + val)
}

Question 17

Maps

Answer 17

• dictionary

var foo map [string] string {}
foo = make(map [string] string)

initialization #1
foo[“bar”] = “aaaa”
foo[“baz”] = “bbbb”

initialization #2
var foo map [string] string {
  "bar": "aaaa",
  "baz": "bbbb"
}

to get values
foo[“bar”]

Operations
==
insert
update => foo["baz"] = "kkkkk"
delete => delete(foo, "baz")

Question 18

Slices

Answer 18

long version

• its a subset of an array
• arrays are fixed lengths and are difficult to pass into functions
• slices are varying length and are easy to pass to functions

var foo [] int
foo = make([] int, 5, 10) => make a a slice of integers with initial length of 5 and capacity of 10

foo := [] int {1, 2, 3}

bar := [] baz {
{id: 1, name: “”}, {id: 2, name: “”}
}
slice of baz struct

slicing operations
==
foo[1:2]   => 2
foo[0:2] => 1, 2
foo[0:] => 1, 2, 3

append(foo, 100)
append(foo, foo…) => append two slices

Question 19

Methods on Struct

Answer 19

functions v/s methods (operate on structs)

type Customer struct {
Id string
Name string
}

type Customers [] Customer

func (customers Customers) SayHello(){
   for _, c := range customers {
       print(c.Id, c.Name)
   }
}

usage
==
goodCustomers := Customers {
  {1, "Alice"}, {2, "Bob"}, {3, "Cathy"}
}

goodCustomers.SayHello()

Question 20

Methods

Answer 20

type Customer struct {
Id string
Name string
}

func (customer *Customer) rename (newName sting){
  customer.name = newName
}

here we have a pointer to the object, so it will change the underlying struct

john = Customer {1, “John”}
john.rename(“bob”)

Question 21

Concurrency

Answer 21

o/p

• go routines

func sayHello(arg){
  print("Hello world...")
}

go sayHello(“Concurrent”) ====> runs on its own thread
sayHello(“Normal”)
time.Sleep(100 * time.Millisecond)

Hello World Normal
Hello World Concurrent