Go Lang

Question 1

Is GO a compiled or interpreted language?

Answer 1

Go is a compiled language

Question 2

Go is either compiled or interpreted. What is a benefit or feature that GO provides that is unlike other languages executed similarly to GO?

Answer 2

Go, although being a compiled language, still has a garbage collector, which makes memory management easy

Question 3

GO doesn’t have classes what does it have in its stead and what are some of the features of classes that GO is not able to implement?

Answer 3

GO doesn’t have classes but has structs instead. Structs don’t support inheritance, constructors, and generics. This makes it easier to code and faster to run.

Question 4

Are variables case-sensitive in GO?

Answer 4

yes they are

Question 5

How to declare variables in GO?

Answer 5

var x, y int
keyword var_name_comma_sep type

Question 6

What’s a way to initialize and declare variables together in GO?

Answer 6

you can either do
var x int =100
or
var x = 100 //infers that 100 is int and assigns accordingly
or
x := 100 // can only be done inside a function; its illegal outside

Question 7

What are * and & in reference to pointers?

Answer 7

The “*” operator is used to declare a pointer variable and to access the value stored at the memory address pointed by the pointer.
The “&” operator is used to get the memory address of a variable. It is also called the address-of-operator.

func main() {
x := 10 // Declare variable x with value 10
var ptr int // Declare a pointer variable ptr of type int
ptr = &x // Assign the memory address of x to ptr
fmt.Println(“x:”, x) // Prints x: 10
fmt.Println(“ptr:”, ptr) // Prints ptr: 0x10414120
fmt.Println(“ptr:”, *ptr) // Prints *ptr: 10
*ptr = 20 // Change the value stored at the memory address pointed by ptr
fmt.Println(“x:”, x) // Prints x: 20
}

Question 8

what does the new() function do?

Answer 8

It returns a pointer to a variable.

use case:
ptr := new(int)
*ptr = 3

Question 9

Does dynamically and statically allocated memory go in a heap or stack?

Answer 9

Dynamically allocated memory in a heap and statically allocated memory in the stack.

Question 10

what is iota in GoLang?

Answer 10

iota is used when you want to define a set of constants which each have a different value but you don’t really care about what the value is.

Question 11

what’s is the typical form of a switch statement

Answer 11

switch variable {
case value1:
// code to be executed if variable == value1
case value2:
// code to be executed if variable == value2
case value3:
// code to be executed if variable == value3
…
default:
// code to be executed if variable does not match any of the case values
}

Question 12

what happens in Go if you write a switch statement without a tag?

Answer 12

it executes the first case that evaluates to true

Question 13

what is scan in Go and how is it used

Answer 13

scan is a method provided by the fmt package in Go, which is used to read input from a user and parse it into variables. It is commonly used to read input from the standard input (stdin)

Question 14

how do you define a slice in GoLang

Answer 14

for slices using [] is main
var my_slice[]int
or
my_slice := []int
or
weekdays := make([]string, 5)
or []string
or
[]string{}
or
[]string{value1, value2, value3, …value n}
arr := [7]string{“This”, “is”, “the”, “tutorial”, “of”, “Go”, “language”}

Question 15

first.go
package main

import “fmt”

func main() {

var a1 byte = 97
var a2 byte = 98
var a3 byte = 99

fmt.Println(a1)
fmt.Println(a2)
fmt.Println(a3)

fmt.Printf("%c\n", a1)
fmt.Printf("%c\n", a2)
fmt.Printf("%c\n", a3) }

Answer 15

$ go run first.go
97
98
99
a
b
c

A byte in Go is an unsigned 8-bit integer. It has type uint8. A byte has a limit of 0 – 255 in numerical range. It can represent an ASCII character.
Go uses rune, which has type int32, to deal with multibyte characters.

Question 16

types.go
package main

import (
“fmt”
“reflect”
)

func main() {

 var a byte = 97
 var b = 98
 c := 'c'

 fmt.Println(a)
 fmt.Println(b)
 fmt.Println(c)

 fmt.Println("-------------------------")

 fmt.Printf("%c\n", a)
 fmt.Printf("%c\n", b)
 fmt.Printf("%c\n", c)

 fmt.Println("-------------------------")

 fmt.Println(reflect.TypeOf(a))
 fmt.Println(reflect.TypeOf(b))
 fmt.Println(reflect.TypeOf(c)) }

Answer 16

$ go run types.go
97
98
99
————————-
a
b
c
————————-
uint8
int
int32

Go uses rune, which has type int32, to deal with multibyte characters.
A byte in Go is an unsigned 8-bit integer. It has type uint8. A byte has a limit of 0 – 255 in numerical range.

Question 17

what are slices in GO?

Answer 17

You can think of a slice in go as a pointer to an array with an offset and length. It can be passed by value to functions and not just by reference.