Function parameters in Go - Deep Dive

Overview - Function parameters

What is it?

Function parameters are the values you give to a function when you call it. They act like placeholders inside the function, letting it use the information you provide. In Go, you define parameters inside the parentheses after the function name. These parameters help the function work with different data each time you use it.

Why it matters

Without function parameters, functions would always do the same thing and could not handle different inputs. This would make programs less flexible and more repetitive. Parameters let you write one function that can work with many different values, saving time and making your code easier to understand and maintain.

Where it fits

Before learning function parameters, you should know what functions are and how to call them. After understanding parameters, you can learn about return values, variadic functions, and pointers to pass data efficiently.

Mental Model

Core Idea

Function parameters are like labeled boxes that hold the input values a function needs to do its job.

Think of it like...

Imagine a recipe that asks you to add specific ingredients. The ingredients are the parameters you provide to the recipe (function) so it can make the dish (result).

FunctionName(param1 type, param2 type) {
  // use param1 and param2 inside
}

Call example:
FunctionName(value1, value2)

Build-Up - 7 Steps

1

Foundation

What are function parameters

Concept: Introduce the idea that functions can take inputs called parameters.

In Go, a function can have parameters listed inside parentheses after its name. Each parameter has a name and a type. For example: func greet(name string) { fmt.Println("Hello,", name) } Here, 'name' is a parameter of type string.

Result

You can call greet("Alice") and it will print: Hello, Alice

Understanding parameters lets you make functions that work with different inputs instead of repeating code.

2

Foundation

Parameter types and naming

Concept: Parameters must have names and types to tell Go what kind of data to expect.

Each parameter needs a name to use inside the function and a type to tell Go what data it holds. For example: func add(a int, b int) int { return a + b } 'a' and 'b' are parameter names, both of type int.

Result

Calling add(3, 4) returns 7

Knowing parameter types helps Go check your code for errors and understand how to handle the data.

3

Intermediate

Multiple parameters and shared types

🤔Before reading on: Do you think you must write the type for each parameter separately or can you share types for parameters of the same kind? Commit to your answer.

Concept: You can list multiple parameters with the same type by writing the type once after their names.

Instead of writing 'a int, b int', you can write 'a, b int' to save space: func multiply(x, y int) int { return x * y } This means both x and y are ints.

Result

Calling multiply(2, 5) returns 10

Sharing types for parameters of the same kind makes your code cleaner and easier to read.

4

Intermediate

Passing parameters by value

🤔Before reading on: When you pass a parameter to a function, do you think the function can change the original variable outside? Commit to your answer.

Concept: By default, Go passes parameters by value, meaning the function gets a copy and cannot change the original variable.

Example: func changeNumber(num int) { num = 10 } x := 5 changeNumber(x) fmt.Println(x) // prints 5, not 10 The function changed its copy, not x itself.

Result

The original variable remains unchanged after the function call.

Understanding pass-by-value prevents confusion about why changes inside functions don't affect original data.

5

Intermediate

Using pointers to modify parameters

🤔Before reading on: Can you guess how to let a function change the original variable? Commit to your answer.

Concept: You can pass a pointer (address) to a variable so the function can modify the original data.

Example: func changeNumber(num *int) { *num = 10 } x := 5 changeNumber(&x) fmt.Println(x) // prints 10 The function receives the address of x and changes the value at that address.

Result

The original variable is changed by the function.

Knowing how to use pointers with parameters lets you write functions that can update data outside their scope.

6

Advanced

Variadic parameters for flexible inputs

🤔Before reading on: Do you think a function can accept any number of parameters of the same type? Commit to your answer.

Concept: Go allows functions to accept a variable number of parameters of the same type using '...' syntax.

Example: func sum(numbers ...int) int { total := 0 for _, n := range numbers { total += n } return total } sum(1, 2, 3) returns 6 sum(4, 5) returns 9

Result

Functions can handle flexible numbers of inputs easily.

Variadic parameters make functions more adaptable without needing multiple overloads.

7

Expert

Parameter evaluation order and side effects

🤔Before reading on: Do you think Go evaluates function parameters left-to-right or right-to-left? Commit to your answer.

Concept: Go evaluates function parameters from left to right before calling the function, which matters if parameters have side effects.

Example: func printAndReturn(x int) int { fmt.Println(x) return x } func main() { a := 1 b := 2 sum(printAndReturn(a), printAndReturn(b)) } Output: 1 2 Parameters are evaluated left to right.

Result

Knowing evaluation order helps avoid bugs when parameters change state or depend on each other.

Understanding evaluation order prevents subtle bugs in complex function calls with side effects.

Under the Hood

