Go toolchain overview - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print the Go version using the runtime package.

Go

package main

import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Println(runtime.[1]())
}

Drag options to blanks, or click blank then click option'

AVersionInfo

BGoVersion

CGetVersion

DVersion

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent function like GoVersion()

Accessing Version as a variable instead of calling the function

The runtime.Version function returns the Go version as a string.

2fill in blank

medium

Complete the command to build a Go program into an executable.

Go

go [1] main.go

Drag options to blanks, or click blank then click option'

Abuild

Brun

Cinstall

Dtest

Attempts:

3 left

💡 Hint

Common Mistakes

Using go run which compiles and runs immediately

Using go test which runs tests instead of building

The go build command compiles the source code into an executable binary.

3fill in blank

hard

Fix the error in the command to run tests with verbose output.

Go

go test [1] ./...

Drag options to blanks, or click blank then click option'

A-v

B-verbose

C-verbose=true

D--verbose

Attempts:

3 left

💡 Hint

Common Mistakes

Using long flags like --verbose which are not supported

Using -verbose=true which is invalid syntax

The correct flag for verbose output in go test is -v.

4fill in blank

hard

Fill both blanks to create a map of word lengths for words longer than 3 characters.

Go

words := []string{"go", "tool", "chain", "test"}
lengths := make(map[string]int)
for _, word := range words {
	if len(word) [2] 3 {
		lengths[word] = [1]
	}
}

Drag options to blanks, or click blank then click option'

Alen(word)

B>

C<

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using word instead of len(word) for the map value

Using < instead of > for filtering

The loop uses len(word) to get length and filters words with length greater than 3 using >.

5fill in blank

hard

Fill all three blanks to create a map of uppercase words to their lengths for words longer than 3 characters.

Go

words := []string{"go", "tool", "chain", "test"}
lengths := make(map[string]int)
for _, [2] := range words {
	if len([2]) [3] 3 {
		lengths[[1]([2])] = len([2])
	}
}

Drag options to blanks, or click blank then click option'

A""

Bword

C>

Dstrings.ToUpper

Attempts:

3 left

💡 Hint

Common Mistakes

Using empty string "" as map key

Using wrong comparison operator like < instead of >

Use strings.ToUpper as the function for uppercase keys, word as the loop variable, and > for the length condition.

Practice

1. Which Go toolchain command is used to create an executable file from your Go source code?

easy

A. go build

B. go run

C. go fmt

D. go test

Solution

1. Step 1: Understand the purpose of go build

   The go build command compiles your Go source code into an executable file.

2. Step 2: Compare with other commands

   go run runs code without creating an executable, go fmt formats code, and go test runs tests.

3. Final Answer:

   go build -> Option A

4. Quick Check:

   Executable creation = go build [OK]

Hint: Build creates executables; run just executes code [OK]

Common Mistakes:

• Confusing go run with go build
• Thinking go fmt builds code
• Using go test to build executables

2. Which of the following is the correct syntax to run a Go program file named main.go using the Go toolchain?

easy

A. go build main.go

B. go test main.go

C. go run main.go

D. go fmt main.go

Solution

1. Step 1: Identify the command to run code directly

   go run compiles and runs the Go program immediately without creating an executable.

2. Step 2: Check other commands

   go build compiles but does not run, go fmt formats code, and go test runs tests, so they are not for running directly.

3. Final Answer:

   go run main.go -> Option C

4. Quick Check:

   Run code immediately = go run [OK]

Hint: Use go run to execute files quickly [OK]

Common Mistakes:

• Using go build to run code directly
• Trying to run tests with go run
• Confusing go fmt as a run command

3. What will be the output when you run the following commands in order?

go fmt main.go
 go build main.go
 ./main

Assuming main.go contains a valid Go program that prints "Hello, Go!".

medium

A. Syntax error

B. Hello, Go!

C. No output

D. Compilation error

Solution

1. Step 1: Understand each command's effect

   go fmt main.go formats the code but does not affect output. go build main.go compiles the code into an executable named main. ./main runs the executable.

2. Step 2: Predict the program output

   Since main.go prints "Hello, Go!", running ./main will output exactly that.

3. Final Answer:

   Hello, Go! -> Option B

4. Quick Check:

   Build then run prints program output [OK]

Hint: Build creates executable; run it to see output [OK]

Common Mistakes:

• Expecting go fmt to produce output
• Confusing build errors with formatting
• Not running the executable after build

4. You run go test on your Go package, but it reports no tests found. What is the most likely reason?

medium

A. Your test functions are not named starting with Test

B. You forgot to run go build first

C. You need to run go fmt before testing

D. Your Go version is outdated

Solution

1. Step 1: Understand Go test naming conventions

   Go requires test functions to start with Test (e.g., TestFunction) to detect and run them.

2. Step 2: Check other options

   go build is not required before testing, go fmt only formats code, and outdated Go versions usually cause errors, not silent no tests.

3. Final Answer:

   Test functions not named starting with Test -> Option A

4. Quick Check:

   Test function names start with 'Test' [OK]

Hint: Test functions must start with 'Test' to run [OK]

Common Mistakes:

• Assuming build is needed before test
• Thinking formatting affects test detection
• Blaming Go version without checking test names

5. You want to automate your Go project workflow to format code, run tests, and then build the executable only if tests pass. Which sequence of commands correctly achieves this?

hard

A. go build && go test && go fmt

B. go fmt && go build && go test

C. go test && go fmt && go build

D. go fmt ./... && go test ./... && go build

Solution

1. Step 1: Understand command order for workflow

   First, go fmt ./... formats all code files recursively. Then, go test ./... runs all tests. Using && ensures the next command runs only if the previous succeeds.

2. Step 2: Confirm build runs only after tests pass

   go build runs last, so it only executes if tests pass, ensuring a clean build.

3. Final Answer:

   go fmt ./... && go test ./... && go build -> Option D

4. Quick Check:

   Format, test, then build with && [OK]

Hint: Use && to chain commands; build last after tests pass [OK]

Common Mistakes:

• Building before testing
• Running tests after build
• Not chaining commands to stop on failure