{"id":165,"date":"2026-07-07T20:29:23","date_gmt":"2026-07-07T20:29:23","guid":{"rendered":"https:\/\/kindsonthegenius.com\/go\/2026\/07\/07\/06-go-functions\/"},"modified":"2026-07-07T20:38:10","modified_gmt":"2026-07-07T20:38:10","slug":"06-go-functions","status":"publish","type":"post","link":"https:\/\/kindsonthegenius.com\/go\/2026\/07\/07\/06-go-functions\/","title":{"rendered":"Go Functions \u2013 Declarations, Returns, and defer"},"content":{"rendered":"

<\/p>\n

\n

Updated July 2, 2026.<\/strong> Refreshed for Go 1.22+ and current SEO best practices.<\/p>\n<\/div>\n

In this lesson we cover the Go functions tutorial<\/strong> fundamentals \u2014 how to declare functions, return multiple values, use named return parameters, accept a variable number of arguments, and schedule cleanup with defer<\/code>. If you completed Lesson 5 \u2013 Control Flow<\/a>, you can branch and loop; functions let you package that logic into reusable, testable units.<\/p>\n

Prerequisites:<\/strong> Lessons 1\u20135, especially Variables and Types<\/a> and Control Flow<\/a>. Estimated time:<\/strong> 45\u201355 minutes.<\/p>\n

1. Function Declarations<\/h4>\n

A function is declared with the func<\/code> keyword, a name, parameters in parentheses, and an optional return type:<\/p>\n

package main\n\nimport \"fmt\"\n\nfunc greet(name string) {\n\tfmt.Printf(\"Hello, %s!\\n\", name)\n}\n\nfunc add(a int, b int) int {\n\treturn a + b\n}\n\nfunc main() {\n\tgreet(\"Kindson\")\n\tfmt.Println(\"3 + 4 =\", add(3, 4))\n}\n<\/code><\/pre>\n
When consecutive parameters share the same type, you can write a, b int<\/code> instead of a int, b int<\/code>. Functions are first-class values in Go \u2014 you can assign them to variables and pass them as arguments \u2014 but start with named functions at package level while learning. Names starting with an uppercase letter are exported (visible outside the package); lowercase names are private.<\/p>\n
2. Multiple Return Values<\/h4>\n
Go functions can return more than one value. This pattern is central to error handling \u2014 a result plus an error<\/code>:<\/p>\n
package main\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\nfunc divide(a, b float64) (float64, error) {\n\tif b == 0 {\n\t\treturn 0, errors.New(\"division by zero\")\n\t}\n\treturn a \/ b, nil\n}\n\nfunc main() {\n\tresult, err := divide(10, 2)\n\tif err != nil {\n\t\tfmt.Println(\"Error:\", err)\n\t\treturn\n\t}\n\tfmt.Println(\"Result:\", result)\n}\n<\/code><\/pre>\n
Callers must handle every return value or explicitly discard with _<\/code>. Ignoring an error return is allowed by the compiler but is poor practice in production code. This explicit style differs from exceptions in languages like Java or Python \u2014 errors are values you check at the call site.<\/p>\n
3. Named Return Values<\/h4>\n
You can name return parameters in the function signature. They act as variables inside the function, and a bare return<\/code> statement returns their current values:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc rectangleStats(width, height float64) (area, perimeter float64) {\n\tarea = width * height\n\tperimeter = 2 * (width + height)\n\treturn \/\/ naked return \u2014 returns area and perimeter\n}\n\nfunc main() {\n\ta, p := rectangleStats(5, 3)\n\tfmt.Printf(\"Area: %.1f, Perimeter: %.1f\\n\", a, p)\n}\n<\/code><\/pre>\n
Named returns improve readability in short functions with obvious results, but overuse in long functions can obscure what is being returned. The Go community often reserves naked returns for very small functions \u2014 defer and error cleanup patterns are a common exception you will see in production code.<\/p>\n
4. Variadic Functions<\/h4>\n
A variadic<\/strong> function accepts zero or more arguments of a specified type. The parameter is declared with an ellipsis before the type and arrives inside the function as a slice:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc sum(numbers ...int) int {\n\ttotal := 0\n\tfor _, n := range numbers {\n\t\ttotal += n\n\t}\n\treturn total\n}\n\nfunc main() {\n\tfmt.Println(sum(1, 2, 3))       \/\/ 6\n\tfmt.Println(sum(10, 20))        \/\/ 30\n\tfmt.Println(sum())              \/\/ 0\n\n\tvals := []int{4, 5, 6}\n\tfmt.Println(sum(vals...))       \/\/ spread a slice\n}\n<\/code><\/pre>\n
Only the last parameter in a function can be variadic. Built-in examples include fmt.Println<\/code> and append<\/code>. Use variadic functions when the number of arguments is naturally variable \u2014 logging, formatting, or aggregating values \u2014 rather than forcing callers to always build a slice manually.<\/p>\n
5. Introduction to defer<\/h4>\n
The defer<\/code> statement schedules a function call to run when the surrounding function returns \u2014 regardless of how it returns (normal return, early return, or panic):<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc process() {\n\tfmt.Println(\"Start\")\n\tdefer fmt.Println(\"Deferred cleanup\")\n\tfmt.Println(\"Middle\")\n\tfmt.Println(\"End\")\n}\n\nfunc main() {\n\tprocess()\n}\n\/\/ Output: Start, Middle, End, Deferred cleanup\n<\/code><\/pre>\n
Deferred calls run in LIFO<\/strong> order (last deferred, first executed). Typical uses: closing files, unlocking mutexes, and rolling back transactions. Pair defer file.Close()<\/code> immediately after a successful os.Open<\/code> so cleanup is never forgotten on an error path \u2014 a pattern you will use constantly in Go.<\/p>\n
6. Putting Functions Together<\/h4>\n
Real Go code combines these features. Here is a small utility that demonstrates parameters, multiple returns, and defer:<\/p>\n
package main\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n)\n\nfunc formatLines(prefix string, lines ...string) (string, int) {\n\tdefer func() { fmt.Println(\"formatLines finished\") }()\n\n\tvar builder strings.Builder\n\tfor _, line := range lines {\n\t\tbuilder.WriteString(prefix)\n\t\tbuilder.WriteString(line)\n\t\tbuilder.WriteString(\"\\n\")\n\t}\n\treturn builder.String(), len(lines)\n}\n\nfunc main() {\n\toutput, count := formatLines(\"> \", \"First\", \"Second\", \"Third\")\n\tfmt.Print(output)\n\tfmt.Println(\"Lines formatted:\", count)\n}\n<\/code><\/pre>\n
Compare this to organizing code in Python<\/a> with def<\/code> \u2014 Go requires explicit types, supports multiple returns natively, and uses defer<\/code> instead of try\/finally<\/code> for cleanup. Both approaches encourage small, focused functions; Go’s type system catches mismatches at compile time.<\/p>\n
7. Quick Reference<\/h4>\n\n\n\n\n\n\n\n\n\n
Feature<\/th>\nSyntax<\/th>\nTypical Use<\/th>\n<\/tr>\n<\/thead>\n
Basic function<\/td>\nfunc name(p T) R<\/code><\/td>\nReusable logic with typed input\/output<\/td>\n<\/tr>\n
Multiple returns<\/td>\nfunc f() (T, error)<\/code><\/td>\nResult plus error checking<\/td>\n<\/tr>\n
Named returns<\/td>\nfunc f() (x int, err error)<\/code><\/td>\nShort functions, naked return<\/td>\n<\/tr>\n
Variadic<\/td>\nfunc f(args ...T)<\/code><\/td>\nVariable argument count<\/td>\n<\/tr>\n
defer<\/td>\ndefer cleanup()<\/code><\/td>\nRun on function exit<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Exported functions (capitalized names) form the public API of a package. Keep functions small enough to read in one screen \u2014 if a function grows past roughly forty lines, consider splitting it.<\/p>\n
8. Next Steps<\/h4>\n
You now understand the go functions tutorial<\/strong> core: declarations, multiple return values, named returns, variadic parameters, and defer<\/code>. Upcoming lessons cover arrays, slices, maps, and structs \u2014 data structures that functions operate on at scale.<\/p>\n
Continue the series: Lesson 5 \u2013 Control Flow<\/a> \u00b7 Lesson 4 \u2013 Variables and Types<\/a><\/p>\n
Browse all tutorials: Content Directory<\/a> \u00b7 Go Programming Hub<\/a><\/p>\n
Frequently Asked Questions<\/h4>\n
Can Go functions return multiple values?<\/strong>
\nYes. List return types in parentheses: func f() (int, error)<\/code>. Callers receive all values: result, err := f()<\/code>.<\/p>\n
What does defer do in Go?<\/strong>
\ndefer<\/code> postpones a function call until the surrounding function returns. Deferred calls run in reverse order (LIFO). It is ideal for cleanup such as closing files or releasing locks.<\/p>\n
What is a variadic function?<\/strong>
\nA variadic function accepts any number of arguments of one type using ...<\/code> syntax, for example func sum(nums ...int)<\/code>. Inside the function, the parameter is a slice.<\/p>\n
<\/p>\n