Variables and Types Exercises

Master Go’s variable declaration syntax, type system, and type conversions through these hands-on exercises.

Basic Data Types

Get familiar with Go’s fundamental data types and literals.

Print Literals

Objective: Practice using different literal typesPrint various values using int, float, string, and bool literals.Key Concepts:

Integer literals
Float literals
String literals
Boolean literals
Literal syntax

Approach:

fmt.Println(42)           // int literal
fmt.Println(3.14)         // float literal
fmt.Println("Hello")      // string literal
fmt.Println(true)         // bool literal

Print Hexadecimal Numbers

Objective: Learn alternative number representationsPrint numbers using hexadecimal notation.Key Concepts:

Hexadecimal literals (0x prefix)
Number base representations
Printf formatting

Approach:

fmt.Printf("%x\n", 255)   // Print as hex
fmt.Println(0xFF)         // Hex literal (equals 255)

Variable Declarations

Practice the standard variable declaration syntax with the var keyword.

Declare Int Variables

Objective: Declare and use integer variablesDeclare int variables using the var keyword.Approach:

var age int
age = 25
fmt.Println(age)

Declare Bool Variables

Objective: Work with boolean variablesDeclare and initialize boolean variables.Approach:

var isActive bool
isActive = true
fmt.Println(isActive)

Declare Float64 Variables

Objective: Handle floating-point numbersDeclare and use float64 variables for decimal numbers.Approach:

var price float64
price = 19.99
fmt.Println(price)

Declare String Variables

Objective: Work with text dataDeclare and manipulate string variables.Approach:

var name string
name = "Alice"
fmt.Println(name)

Undeclarable Types

Objective: Understand what cannot be declared with varTry to declare variables with invalid type specifications.Key Concepts:

Valid vs invalid type names
Compiler error messages
Type system rules

Approach: Attempt declarations that will fail to understand the type system better.

Declare with Bits

Objective: Learn about sized integer typesUse specific integer types like int8, int16, int32, int64.Approach:

var small int8 = 127
var medium int16 = 32767
var large int64 = 9223372036854775807

Multiple Declarations

Objective: Declare multiple variables efficientlyLearn different ways to declare multiple variables.Approach:

// Method 1
var x, y, z int

// Method 2
var (
    name string
    age  int
    active bool
)

Package-Level Variables

Objective: Understand package scopeDeclare variables outside of functions at the package level.Key Concepts:

Package-level scope
Initialization order
Global state

Approach: Declare variables outside main() and access them within functions.

Short Declaration

Master the := operator for concise variable declarations.

Short Declaration Syntax

Objective: Use the := operatorPractice the short declaration operator for local variables.Key Concepts:

Type inference
Local scope only
Simultaneous declaration and assignment

Approach:

name := "Bob"
age := 30
price := 19.99

Multiple Short Declarations

Objective: Declare multiple variables with :=Declare and initialize multiple variables in one statement.Approach:

name, age, city := "Alice", 25, "NYC"

Short Declaration with Expressions

Objective: Use expressions in short declarationsAssign the result of expressions to variables using :=.Approach:

sum := 10 + 20
product := 5 * 4
length := len("Hello")

Discard with Underscore

Objective: Use the blank identifierDiscard unwanted return values using _.Key Concepts:

Blank identifier _
Discarding values
Multiple return values

Approach:

_, err := someFunction()
value, _ := anotherFunction()

Redeclaration

Objective: Understand redeclaration rulesLearn when you can redeclare variables with :=.Key Concepts:

At least one new variable required
Redeclaration vs reassignment
Scope rules

Approach:

x := 10
x, y := 20, 30  // OK: y is new
// x := 30      // Error: no new variables

Assignment and Type Conversion

Learn to work with variable assignments and convert between types.

Variable Assignment

Objective: Reassign variable valuesPractice assigning new values to existing variables.Approach:

color := "red"
color = "blue"  // Assignment (not declaration)

Assignment with Expressions

Objective: Use expressions in assignmentsAssign calculated values to variables.Approach:

x := 10
x = x + 5
x = x * 2

Calculate Rectangle Perimeter

Objective: Apply variables to solve a problemCalculate and print the perimeter of a rectangle.Approach:

Declare width and height
Calculate perimeter: 2 * (width + height)
Print the result

Multiple Assignment

Objective: Assign to multiple variables simultaneouslyUse parallel assignment for multiple variables.Approach:

x, y := 1, 2
x, y = y, x  // Swap values

Swapper

Objective: Swap variable valuesExchange the values of two variables.Approach:

a, b := 5, 10
a, b = b, a
fmt.Println(a, b)  // 10 5

Type Conversion Basics

Objective: Convert between numeric typesPractice explicit type conversion in Go.Key Concepts:

Explicit conversion required
No implicit conversions
Syntax: Type(value)

Approach:

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

Fix Type Conversion Errors

Objective: Debug type mismatch issuesFix programs with type conversion errors.Approach:

Identify type mismatches
Add explicit conversions
Ensure conversions are safe

Example fixes:

// Error: cannot use int as float64
var x float64 = 10  // Wrong

// Fixed:
var x float64 = float64(10)

Command-Line Arguments

Work with command-line input using os.Args.

Count Arguments

Objective: Access command-line argumentsCount and print the number of arguments passed to your program.Key Concepts:

os.Args slice
Argument indexing
Program name in Args[0]

Approach:

import "os"

fmt.Println("Argument count:", len(os.Args))

Print the Path

Objective: Access the program pathPrint the path of the running program.Approach:

fmt.Println("Program path:", os.Args[0])

Print Your Name

Objective: Use command-line argumentsAccept and print a name from command-line arguments.Approach:

Check if argument exists
Access os.Args[1]
Print the value

Greet Multiple People

Objective: Process multiple argumentsGreet each person passed as a command-line argument.Approach: Loop through os.Args[1:] and greet each person.

Projects

Exercises

Variables and Types Exercises

Basic Data Types

Variable Declarations

Short Declaration

Assignment and Type Conversion

Command-Line Arguments

Next Steps

Control Flow

Data Structures

Build docs developers (and LLMs) love

Projects

Exercises

​Basic Data Types

​Variable Declarations

​Short Declaration

​Assignment and Type Conversion

​Command-Line Arguments

​Next Steps

Control Flow

Data Structures

Build docs developers (and LLMs) love

Basic Data Types

Variable Declarations

Short Declaration

Assignment and Type Conversion

Command-Line Arguments

Next Steps