- They should share the same signatures, including parameter types and return types.
- They should share the same parameter types but can return different types.
- All functions should be the same type.
- The functions should not be a first class type.
User defined function types in Go (Golang)
- the number of characters
- the number of bytes
- It does not accept string types.
- the number of code points
Length of string in Go (Golang).
-
do { ... } while i < 5-
for _,c := range "hello" { ... }-
for i := 1; i < 5; i++ { ... }-
for i < 5 { ... }Explanation: Go has only for-loops
values := []int{1, 1, 2}-
values.append(3)-
values.insert(3, 3)-
append(values, 3)-
values = append(values, 3)Explanation: slices in GO are immutable, so calling append does not modify the slice
const (
Write = iota
Read
Execute
)- 0
- 1
- 2
- a random value
-
import "github/gin-gonic/gin"-
import "https://github.com/gin-gonic/gin"-
import "../template"-
import "github.com/gin-gonic/gin"package main
var GlobalFlag string
func main() {
print("["+GlobalFlag+"]")
}- It would not compile because
GlobalFlagwas never initialized. - It would compile and print
[]. - It would compile and print nothing because
"[" +nil+"]"is alsonil. - It would compile but then panic because
GlobalFlagwas never initialized.
- variables in Go have initial values. For string type, it's an empty string.
- Go Playground
Q8. From where is the variable myVar accessible if it is declared outside of any functions in a file in package myPackage located inside module myModule?
- It can be accessed anywhere inside
myPackage, not the rest of myModule. - It can be accessed by any application that imports
myModule. - It can be accessed from anywhere in
myModule. - It can be accessed by other packages in
myModuleas long as they importmyPackage
Explanation: to make the variable available outside of myPackage change the name to MyVar.
See also an example of Exported names in the Tour of Go.
-
go test -
go test -x -
go test --verbose -
go test -v
type Point struct {
x int
y int
}
func main() {
data := []byte(`{"x":1, "y": 2}`)
var p Point
if err := json.Unmarshal(data, &p); err != nil {
fmt.Println("error: ", err)
} else {
fmt.Println(p)
}
}- use
json.Decoder - Pass a pointer to
data - Make
XandYexported (uppercase) - Use field tags
- all goroutines
- any other call to lock that
Mutex - any reads or writes of the variable it is locking
- any writes to the variable it is locking
- Mutex in GoLang, sync.Mutex locks so only one goroutine at a time can access the locked variable.
- sync.Mutex
Q12. What is an idiomatic way to pause execution of the current scope until an arbitrary number of goroutines have returned?
- Pass an
intandMutexto each and count when they return. - Loop over a
selectstatement. - Sleep for a safe amount of time.
-
sync.WaitGroup
Explanation: this is exactly what sync.WaitGroup is designed for - Use sync.WaitGroup in Golang
- It blocks the other channels.
- It is meant to be used in select statements without side effects.
- It blocks the
selectstatement until the time has passed. - The goroutine does not end until the time passes.
Note: it doesn't block
selectand does not block other channels.
- time.After() Function in Golang With Examples
- How can I use 'time.After' and 'default' in Golang?
- Go Playground example
- executing a function concurrently
- executing a different case based on the type of a variable
- executing a different case based on the value of a variable
- executing a different case based on which channel returns first
func Add(a, b int) int {
return a + b
}-
A
// Calculate a + b // - a: int // - b: int // - returns: int func Add(a, b int) int { return a + b }
-
B
// Does a + b func Add(a, b int) int { return a + b }
-
C
// Add returns the sum of a and b func Add(a, b int) int { return a + b }
-
D
// returns the sum of a and b func Add(a, b int) int { return a + b }
Explanation: documentation block should start with a function name
-
myValmust be an integer type, such asint,int64,int32, etc. -
myValmust be able to be asserted as anint. -
myValmust be an interface. -
myValmust be a numeric type, such asfloat64orint64.
Explanation: This kind of type casting (using .(type)) is used on interfaces only.
- a global variable
- a medium for sending values between goroutines
- a dynamic array of values
- a lightweight thread for concurrent programming
- Check runtime.GOOS.
- Add a // +build windows comment anywhere in the file.
- Add a _ prefix to the file name.
- Add a // +build windows comment at the top of the file.
//go:build windows"Go versions 1.16 and earlier used a different syntax for build constraints, with a "// +build" prefix. The gofmt command will add an equivalent //go:build constraint when encountering the older syntax."
data := "A group of Owls is called a parliament"-
resp, err := http.Post("https://httpbin.org/post", "text/plain", []byte(data))-
resp, err := http.Post("https://httpbin.org/post", "text/plain", data)-
resp, err := http.Post("https://httpbin.org/post", "text/plain", strings.NewReader(data))-
resp, err := http.Post("https://httpbin.org/post", "text/plain", &data)Q20. What should the idiomatic name be for an interface with a single method and the signature Save() error?
- Saveable
- SaveInterface
- ISave
- Saver
- does not create; creates
- does not create; does not create
- creates; creates
- creates; does not create
Go Language Core technology (Volume one) 1.5-scope
Relevant excerpt from the article:
The second if statement is nested inside the first, so a variable declared in the first if statement is visible to the second if statement. There are similar rules in switch: Each case has its own lexical block in addition to the conditional lexical block.
- The default behavior is case insensitive, but it can be overridden.
- Fields are matched case sensitive.
- Fields are matched case insensitive.
- The default behavior is case sensitive, but it can be overridden.
Relevant excerpt from the article:
To unmarshal JSON into a struct, Unmarshal matches incoming object keys to the keys used by Marshal (either the struct field name or its tag), preferring an exact match but also accepting a case-insensitive match. By default, object keys which don't have a corresponding struct field are ignored (see Decoder.DisallowUnknownFields for an alternative).
- Time.Add() is for performing addition while Time.Sub() is for nesting timestamps.
- Time.Add() always returns a later time while time.Sub always returns an earlier time.
- They are opposites. Time.Add(x) is the equivalent of Time.Sub(-x).
- Time.Add() accepts a Duration parameter and returns a Time while Time.Sub() accepts a Time parameter and returns a Duration.
- Every field must have all tags to compile.
- It tightly couples different layers of your application.
- Any tags after the first are ignored.
- Missing tags panic at runtime.
- in the main function
- immediately after a line that might panic
- inside a deferred function
- at the beginning of a function that might panic
Example of Recover Function in Go (Golang)
Relevant excerpt from the article:
Recover is useful only when called inside deferred functions. Executing a call to recover inside a deferred function stops the panicking sequence by restoring normal execution and retrieves the error message passed to the panic function call. If recover is called outside the deferred function, it will not stop a panicking sequence.
-
println(message) -
log.New(os.Stderr, "", 0).Println(message) -
fmt.Errorf("%s\n", message) -
fmt.Fprintln(os.Stderr, message)
- func println: writes the result to standard error.
- func New: func New(out io.Writer, prefix string, flag int) *Logger; the out variable sets the destination to which log data will be written.
- func Errorf: Errorf formats according to a format specifier and returns the string as a value.
- func Fprintln: func Fprintln(w io.Writer, a ...any) (n int, err error); Fprintln formats using the default formats for its operands and writes to w.
- Use a proxy.
- Change the import path.
- Use a replace directive in go.mod.
- Use a replace directory.
- Call your code from another module: chapter 5.,
go mod edit -replace example.com/greetings=../greetings. - go.mod replace directive
Q28. If your current working directory is the top level of your project, which command will run all its test packages?
-
go test all -
go run --all -
go test . -
go test ./...
Relevant excerpt from the article:
Relative patterns are also allowed, like "go test ./..." to test all subdirectories.
- any, it accepts arbitary bytes
- any Unicode format
- UTF-8 or ASCII
- UTF-8
Relevant excerpt from the article:
In short, Go source code is UTF-8, so the source code for the string literal is UTF-8 text.
Relevant excerpt from the article:
Package encoding defines an interface for character encodings, such as Shift JIS and Windows 1252, that can convert to and from UTF-8.
- There is no difference.
- t.Fatal does not crash the test harness, preserving output messages.
- t.Fatal stops execution of the subtest and continues with other test cases.
- t.Fatal stops all tests and contains extra information about the failed subtest.
- Reference:
- testing package in Go, the relevant excerpt from the article:
Fatalis equivalent toLogfollowed byFailNow.Logformats its arguments using default formatting, analogous toPrintln, and records the text in the error log.FailNowmarks the function as having failed and stops its execution by callingruntime.Goexit(which then runs all deferred calls in the current goroutine). Execution will continue at the next test or benchmark.FailNowmust be called from the goroutine running the test or benchmark function, not from other goroutines created during the test. CallingFailNowdoes not stop those other goroutines.Runrunsfas a subtest oftcalled name. It runsfin a separate goroutine and blocks untilfreturns or callst.Parallelto become a parallel test. Run reports whetherfsucceeded (or at least did not fail before callingt.Parallel). Run may be called simultaneously from multiple goroutines, but all such calls must return before the outer test function for t returns.
- It raises a panic.
- It prints the log and then raises a panic.
- It prints the log and then safely exits the program.
- It exits the program.
Example of func Fatal in Go (Golang)
Relevant excerpt from the article:
Fatalis equivalent toPrint()followed by a call toos.Exit(1).
- "2006-01-02"
- "YYYY-mm-dd"
- "y-mo-d"
- "year-month-day"
Relevant excerpt from the article:
Year: "2006" "06"
Month: "Jan" "January" "01" "1"
Day of the week: "Mon" "Monday"
Day of the month: "2" "_2" "02"
Day of the year: "__2" "002"
Hour: "15" "3" "03" (PM or AM)
Minute: "4" "04"
Second: "5" "05"
AM/PM mark: "PM"
-
log.Error(err) -
log.Printf("error: %v", err) -
log.Printf(log.ERROR, err) -
log.Print("error: %v", err)
Explanation: There is defined neither log.ERROR, nor log.Error() in log package in Go; log.Print() arguments are handled in the manner of fmt.Print(); log.Printf() arguments are handled in the manner of fmt.Printf().
- any that starts with
test - any files that include the word
test - only files in the root directory that end in
_test.go - any that ends in
_test.go
- Test packages in go command in Go: 'Go test' recompiles each package along with any files with names matching the file pattern "*_test.go".
- Add a test in Go
ch := make(chan int)
ch <- 7
val := <-ch
fmt.Println(val)- 0
- It will deadlock
- It will not compile
- 2.718
Go Playground share, output:
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox2282523250/prog.go:7 +0x37
Program exited.
ch := make(chan int)
close(ch)
val := <-ch
fmt.Println(val)- It will deadlock
- It will panic
- 0
- NaN
-
The Go Programming Language Specification "Receive operator", Relevant excerpt from the article:
A receive operation on a closed channel can always proceed immediately, yielding the element type's zero value after any previously sent values have been received.
-
Go Playground share, output:
0
Program exited.
var stocks map[string]float64 // stock -> price
price := stocks["MSFT"]
fmt.Printf("%f\n", price)- 0
- 0.000000
- The code will panic
- NaN
Go Playground share, output:
0.000000
Program exited.
- Have a cmd directory and a directory per executable inside it.
- Comment out main.
- Use build tags.
- Have a pkg directory and a directory per executable inside it.
- Set GOOS to arm64 and GOARCH to darwin.
- Set GOOS to osx and GOARCH to arm64.
- Set GOOS to arm64 and GOARCH to osx.
- Set GOOS to darwin and GOARCH to arm64.
-
go(fmt.Println("Hello Gopher!")) -
go func() { fmt.Println("Hello Gopher!") } -
go fmt.Println("Hello Gopher!") -
Go fmt.Println("Hello Gopher!")
Q41. If you iterate over a map in a for range loop, in which order will the key:value pairs be accessed?
- in pseudo-random order that cannot be predicted
- in reverse order of how they were added, last in first out
- sorted by key in ascending order
- in the order they were added, first in first out
Q42. What is an idiomatic way to customize the representation of a custom struct in a formatted string?
- There is no customizing the string representation of a type.
- Build it in pieces each time by calling individual fields.
- Implement a method
String()string - Create a wrapper function that accepts your type and outputs a string.
func findUser(ctx context.Context, login string) (*User, error) {
ch := make(chan *User)
go func() {
ch <- findUserInDB(login)
}()
select {
case user := <-ch:
return user, nil
case <-ctx.Done():
return nil, fmt.Errorf("timeout")
}
}- Use a sync.WaitGroup.
- Make ch a buffered channel.
- Add a default case to the select.
- Use runtime.SetFinalizer.
Relevant excerpt from the article:
The simplest way to resolve this leak is to change the channel from an unbuffered channel to a buffered channel with a capacity of 1. Now in the timeout case, after the receiver has moved on, the Goroutine will complete its send by placing the *User value in the channel then it will return.
var i int8 = 120
i += 10
fmt.Println(i)- -126
- 0
- NaN
- 130
Go Playground example, output:
-126
Program exited.
45. Given the definition of worker below, what is the right syntax to start a goroutine that will call worker and send the result to a channel named ch?
func worker(m Message) Result-
go func() {
r := worker(m)
ch <- r
}-
go func() {
r := worker(m)
r -> ch
} ()-
go func() {
r := worker(m)
ch <- r
} ()-
go ch <- worker(m)package os
type FilePermission int
type userID int- FilePermission
- none of these answers
- FilePermission and userID
- userID
- Structure is another user defined data type available in Go programming, which allows you to combine data items of different kinds.
- Structures are used to represent a record
- To define a structure, you must use type and struct statements.
- All of the above
- It provides subcommands
sql,json,yaml, and switches--schemaand--objectsto generate relevant code. - It looks for files with names that end with
_generate.go, and then compiles and runs each of these files individually. - It scans the projects source code looking for
//go:generatecomments, and for each such comment runs the terminal command it specifies. - It has subcommands
mocksandteststo generate relevant.gosource files.
Generate Go files by processing source
-
time.Now().Add(90) -
time.Now() + (90 * time.Minute) -
time.Now() + 90 -
time.Now().Add(90 * time.Minute)
Q50. A program uses a channel to print five integers inside a goroutine while feeding the channel with integers from the main routine, but it doesn't work as is. What do you need to change to make it work?
- Add a
close(ch)immediately afterwg.Wait(). - Add a second parameter to
make(chan, int), e.g.make(chan int, 5). - Remove the use of unnecessary
WaitGroupcalls, e.g. all lines that start withwg. - Move the 7-line goroutine immediately after
wg.Add(1)to a line immediately beforewg.Wait().
Relevant excerpt from the article:
The simplest way to resolve this leak is to change the channel from an unbuffered channel to a buffered channel with a capacity of 1. Now in the timeout case, after the receiver has moved on, the Goroutine will complete its send by placing the *User value in the channel then it will return.
-
encoding.json.Marshal -
encoding/json.Marshal -
Marshal -
json.Marshal
Q52. What are the two missing segments of code that would complete the use of context.Context to implement a three-second timeout for this HTTP client making a GET request?
package main
import (
"context"
"fmt"
"net/http"
)
func main() {
var cancel context.CancelFunc
ctx := context.Background()
// #1: <=== What should go here?
req, _ := http.NewRequest(http.MethodGet,
"https://linkedin.com",
nil)
// #2: <=== What should go here?
client := &http.Client{}
res, err := client.Do(req)
if err != nil {
fmt.Println("Request failed:", err)
return
}
fmt.Println("Response received, status code:",
res.StatusCode)
}-
ctx.SetTimeout(3*time.Second)
req.AttachContext(ctx)-
ctx, cancel = context.WithTimeout(ctx, 3*time.Second); defer cancel()
req = req.WithContext(ctx)-
ctx, cancel = context.WithTimeout(ctx, 3*time.Second); defer cancel() #2: req.AttachContext(ctx)-
ctx.SetTimeout(3*time.Second)
req = req.WithContext(ctx)Q53. If you have a struct named Client defined in the same .go file as the statement, how do you export a variable with a default value so the variable is accessible by other packages?
-
let Default := new Client()
-
public default = &Client()
-
var Default = &Client{}
-
export default := new Client{}
Q54. This program outputs {Master Chief Spartan Protagonist Halo}. How would you get it to output Master Chief - a Spartan - is the Protagonist of Halo instead?
package main
import "fmt"
type Character struct{
Name string
Class string
Role string
Game string
}
func main() {
mc := Character{
Name: "Master Chief",
Class: "Spartan",
Role: "Protagonist",
Game: "Halo",
}
fmt.Println(mc)
}-
A
// Replace // fmt.Println(mc) // with this: fmt.Printf("(?P<Name>) - a (?P<Class>) - is the (?P<Role>) of (?P<Game>)", mc)
-
B
// Replace // fmt.Println(mc) // with this: fmt.Println(mc, func(c Character) string { return c. Name + " - a " + c.Class + " - is the " + c.Role + " of " + c.Game })
-
C
// add this to the package `main` func (c Character) String() string { return fmt.Sprintf("%s - a %s - is the %s of %s", c.Name, c.Class, c.Role,c.Game) }
-
D
// add this to the package `main` func (c Character) OnPrint() { fmt.Println("{{c.Name}} - a {{c.Class}} - is the {{c.Role}} of {{c.Game}}") }
package main
type Client struct {
Name string
}
type Clients struct {
clients []*Client
}
func main() {
c:= &Clients{clients.make([]*Client,0)}
c.Append(&Client{Name: "LinkedIn API})
}-
A
func (cc *Clients) Append(c *Client) { cc.clients = append(cc.clients, c) }
-
B
func (cc *Clients) Append(c *Client) { cc.append(c) }
-
C
func (cc Clients) Append(c Client) { cc.clients = append(cc.clients, c) }
-
D
func (cc *Clients) Append(c Client) { cc.clients.append(c) }
Q56. How would you recover from a panic() thrown by a called function without allowing your program to fail assuming your answer will run in the same scope where your function call will experience the panic?
-
Wrap the function call in an anonymous function with a return type of
panic, remembering to invoke the anonymous function by suffixing it with()then introspecting the returnedpanicinstance to handle the error. -
Use
try{ ... }to wrap the code calling the function and then handle the error within thecatch{ ... }. -
Use
defer func { ... }()before the function call with the error and then handle the panic inside the anonymous function. -
Prefix the function call with
@to force return the panic as anerrorvalue and then handle the error just as you would anerrorreturned by any function.
var n int
fmt.Println (n)- 0
- nil
- a random value
- 1
This is because in Go, when a variable is declared but not explicitly initialized, it is assigned a default zero value based on its type. For integers like n, the zero value is 0.
Q58. When creating a formatted string, which verb should you use to call the String () string method of a custom type?
- %s
- %b
- %v
- %string
In Go, the %s verb is used to format a string. When used with a custom type that has a String() method defined, the String() method will be automatically called and its return value will be used in the formatted string.
- time.REC3339
- "1970-01-01"
- "Jan 2nd 2006"
- time.Kitchen
According to the documentation, the value 1 and 01 will represent the current month.
each layout string is a representation of the time stamp,
Jan 2 15:04:05 2006 MST
An easy way to remember this value is that it holds, when presented in this order, the values (lined up with the elements above):
1 2 3 4 5 6 -7
Q60. How would you signal to the Go compiler that the Namespace struct must implement the JSONConverter interface? This question assumes the answer would be included in the same package where Namespace is declared.
- var_JSONConverter = nil. (*Namespace)
- var_JSONConverter = (*Namespace) (nil)
- type Namespace struct { implements JSONConverter // The rest of the struct declaration goes here }
- type Namespace struct { JSONConverter // The rest of the struct declaration goes here }
This syntax creates a variable _ with the type of JSONConverter and assigns to it a value of (*Namespace)(nil). This essentially checks that the Namespace struct satisfies the JSONConverter interface by ensuring that it can be assigned to a variable of type JSONConverter.
- A method signature is the combination of a method name and the type(s) of its declared parameter(s) and return value(s).
- A struct must explicitly declare using the implements keyword that its instances can be used wherever a variable, parameter, and/or return value is typed for the declared interface.
- An interface declares a list of methods and their signatures that a type must implement to be compatible with values typed for that interface.
- Variable, parameters, and return values must be "typed" as one of 1) a built-in type, 2) a type alias, 3) a derived type, 4) a composite type, or
- an interface.
===[Output]================
1: &{GameId:1 Title:Wolfenstein YearReleased:1992}
2: &{GameId:2 Title:Doom YearReleased:1993}
3: &{GameId:3 Title:Quake YearReleased:1996}
===[main.go]================
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
"log"
)
type Game struct {
GameId int
Title string
YearReleased int
}
func main() {
conn, err := sql.Open("mysql",
"john_carmack:agiftw!@tcp(localhost:3306)/idsoftware")
if err != nil {
panic(err)
}
defer func() { _ = conn.Close() }()
results, err := conn.Query("SELECT game_id,title,year_released FROM games;")
if err != nil {
panic(err)
}
defer func() { _ = results.Close() }()
// #1 <=== What goes here?
for results.Next() {
var g Game
// #2 <=== What goes here?
if err != nil {
panic(err)
}
// #3 <=== What goes here?
}
for i, g := range games {
fmt.Printf("%d: %+v\n", i, g)
}
}-
#1: games := make([]*Game, results.RowsAffected())
#2: g, err = results.Fetch()
#3: games[results.Index()] = &g-
#1: games := []Game{}
#2: g, err = results.Fetch()
#3: games = append(games,g)-
#1: games := map[int]Game{}
#2: err = results.Scan(&g)
#3: games[g.GameId] = g-
#1: games := make(map[int]*Game, 0)
#2: err = results.Scan(&g.GameId, &g.Title, &g.YearReleased)
#3: games[g.GameId] = &g- Test files in Go must _.
- Individual tests are identified by _.
- You can run subtests by __.
- You log the error and mark the test failed by _.
-
be stored in a
/test/subdirectory of that package
functions accepting atesting.Testerparameter
writing functions with names matching^Subtest
callingtesting.AssertionFailed -
end in
_test.go
function names matching^Test[A-Z]
callingt.Run()
callingt.Errorf() -
begin with
test_
functions matching[a-z]Test$
callingtesting.Subtest()
allowingtesting.Assert()to fail its assertion -
be stored in
/test/root subdirectory for the project
functions accepting atesting.Testparameter
passing closures totesting.AddSubtest()
returning anerrorfrom the function
- char
- byte
- int32
- string
Relevant excerpt from the article:
The Go language defines the word rune as an alias for the type int32, so programs can be clear when an integer value represents a code point.
x, err := myFunc()- if it at least has not been declared in that lexical block
- at all times, as it will overwrite existing variables
- if no variables of those names is accessible
- if none of the variables exist in that lexical block
- go pprof -to SVG cpu.prof
- go tool pprof -http=:8080 cpu.pprof (true)
- go tool pprof cpu.pprof
- go tool trace cpu.pprof
- It has been assingned a dynamic type whose value is nil. (true)
- It has been explicitly set to nil.
- It has not been assigned a dynamic type.
- It can not evaluate to nil.
- nil
- undefined
- null
- ""
If a string variable has been allocated but not assigned a value, its default value is an empty string "". In Go, uninitialized string variables are automatically assigned the zero value for their respective type, which for strings is an empty string.
- panic
- There is no such function.
- raiseException
- exit
The built-in function used to stop a program from continuing is
panic(). Whenpanic()is called, it triggers a panic, which stops the normal execution flow of the program and begins panicking. If the panic is not recovered, the program terminates.
a,b := 1, 2
b,c:= 3, 4
fmt.Println(a, b, c)- 1 3 4
- 1 2 3
- 1 2 4
- It will not compile.
- +
- and
- &&
- ||
- A function with no return type.
- A function with no parameters.
- A function without a name.
- A function declared inside another function.
-
func -
lambda -
func() -
anonymous
- They always have better performance than named functions.
- They can have multiple return values.
- They can be defined inline where they are used.
- They have a shorter syntax than named functions.
Explanation: they can be defined inline where they are used, offering more flexibility in code organization.
-
functionName(){} -
call functionName(){} -
func(){}() -
execute func(){}
-
all named types not built-in to Go, such as type Example int but not int, type Example struct{...} but not struct, etc. -
only types named struct, map, and slice, such as type Example struct{…} -
only types named struct, such as type Example struct{...} -
all types
Methods can be defined for any named type that is not a built-in type. When you create a new type using a type declaration, it becomes a named type, and you can define methods specific to that type. However, methods cannot be directly attached to built-in types like int, string, etc. reference