go

Question 1

Front

Answer 1

Back

Question 2

How do you start a goroutine that calls function f?

Answer 2

go f()

Question 3

Code:

```go
____ f() // launch concurrently
~~~

Answer 3

go

Question 4

What Go type is used to synchronize concurrent goroutines waiting for completion?

Answer 4

sync.WaitGroup

Question 5

Fill the blank to send value v on channel ch: \_\_\_\_

Answer 5

ch <- v

Question 6

Fill the blank to receive from channel ch into x: x := \_\_\_\_

Answer 6

<-ch

Question 7

What happens when you close a channel?

Answer 7

Receivers drain remaining buffered values then receive zero values; sends panic.

Question 8

Idiomatic way to avoid blocking send when channel is full?

Answer 8

Use select { case ch <- v: default: }

Question 9

How do you create a buffered channel of int with capacity 4?

Answer 9

ch := make(chan int, 4)

Question 10

Which type provides an efficient mutable bytes buffer?

Answer 10

bytes.Buffer

Question 11

Code completion: write “hello” to buffer b

```go
var b bytes.Buffer
b.____(“hello”)
~~~

Answer 11

WriteString

Question 12

Copy all data from r to w: ____

Answer 12

io.Copy(w, r)

Question 13

Quickly build strings without reallocations:

Answer 13

strings.Builder

Question 14

Start a basic HTTP server on :8080 serving mux:

Answer 14

log.Fatal(http.ListenAndServe(“:8080”, mux))

Question 15

Create GET request with context ctx to url u:

Answer 15

req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)

Question 16

Defer closing response body resp:

Answer 16

defer resp.Body.Close()

Question 17

Marshal struct s to JSON bytes:

Answer 17

b, err := json.Marshal(s)

Question 18

Unmarshal JSON bytes b into variable v:

Answer 18

err := json.Unmarshal(b, &v)

Question 19

Add json tag to field Name in struct:

Answer 19

Name string json:”name”``

Question 20

Make []int of len 0 cap 10:

Answer 20

s := make([]int, 0, 10)

Question 21

Append value x to slice s:

Answer 21

s = append(s, x)

Question 22

Map lookup idiom for key k in m, getting ok flag:

Answer 22

v, ok := m[k]

Question 23

Declare method String() string on pointer *T:

Answer 23

func (t *T) String() string { … }

Question 24

Blank identifier purpose _:

Answer 24

Ignore value or import side‑effect

Question 25

Interface satisfaction rule:

Answer 25

Implicit: type implements interface by having required methods

Question 26

Idiomatic error check after call returning error err:

Answer 26

if err != nil { return err }

Question 27

Wrap an error with context:

Answer 27

fmt.Errorf("context: %w", err)

Question 28

Check if err is io.EOF:

Answer 28

errors.Is(err, io.EOF)

Question 29

Create cancellable context child of ctx:

Answer 29

ctx, cancel := context.WithCancel(ctx)

Question 30

Timeout a goroutine after 5s using select and time.After:

Answer 30

select { case <-done: case <-time.After(5*time.Second): }

Question 31

Add 1 to WaitGroup wg before launching goroutine:

Answer 31

wg.Add(1)

Question 32

Mark WaitGroup done in goroutine:

Answer 32

defer wg.Done()

Question 33

Ensure init() runs exactly once:

Answer 33

var once sync.Once; once.Do(init)

Question 34

Set max OS threads to n:

Answer 34

runtime.GOMAXPROCS(n)

Question 35

Run only TestFoo in package tests:

Answer 35

go test -run TestFoo

Question 36

Read entire file my.txt to bytes:

Answer 36

b, err := os.ReadFile("my.txt")

Question 37

Use bufio.Scanner to read file line by line: fill blank ```go scanner := bufio.NewScanner(____) ```

Answer 37

file

Question 38

Add build tag 'netgo' at top of file:

Answer 38

//go:build netgo

Question 39

Purpose of default case in select:

Answer 39

Non‑blocking select path if no other cases ready.

Question 40

What is a goroutine leak?

Answer 40

Goroutines blocked forever on channel/IO so never exit.

Question 41

Allow multiple readers but single writer lock type:

Answer 41

`sync.RWMutex`

Question 42

Embed type Logger in struct S:

Answer 42

type S struct { *log.Logger }

Question 43

Signature of io.Reader's Read:

Answer 43

Read(p []byte) (n int, err error)

Question 44

Combine outputs from multiple channels into one: pattern name?

Answer 44

Fan‑in