When a function is called, Go creates new memory space for its parameters and copies the values passed in. For value parameters, this is a copy of the data. For pointer parameters, the address is copied, allowing access to the original data. The function uses these parameter values inside its own scope. After the function finishes, this memory is discarded. Variadic parameters are handled as slices internally, allowing flexible argument counts.

Why designed this way?

Go uses pass-by-value to keep functions safe and predictable, avoiding unexpected changes to data. Pointers provide controlled access to modify data when needed. The left-to-right evaluation order was chosen for consistency and to match common expectations in programming. Variadic parameters simplify function design without complex overloading.

Caller Stack Frame
┌─────────────────────┐
│ Arguments (values)   │
│ or pointers          │
└─────────┬───────────┘
          │
          ▼
Function Stack Frame
┌─────────────────────┐
│ Parameters (copies)  │
│ or pointers         │
│ Function body uses   │
└─────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does changing a parameter inside a function always change the original variable? Commit to yes or no.

Common Belief: Changing a parameter inside a function will change the original variable passed in.

Reality: By default, parameters are passed by value, so changes inside the function do not affect the original variable unless you use pointers.

Why it matters: Assuming parameters always change originals leads to bugs where data is unexpectedly unchanged after function calls.

Quick: Can a Go function have parameters without types? Commit to yes or no.

Common Belief: You can define function parameters without specifying their types if the names are clear.

Reality: In Go, every parameter must have a type; omitting types causes a compile error.

Why it matters: Not specifying types leads to code that won't compile, blocking progress and causing confusion.

Quick: Are function parameters evaluated right-to-left in Go? Commit to yes or no.

Common Belief: Function parameters are evaluated from right to left, like in some other languages.

Reality: Go evaluates function parameters from left to right, which affects the order of side effects.

Why it matters: Wrong assumptions about evaluation order can cause unexpected behavior in functions with side effects.

Quick: Does using variadic parameters mean you can pass any type of arguments? Commit to yes or no.

Common Belief: Variadic parameters let you pass any types of arguments to a function.

Reality: Variadic parameters accept any number of arguments, but all must be of the same specified type.

Why it matters: Misusing variadic parameters can cause type errors and confusion about what inputs are allowed.

Expert Zone

1

Named parameters in Go are always positional; Go does not support named arguments at call time, which affects readability in functions with many parameters.

2

Variadic parameters are implemented as slices internally, so passing a slice with '...' syntax allows flexible reuse of existing data structures.

3

Passing large structs by value can be inefficient; experts often use pointers to avoid copying large data when performance matters.

When NOT to use

Avoid using pointers as parameters when you do not want the function to modify the original data; instead, use value parameters for safety. For functions requiring many optional parameters, consider using struct types or functional options patterns instead of long parameter lists.

Production Patterns

In production Go code, functions often use pointers for large data or to modify state, variadic parameters for flexible APIs like logging, and carefully order parameters for clarity. Functions with many parameters are refactored into smaller functions or use configuration structs to improve maintainability.

Connections

Pointers

Builds-on

Understanding function parameters deeply connects to pointers because pointers allow functions to modify original data, making parameter passing more powerful.

API Design

Builds-on

Good use of function parameters is essential for designing clear and flexible APIs, influencing how users interact with your code.

Mathematics - Functions

Same pattern

Just like in math where functions take inputs and produce outputs, programming function parameters represent inputs that determine the function's behavior.

Common Pitfalls

#1 Expecting a function to change the original variable without using pointers.

Wrong approach:

func reset(x int) {
x = 0
}

value := 5
reset(value)
fmt.Println(value) // prints 5, not 0

Correct approach:

func reset(x *int) {
*x = 0
}

value := 5
reset(&value)
fmt.Println(value) // prints 0

Root cause:

Misunderstanding that parameters are passed by value, so changes inside the function do not affect the original variable.

#2 Defining parameters without types.

Wrong approach:

func add(a, b) int {
return a + b
}

Correct approach:

func add(a, b int) int {
return a + b
}

Root cause:

Not knowing that Go requires explicit types for all parameters.

#3 Passing a slice directly to a variadic parameter without '...'.

Wrong approach:

func printAll(nums ...int) {
for _, n := range nums {
fmt.Println(n)
}
}

numbers := []int{1, 2, 3}
printAll(numbers) // compile error

Correct approach:

printAll(numbers...) // correct usage

Root cause:

Not understanding that slices must be expanded with '...' to match variadic parameters.

Key Takeaways

Function parameters let you give inputs to functions so they can work with different data each time.

In Go, every parameter must have a name and a type, and multiple parameters of the same type can share the type declaration.

Parameters are passed by value, so functions get copies and cannot change original variables unless you use pointers.

Variadic parameters allow functions to accept any number of arguments of the same type, increasing flexibility.

Understanding parameter evaluation order and pointer usage helps avoid subtle bugs and write efficient, clear Go code.