Package scope rules in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a package named main.

Go

package [1]

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

Amain

Bfmt

Cpackage

Dfunc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'fmt' as package name instead of 'main'.

Writing 'package' as the package name.

Using 'func' which is a keyword, not a package name.

The package name main is used for executable programs in Go.

2fill in blank

medium

Complete the code to import the fmt package.

Go

import [1]"fmt"

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

A"

B(

C{

D[

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes directly after import without parentheses.

Using curly braces or square brackets instead of parentheses.

In Go, multiple imports are enclosed in parentheses ( ). Even for one import, parentheses are used for grouping.

3fill in blank

hard

Fix the error in the variable declaration to make it package scoped.

Go

var [1] = 42

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

AmyVar

Bmy_var

C_myVar

DMyVar

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase variable names which are not exported.

Using underscores which do not affect scope.

In Go, identifiers starting with a capital letter are exported and have package scope accessible outside the package.

4fill in blank

hard

Fill both blanks to define a package-level function and call it inside main.

Go

func [1]() {
	println("Hello from package scope")
}

func main() {
	[2]()
}

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

AGreet

Bgreet

CPrint

Dprint

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase function names which are not exported.

Calling a different function name than defined.

Functions starting with a capital letter are exported and package scoped. The same name is used to define and call the function.

5fill in blank

hard

Fill all three blanks to create a package-level constant, a variable, and a function that uses them.

Go

const [1] = "GoLang"

var [2] = 2024

func [3]() string {
	return [1] + " " + string([2])
}

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

AVersion

Bversion

CGetVersion

DgetVersion

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase names which are not exported.

Mismatching names between declaration and usage.

Constants and variables starting with capital letters are exported. The function name starting with a capital letter is also exported and can access these package-level identifiers.

Practice

1. In Go, what does it mean if a variable name starts with a lowercase letter inside a package?

easy

A. It is private to the package and cannot be accessed from other packages.

B. It is accessible from any package.

C. It is a constant value.

D. It is a global variable accessible everywhere.

Solution

1. Step 1: Understand Go naming conventions

   In Go, identifiers starting with a lowercase letter are unexported, meaning they are private to the package.

2. Step 2: Apply package scope rule

   Such variables cannot be accessed from outside their package, ensuring encapsulation.

3. Final Answer:

   It is private to the package and cannot be accessed from other packages. -> Option A

4. Quick Check:

   Lowercase start = private [OK]

Hint: Lowercase start means private inside package [OK]

Common Mistakes:

• Thinking lowercase variables are accessible outside package
• Confusing lowercase with constants
• Assuming lowercase means global

2. Which of the following is the correct way to declare an exported function in a Go package?

easy

A. func MyFunction() {}

B. func myFunction() {}

C. func _MyFunction() {}

D. func my_function() {}

Solution

1. Step 1: Recall Go export rules

   Functions starting with an uppercase letter are exported and accessible outside the package.

2. Step 2: Check each option

   func MyFunction() {} starts with uppercase 'M', so it is exported. Others start with lowercase or invalid characters.

3. Final Answer:

   func MyFunction() {} -> Option A

4. Quick Check:

   Uppercase start = exported function [OK]

Hint: Function name uppercase means exported [OK]

Common Mistakes:

• Using lowercase to export functions
• Using underscores which are allowed but don't affect export
• Confusing export with naming style

3. Given the following Go code in package 'mathops':

package mathops

var result = 10

func Result() int {
    return result
}

What will happen if another package tries to access mathops.result?

medium

A. It will access the value 10 successfully.

B. It will cause a compile-time error due to unexported variable.

C. It will cause a runtime panic.

D. It will access a zero value.

Solution

1. Step 1: Identify variable scope

   The variable 'result' starts with lowercase, so it is unexported and private to the package.

2. Step 2: Understand access from other packages

   Accessing 'mathops.result' from outside the package is not allowed and causes a compile-time error.

3. Final Answer:

   It will cause a compile-time error due to unexported variable. -> Option B

4. Quick Check:

   Lowercase variable = inaccessible outside package [OK]

Hint: Lowercase vars cause compile error if accessed outside [OK]

Common Mistakes:

• Assuming private variables can be accessed
• Thinking runtime panic occurs instead of compile error
• Confusing function export with variable export

4. Consider this Go code snippet inside a package:

package example

func calculate() int {
    return 42
}

func Calculate() int {
    return calculate()
}

What is the main reason for defining both calculate and Calculate functions?

medium

A. To confuse the compiler with similar names.

B. To create two independent exported functions.

C. To cause a compile-time error due to duplicate names.

D. To have a private helper function and a public wrapper function.

Solution

1. Step 1: Analyze function names and scope

   'calculate' starts lowercase, so it is private to the package; 'Calculate' starts uppercase, so it is exported.

2. Step 2: Understand design pattern

   This pattern allows internal logic in 'calculate' while exposing a public function 'Calculate' that calls it.

3. Final Answer:

   To have a private helper function and a public wrapper function. -> Option D

4. Quick Check:

   Lowercase private + uppercase public wrapper [OK]

Hint: Use lowercase for private helpers, uppercase for public API [OK]

Common Mistakes:

• Thinking both functions are exported
• Expecting compile error from similar names
• Assuming no reason for two functions

5. You want to create a Go package that exposes only a function GetData but keeps the data source variable private. Which code snippet correctly implements this using package scope rules?

hard

A. package data

var datasource = "secret"

func getData() string {
return datasource
}

B. package data

var DataSource = "secret"

func GetData() string {
return DataSource
}

C. package data

var datasource = "secret"

func GetData() string {
return datasource
}

D. package data

var DataSource = "secret"

func getData() string {
return DataSource
}

Solution

1. Step 1: Identify private data variable

   The data source variable should start lowercase to be private to the package, so 'datasource' is correct.

2. Step 2: Identify exported function

   The function 'GetData' starts uppercase, so it is exported and accessible outside the package.

3. Step 3: Verify function returns private variable

   The function returns the private variable, exposing data safely.

4. Final Answer:

   package data var datasource = "secret" func GetData() string { return datasource } -> Option C

5. Quick Check:

   Lowercase var + uppercase func = private data, public access [OK]

Hint: Private vars lowercase, public funcs uppercase [OK]

Common Mistakes:

• Making data variable exported by uppercase
• Making function unexported by lowercase
• Returning unexported function instead of exported