{"id":1065,"date":"2026-08-16T21:40:04","date_gmt":"2026-08-16T21:40:04","guid":{"rendered":"https:\/\/www.devopsschool.com\/tutorials\/?p=1065"},"modified":"2026-08-16T21:44:48","modified_gmt":"2026-08-16T21:44:48","slug":"go-tutorials-go-error-management-easy-complete-tutorial","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/tutorials\/go-tutorials-go-error-management-easy-complete-tutorial\/","title":{"rendered":"Go Tutorials – Go Error Management \u2014 Easy, Complete Tutorial"},"content":{"rendered":"\n

The most important rule to remember is:<\/p>\n\n\n\n

\n

In Go, errors are normal values. A function usually returns an error<\/code>, and the caller decides what to do with it.<\/strong><\/p>\n<\/blockquote>\n\n\n\n

The basic flow is:<\/p>\n\n\n\n

flowchart LR\n    A[Call function] --> B{Problem?}\n    B -- No --> C[Return result + nil]\n    B -- Yes --> D[Return zero value + error]\n    D --> E{Caller checks err}\n    E -- err == nil --> F[Continue]\n    E -- err != nil --> G[Handle error]<\/code><\/pre>\n\n\n\n
For example:<\/p>\n\n\n\n
result, err := doSomething()\n\nif err != nil {\n    \/\/ handle the problem\n}\n\nfmt.Println(result)<\/code><\/pre>\n\n\n\n
\n\n\n\n
1. Built-in \/ Standard Error Tools<\/h1>\n\n\n\n
First, one terminology correction that will make Go easier to understand.<\/p>\n\n\n\n
Go has:<\/p>\n\n\n\n
Thing<\/th>Type<\/th>Purpose<\/th><\/tr><\/thead>
error<\/code><\/td>Built-in interface<\/td>Represents an error<\/td><\/tr>
errors<\/code><\/td>Standard library package<\/td>Creates\/checks errors<\/td><\/tr>
fmt<\/code><\/td>Standard library package<\/td>Creates formatted errors<\/td><\/tr>
panic<\/code><\/td>Built-in function<\/td>Stops normal execution<\/td><\/tr>
recover<\/code><\/td>Built-in function<\/td>Catches a panic<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
So:<\/p>\n\n\n\n
error\npanic()\nrecover()<\/code><\/pre>\n\n\n\n
are built into the language.<\/p>\n\n\n\n
But:<\/p>\n\n\n\n
import \"errors\"\nimport \"fmt\"<\/code><\/pre>\n\n\n\n
are packages from Go’s standard library<\/strong>.<\/p>\n\n\n\n
What?<\/h2>\n\n\n\n
These are the main tools used for error management.<\/p>\n\n\n\n
Why?<\/h2>\n\n\n\n
Because different situations need different tools:<\/p>\n\n\n\n
Simple error                 \u2192 errors.New()\nError containing information \u2192 fmt.Errorf()\nCheck returned error         \u2192 if err != nil\nUnexpected fatal condition   \u2192 panic()\nCatch panic                  \u2192 recover()<\/code><\/pre>\n\n\n\n
When?<\/h2>\n\n\n\n
Most application code will mainly use:<\/p>\n\n\n\n
if err != nil<\/code><\/pre>\n\n\n\n
along with:<\/p>\n\n\n\n
errors.New(...)\nfmt.Errorf(...)<\/code><\/pre>\n\n\n\n
How \/ Where?<\/h2>\n\n\n\n
Here is a complete example showing the main tools.<\/p>\n\n\n\n
Complete example<\/h3>\n\n\n\n
package main\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\nfunc divide(a, b int) (int, error) {\n\n\t\/\/ errors.New creates a simple error.\n\tif b == 0 {\n\t\treturn 0, errors.New(\"cannot divide by zero\")\n\t}\n\n\treturn a \/ b, nil\n}\n\nfunc main() {\n\n\tresult, err := divide(10, 0)\n\n\t\/\/ Always check the returned error.\n\tif err != nil {\n\t\tfmt.Println(\"Error:\", err)\n\t\treturn\n\t}\n\n\tfmt.Println(\"Result:\", result)\n}<\/code><\/pre>\n\n\n\n
Run:<\/p>\n\n\n\n
go run .<\/code><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Error: cannot divide by zero<\/code><\/pre>\n\n\n\n
Remember<\/h3>\n\n\n\n
error       \u2192 type\/interface\nerrors      \u2192 package\nfmt         \u2192 package\npanic       \u2192 built-in function\nrecover     \u2192 built-in function<\/code><\/pre>\n\n\n\n
\n\n\n\n
2. The error<\/code> Interface<\/h1>\n\n\n\n
This is the most important concept<\/strong> behind Go errors.<\/p>\n\n\n\n
What?<\/h2>\n\n\n\n
error<\/code> is a built-in interface.<\/p>\n\n\n\n
Conceptually, Go defines it like this:<\/p>\n\n\n\n
type error interface {\n\tError() string\n}<\/code><\/pre>\n\n\n\n
That means:<\/p>\n\n\n\n
\n
Anything having a method named Error() string<\/code> can be an error.<\/p>\n<\/blockquote>\n\n\n\n
Notice the capital E<\/code>:<\/p>\n\n\n\n
Error()<\/code><\/pre>\n\n\n\n
Why?<\/h2>\n\n\n\n
It allows us to create our own custom error types.<\/p>\n\n\n\n
When?<\/h2>\n\n\n\n
Use custom errors when the error should contain additional information.<\/p>\n\n\n\n
For example:<\/p>\n\n\n\n
user ID\nfilename\nHTTP status\ndatabase information\nvalidation information<\/code><\/pre>\n\n\n\n
How?<\/h2>\n\n\n\n
Create a type and give it:<\/p>\n\n\n\n
Error() string<\/code><\/pre>\n\n\n\n
Where?<\/h2>\n\n\n\n
Usually inside the package responsible for that particular operation.<\/p>\n\n\n\n
Complete example<\/h3>\n\n\n\n
package main\n\nimport \"fmt\"\n\n\/\/ Create our own error type.\ntype AgeError struct {\n\tAge int\n}\n\n\/\/ Because AgeError has:\n\/\/\n\/\/ Error() string\n\/\/\n\/\/ it satisfies Go's built-in error interface.\nfunc (e AgeError) Error() string {\n\treturn fmt.Sprintf(\"age %d is too young\", e.Age)\n}\n\nfunc checkAge(age int) error {\n\n\tif age < 18 {\n\t\treturn AgeError{Age: age}\n\t}\n\n\treturn nil\n}\n\nfunc main() {\n\n\terr := checkAge(15)\n\n\tif err != nil {\n\t\tfmt.Println(\"Error:\", err)\n\t\treturn\n\t}\n\n\tfmt.Println(\"Age accepted\")\n}<\/code><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Error: age 15 is too young<\/code><\/pre>\n\n\n\n
The important part is:<\/p>\n\n\n\n
func (e AgeError) Error() string<\/code><\/pre>\n\n\n\n
Because of this method:<\/p>\n\n\n\n
AgeError\n   \u2502\n   \u2502 has Error() string\n   \u25bc\nsatisfies\n   \u2502\n   \u25bc\nerror interface<\/code><\/pre>\n\n\n\n
flowchart TD\n    A[AgeError struct] --> B[\"Error() string method\"]\n    B --> C[implements error interface]\n    C --> D[Can be returned as error]<\/code><\/pre>\n\n\n\n
You do not<\/strong> write:<\/p>\n\n\n\n
implements error<\/code><\/pre>\n\n\n\n
Go automatically recognizes it.<\/p>\n\n\n\n
Remember<\/h3>\n\n\n\n
type error interface {\n    Error() string\n}<\/code><\/pre>\n\n\n\n
is the heart of Go error management.<\/p>\n\n\n\n
\n\n\n\n
3. The errors<\/code> Package<\/h1>\n\n\n\n
Now we know that error<\/code> is an interface.<\/p>\n\n\n\n
The next question is:<\/p>\n\n\n\n
\n
How do I easily create an error?<\/p>\n<\/blockquote>\n\n\n\n
One common answer is the errors<\/code> package.<\/p>\n\n\n\n
import \"errors\"<\/code><\/pre>\n\n\n\n
What?<\/h2>\n\n\n\n
errors<\/code> is a standard Go package for creating and working with errors.<\/p>\n\n\n\n
The simplest function is:<\/p>\n\n\n\n
errors.New()<\/code><\/pre>\n\n\n\n
Example:<\/p>\n\n\n\n
errors.New(\"user not found\")<\/code><\/pre>\n\n\n\n
Why?<\/h2>\n\n\n\n
Because creating a custom struct for every simple error would be unnecessary.<\/p>\n\n\n\n
Instead of creating:<\/p>\n\n\n\n
type MyError struct {\n\t...\n}<\/code><\/pre>\n\n\n\n
you can simply write:<\/p>\n\n\n\n
errors.New(\"something went wrong\")<\/code><\/pre>\n\n\n\n
When?<\/h2>\n\n\n\n
Use errors.New()<\/code> when the error message is fixed\/simple.<\/p>\n\n\n\n
Example:<\/p>\n\n\n\n
invalid password\nuser not found\ndivision by zero\nfile is empty<\/code><\/pre>\n\n\n\n
How?<\/h2>\n\n\n\n
err := errors.New(\"something went wrong\")<\/code><\/pre>\n\n\n\n
Where?<\/h2>\n\n\n\n
Usually inside the function where the problem is detected.<\/p>\n\n\n\n
Complete example<\/h3>\n\n\n\n
package main\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\nfunc login(password string) error {\n\n\tif password != \"secret123\" {\n\n\t\t\/\/ Create and return a simple error.\n\t\treturn errors.New(\"invalid password\")\n\t}\n\n\t\/\/ nil means there was no error.\n\treturn nil\n}\n\nfunc main() {\n\n\terr := login(\"wrong-password\")\n\n\tif err != nil {\n\t\tfmt.Println(\"Login failed:\", err)\n\t\treturn\n\t}\n\n\tfmt.Println(\"Login successful\")\n}<\/code><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Login failed: invalid password<\/code><\/pre>\n\n\n\n
The flow is:<\/p>\n\n\n\n
login()\n   \u2502\n   \u251c\u2500\u2500 correct password\n   \u2502       \u2193\n   \u2502      nil\n   \u2502\n   \u2514\u2500\u2500 wrong password\n           \u2193\n      errors.New(...)\n           \u2193\n         error<\/code><\/pre>\n\n\n\n
Most important pattern<\/h3>\n\n\n\n
return errors.New(\"something went wrong\")<\/code><\/pre>\n\n\n\n
\n\n\n\n
4. errors.New()<\/code> and fmt.Errorf()<\/code><\/h1>\n\n\n\n
You mentioned Error & Errorf function<\/strong>.<\/p>\n\n\n\n
The common functions you will actually use are:<\/p>\n\n\n\n
errors.New()\nfmt.Errorf()<\/code><\/pre>\n\n\n\n
There isn’t a general built-in Error()<\/code> function for creating errors.<\/p>\n\n\n\n
Error()<\/code> is normally the method required by the error<\/code> interface<\/strong>.<\/p>\n\n\n\n
errors.New()<\/code><\/h2>\n\n\n\n
Creates a simple fixed error.<\/p>\n\n\n\n
errors.New(\"user not found\")<\/code><\/pre>\n\n\n\n
fmt.Errorf()<\/code><\/h2>\n\n\n\n
Creates an error containing dynamic information.<\/p>\n\n\n\n
fmt.Errorf(\"user %s not found\", username)<\/code><\/pre>\n\n\n\n
Why Errorf<\/code>?<\/h2>\n\n\n\n
Suppose username is:<\/p>\n\n\n\n
rajesh<\/code><\/pre>\n\n\n\n
Instead of:<\/p>\n\n\n\n
errors.New(\"user not found\")<\/code><\/pre>\n\n\n\n
you might want:<\/p>\n\n\n\n
user rajesh not found<\/code><\/pre>\n\n\n\n
That’s where:<\/p>\n\n\n\n
fmt.Errorf()<\/code><\/pre>\n\n\n\n
is useful.<\/p>\n\n\n\n
When?<\/h2>\n\n\n\n
Use:<\/p>\n\n\n\n
errors.New() \u2192 simple\/static error\nfmt.Errorf() \u2192 dynamic\/formatted error<\/code><\/pre>\n\n\n\n
Complete example<\/h3>\n\n\n\n
package main\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\nfunc findUser(username string) error {\n\n\tif username == \"\" {\n\n\t\t\/\/ Fixed message:\n\t\t\/\/ errors.New is perfect here.\n\t\treturn errors.New(\"username cannot be empty\")\n\t}\n\n\tif username != \"rajesh\" {\n\n\t\t\/\/ Dynamic message:\n\t\t\/\/ username is inserted into the error.\n\t\treturn fmt.Errorf(\"user %s not found\", username)\n\t}\n\n\treturn nil\n}\n\nfunc main() {\n\n\terr := findUser(\"amit\")\n\n\tif err != nil {\n\t\tfmt.Println(\"Error:\", err)\n\t\treturn\n\t}\n\n\tfmt.Println(\"User found\")\n}<\/code><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Error: user amit not found<\/code><\/pre>\n\n\n\n
Easy rule<\/h3>\n\n\n\n
Fixed error:\n\nerrors.New(\"database unavailable\")\n\n\nDynamic error:\n\nfmt.Errorf(\"user %s not found\", username)<\/code><\/pre>\n\n\n\n
Think:<\/p>\n\n\n\n
New       = simple message\nErrorf    = formatted message<\/code><\/pre>\n\n\n\n
\n\n\n\n
5. Error Handling in Go<\/h1>\n\n\n\n
Now we reach the part you will use constantly.<\/p>\n\n\n\n
What?<\/h2>\n\n\n\n
Error handling means:<\/p>\n\n\n\n
    \n
  1. call a function<\/li>\n\n\n\n
  2. receive an error<\/li>\n\n\n\n
  3. check the error<\/li>\n\n\n\n
  4. decide what to do<\/li>\n<\/ol>\n\n\n\n
    The famous Go pattern is:<\/p>\n\n\n\n
    if err != nil {\n\t\/\/ handle error\n}<\/code><\/pre>\n\n\n\n
    Why?<\/h2>\n\n\n\n
    Go intentionally makes error handling explicit.<\/p>\n\n\n\n
    You can clearly see:<\/p>\n\n\n\n
    where an error happened\nwho handled it\nwhat happened after it<\/code><\/pre>\n\n\n\n
    When?<\/h2>\n\n\n\n
    Whenever a function returns:<\/p>\n\n\n\n
    error<\/code><\/pre>\n\n\n\n
    check it.<\/p>\n\n\n\n
    How?<\/h2>\n\n\n\n
    Common pattern:<\/p>\n\n\n\n
    value, err := someFunction()\n\nif err != nil {\n\treturn\n}<\/code><\/pre>\n\n\n\n
    Where?<\/h2>\n\n\n\n
    Immediately after calling the function.<\/p>\n\n\n\n
    Prefer:<\/p>\n\n\n\n
    result, err := divide(10, 2)\n\nif err != nil {\n\t...\n}<\/code><\/pre>\n\n\n\n
    rather than ignoring err<\/code>.<\/p>\n\n\n\n
    Complete example<\/h3>\n\n\n\n
    package main\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\nfunc divide(a, b float64) (float64, error) {\n\n\tif b == 0 {\n\t\treturn 0, errors.New(\"cannot divide by zero\")\n\t}\n\n\t\/\/ Success:\n\t\/\/ result + nil error\n\treturn a \/ b, nil\n}\n\nfunc main() {\n\n\tresult, err := divide(20, 4)\n\n\t\/\/ Step 1: check error.\n\tif err != nil {\n\t\tfmt.Println(\"Failed:\", err)\n\t\treturn\n\t}\n\n\t\/\/ Step 2: use result only after checking error.\n\tfmt.Println(\"Result:\", result)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    Result: 5<\/code><\/pre>\n\n\n\n
    Now change:<\/p>\n\n\n\n
    divide(20, 4)<\/code><\/pre>\n\n\n\n
    to:<\/p>\n\n\n\n
    divide(20, 0)<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    Failed: cannot divide by zero<\/code><\/pre>\n\n\n\n
    Understand (result, error)<\/code><\/h2>\n\n\n\n
    This is extremely common:<\/p>\n\n\n\n
    func divide(a, b float64) (float64, error)<\/code><\/pre>\n\n\n\n
    Success:<\/p>\n\n\n\n
    return a \/ b, nil<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    Result = valid\nError  = nothing<\/code><\/pre>\n\n\n\n
    Failure:<\/p>\n\n\n\n
    return 0, errors.New(\"cannot divide by zero\")<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    Result = zero value\nError  = problem information<\/code><\/pre>\n\n\n\n
    Mental model:<\/p>\n\n\n\n
    flowchart TD\n    A[\"divide(20,4)\"] --> B{Problem?}\n\n    B -- No --> C[\"return 5, nil\"]\n    B -- Yes --> D[\"return 0, error\"]\n\n    C --> E[\"err == nil\"]\n    D --> F[\"err != nil\"]\n\n    E --> G[Use result]\n    F --> H[Handle error]<\/code><\/pre>\n\n\n\n
    The #1 Go error pattern<\/h3>\n\n\n\n
    Memorize this:<\/p>\n\n\n\n
    result, err := someFunction()\n\nif err != nil {\n\tfmt.Println(err)\n\treturn\n}\n\nfmt.Println(result)<\/code><\/pre>\n\n\n\n
    You will see this everywhere in Go.<\/p>\n\n\n\n
    \n\n\n\n
    6. Errors vs Panics<\/h1>\n\n\n\n
    This distinction is extremely important.<\/p>\n\n\n\n
    Error<\/h2>\n\n\n\n
    An error means:<\/p>\n\n\n\n
    \n
    Something went wrong, but the program can potentially deal with it.<\/p>\n<\/blockquote>\n\n\n\n
    Examples:<\/p>\n\n\n\n
    file doesn't exist\nwrong password\ndatabase unavailable\ninvalid user input\nnetwork timeout<\/code><\/pre>\n\n\n\n
    Return:<\/p>\n\n\n\n
    error<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    Panic<\/h2>\n\n\n\n
    A panic means:<\/p>\n\n\n\n
    \n
    Normal program execution cannot safely continue.<\/p>\n<\/blockquote>\n\n\n\n
    Example:<\/p>\n\n\n\n
    panic(\"something seriously wrong\")<\/code><\/pre>\n\n\n\n
    A panic starts unwinding the current goroutine’s stack.<\/p>\n\n\n\n
    Unless recovered, the program terminates and prints a stack trace.<\/p>\n\n\n\n
    When to use which?<\/h2>\n\n\n\n
    Normal expected problem:<\/p>\n\n\n\n
    return errors.New(\"user not found\")<\/code><\/pre>\n\n\n\n
    Exceptional\/programmer\/invariant problem:<\/p>\n\n\n\n
    panic(\"configuration must never be empty\")<\/code><\/pre>\n\n\n\n
    Complete example<\/h3>\n\n\n\n
    package main\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\n\/\/ Normal problem:\n\/\/ return an error.\nfunc checkUsername(username string) error {\n\n\tif username == \"\" {\n\t\treturn errors.New(\"username cannot be empty\")\n\t}\n\n\treturn nil\n}\n\n\/\/ Serious invariant problem:\n\/\/ panic.\nfunc startApplication(configLoaded bool) {\n\n\tif !configLoaded {\n\t\tpanic(\"application configuration was not loaded\")\n\t}\n\n\tfmt.Println(\"Application started\")\n}\n\nfunc main() {\n\n\t\/\/ NORMAL ERROR\n\terr := checkUsername(\"\")\n\n\tif err != nil {\n\t\tfmt.Println(\"Handled error:\", err)\n\t}\n\n\tfmt.Println(\"Program is still running\")\n\n\t\/\/ PANIC\n\tstartApplication(false)\n\n\t\/\/ This will never execute.\n\tfmt.Println(\"Finished\")\n}<\/code><\/pre>\n\n\n\n
    Typical output:<\/p>\n\n\n\n
    Handled error: username cannot be empty\nProgram is still running\npanic: application configuration was not loaded<\/code><\/pre>\n\n\n\n
    Notice the difference.<\/p>\n\n\n\n
    With error:<\/p>\n\n\n\n
    if err != nil {\n\tfmt.Println(err)\n}<\/code><\/pre>\n\n\n\n
    you control what happens.<\/p>\n\n\n\n
    With:<\/p>\n\n\n\n
    panic(...)<\/code><\/pre>\n\n\n\n
    normal execution stops.<\/p>\n\n\n\n
    Easy comparison<\/h3>\n\n\n\n
    Error<\/th>Panic<\/th><\/tr><\/thead>
    Normal problem<\/td>Exceptional situation<\/td><\/tr>
    Returned<\/td>Thrown by panic()<\/code><\/td><\/tr>
    Caller handles it<\/td>Stops normal execution<\/td><\/tr>
    Very common<\/td>Much less common<\/td><\/tr>
    return err<\/code><\/td>panic(...)<\/code><\/td><\/tr>
    Expected failures<\/td>Broken assumptions\/invariants<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    Golden rule<\/h3>\n\n\n\n
    Don’t use panic just because something returned an error.<\/strong><\/p>\n\n\n\n
    Usually:<\/p>\n\n\n\n
    if err != nil {\n\treturn err\n}<\/code><\/pre>\n\n\n\n
    not:<\/p>\n\n\n\n
    if err != nil {\n\tpanic(err)\n}<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    7. Converting Panic to Error<\/h1>\n\n\n\n
    Sometimes you are calling code that may panic, but you don’t want that panic to crash your program.<\/p>\n\n\n\n
    Go provides:<\/p>\n\n\n\n
    recover()<\/code><\/pre>\n\n\n\n
    But recover()<\/code> works only from a deferred function during panic unwinding.<\/p>\n\n\n\n
    The pattern is:<\/p>\n\n\n\n
    defer func() {\n\tif r := recover(); r != nil {\n\t\t\/\/ panic was caught\n\t}\n}()<\/code><\/pre>\n\n\n\n
    What?<\/h2>\n\n\n\n
    recover()<\/code> catches a panic.<\/p>\n\n\n\n
    Why?<\/h2>\n\n\n\n
    It lets you turn:<\/p>\n\n\n\n
    panic<\/code><\/pre>\n\n\n\n
    into:<\/p>\n\n\n\n
    ordinary error<\/code><\/pre>\n\n\n\n
    When?<\/h2>\n\n\n\n
    Use it mainly at controlled boundaries.<\/p>\n\n\n\n
    For example:<\/p>\n\n\n\n
    server request handler\nlibrary wrapper\nplugin execution\nworker\/job boundary\ncode you don't control<\/code><\/pre>\n\n\n\n
    Do not<\/strong> use recover()<\/code> as normal error handling.<\/p>\n\n\n\n
    How?<\/h2>\n\n\n\n
    This looks strange initially:<\/p>\n\n\n\n
    defer func() {\n\tif r := recover(); r != nil {\n\t\terr = fmt.Errorf(\"panic occurred: %v\", r)\n\t}\n}()<\/code><\/pre>\n\n\n\n
    The defer<\/code> waits.<\/p>\n\n\n\n
    If a panic occurs, the deferred function runs and recover()<\/code> catches the panic.<\/p>\n\n\n\n
    Complete example<\/h3>\n\n\n\n
    package main\n\nimport \"fmt\"\n\n\/\/ This function converts a panic into a normal error.\nfunc safeDivide(a, b int) (result int, err error) {\n\n\t\/\/ This deferred function runs when safeDivide finishes,\n\t\/\/ including when a panic happens.\n\tdefer func() {\n\n\t\t\/\/ recover() catches the panic.\n\t\tif r := recover(); r != nil {\n\n\t\t\t\/\/ Convert panic value into a normal error.\n\t\t\terr = fmt.Errorf(\"operation failed: %v\", r)\n\t\t}\n\t}()\n\n\tif b == 0 {\n\t\tpanic(\"cannot divide by zero\")\n\t}\n\n\tresult = a \/ b\n\treturn result, nil\n}\n\nfunc main() {\n\n\tresult, err := safeDivide(10, 0)\n\n\tif err != nil {\n\t\tfmt.Println(\"Error:\", err)\n\t\treturn\n\t}\n\n\tfmt.Println(\"Result:\", result)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    Error: operation failed: cannot divide by zero<\/code><\/pre>\n\n\n\n
    Without recover()<\/code>:<\/p>\n\n\n\n
    panic\n   \u2193\nprogram crashes<\/code><\/pre>\n\n\n\n
    With recover()<\/code>:<\/p>\n\n\n\n
    panic\n   \u2193\ndefer runs\n   \u2193\nrecover()\n   \u2193\nfmt.Errorf(...)\n   \u2193\nnormal error\n   \u2193\ncaller handles it<\/code><\/pre>\n\n\n\n
    flowchart TD\n    A[Function starts] --> B[defer recovery function]\n    B --> C[Code runs]\n    C --> D{Panic?}\n\n    D -- No --> E[Normal return]\n\n    D -- Yes --> F[Deferred function runs]\n    F --> G[\"recover()\"]\n    G --> H[\"Create error using fmt.Errorf\"]\n    H --> I[Return error to caller]<\/code><\/pre>\n\n\n\n
    Important<\/h3>\n\n\n\n
    This:<\/p>\n\n\n\n
    recover()<\/code><\/pre>\n\n\n\n
    does not<\/strong> mean:<\/p>\n\n\n\n
    \n
    catch every error.<\/p>\n<\/blockquote>\n\n\n\n
    It only catches:<\/p>\n\n\n\n
    panic()<\/code><\/pre>\n\n\n\n
    Errors and panics are two different mechanisms.<\/p>\n\n\n\n
    \n\n\n\n
    The Complete Mental Model<\/h1>\n\n\n\n
    You can understand nearly all basic Go error handling with this picture:<\/p>\n\n\n\n
    flowchart TD\n    A[Function executes] --> B{Problem occurs?}\n\n    B -- No --> C[\"return result, nil\"]\n\n    B -- Yes --> D{Normal \/ expected problem?}\n\n    D -- Yes --> E[\"return result, error\"]\n    E --> F[\"Caller checks err != nil\"]\n    F --> G[Handle \/ return \/ log error]\n\n    D -- No --> H[\"panic(...)\"]\n    H --> I{recover exists?}\n\n    I -- No --> J[Program \/ goroutine terminates]\n    I -- Yes --> K[\"recover()\"]\n    K --> L[Possibly convert panic to error]<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    Final Comparison \u2014 Everything Side by Side<\/h1>\n\n\n\n
    Concept<\/th>What is it?<\/th>Main purpose<\/th>Typical syntax<\/th>When to use<\/th>Normal?<\/th><\/tr><\/thead>
    error<\/code><\/td>Built-in interface<\/td>Represent a problem<\/td>var err error<\/code><\/td>Nearly all recoverable failures<\/td>Yes<\/td><\/tr>
    Error() string<\/code><\/td>Interface method<\/td>Makes a type satisfy error<\/code><\/td>func (e MyError) Error() string<\/code><\/td>Custom errors<\/td>Yes<\/td><\/tr>
    errors<\/code><\/td>Standard package<\/td>Error utilities<\/td>import \"errors\"<\/code><\/td>Creating\/checking errors<\/td>Yes<\/td><\/tr>
    errors.New()<\/code><\/td>Function<\/td>Create simple error<\/td>errors.New(\"invalid input\")<\/code><\/td>Static error message<\/td>Yes<\/td><\/tr>
    fmt.Errorf()<\/code><\/td>Function<\/td>Create formatted error<\/td>fmt.Errorf(\"user %s not found\", name)<\/code><\/td>Dynamic error message<\/td>Yes<\/td><\/tr>
    if err != nil<\/code><\/td>Error-handling pattern<\/td>Detect returned errors<\/td>if err != nil {...}<\/code><\/td>After error-returning function calls<\/td>Extremely common<\/td><\/tr>
    nil<\/code><\/td>No error<\/td>Indicates success<\/td>return value, nil<\/code><\/td>Successful operation<\/td>Extremely common<\/td><\/tr>
    panic()<\/code><\/td>Built-in function<\/td>Stop normal execution<\/td>panic(\"bad state\")<\/code><\/td>Exceptional\/unrecoverable situation<\/td>Rare<\/td><\/tr>
    recover()<\/code><\/td>Built-in function<\/td>Catch panic<\/td>recover()<\/code><\/td>Controlled panic boundary<\/td>Rare<\/td><\/tr>
    defer<\/code> + recover<\/code><\/td>Recovery pattern<\/td>Convert\/catch panic<\/td>defer func(){...}()<\/code><\/td>Server\/library boundaries<\/td>Rare<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    \n\n\n\n
    errors.New<\/code> vs fmt.Errorf<\/code> vs panic<\/code><\/h1>\n\n\n\n
    This is probably the most useful decision table to remember:<\/p>\n\n\n\n
    Situation<\/th>Use<\/th><\/tr><\/thead>
    Simple fixed error<\/td>errors.New()<\/code><\/td><\/tr>
    Error needs variables\/data<\/td>fmt.Errorf()<\/code><\/td><\/tr>
    Function succeeds<\/td>nil<\/code><\/td><\/tr>
    Function returns error<\/td>if err != nil<\/code><\/td><\/tr>
    Normal expected failure<\/td>error<\/code><\/td><\/tr>
    Truly exceptional impossible state<\/td>panic()<\/code><\/td><\/tr>
    Need to catch a panic<\/td>recover()<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    For example:<\/p>\n\n\n\n
    \/\/ Simple\nreturn errors.New(\"invalid password\")<\/code><\/pre>\n\n\n\n
    \/\/ Dynamic\nreturn fmt.Errorf(\"user %s not found\", username)<\/code><\/pre>\n\n\n\n
    \/\/ Success\nreturn result, nil<\/code><\/pre>\n\n\n\n
    \/\/ Handle\nif err != nil {\n\treturn\n}<\/code><\/pre>\n\n\n\n
    \/\/ Exceptional\npanic(\"database configuration missing\")<\/code><\/pre>\n\n\n\n
    \/\/ Catch panic\nif r := recover(); r != nil {\n\tfmt.Println(r)\n}<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    One Very Important Go Pattern to Memorize<\/h1>\n\n\n\n
    If you remember only one piece of code<\/strong> from this tutorial, remember this:<\/p>\n\n\n\n
    package main\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\nfunc divide(a, b int) (int, error) {\n\n\tif b == 0 {\n\t\treturn 0, errors.New(\"cannot divide by zero\")\n\t}\n\n\treturn a \/ b, nil\n}\n\nfunc main() {\n\n\tresult, err := divide(10, 2)\n\n\tif err != nil {\n\t\tfmt.Println(\"Error:\", err)\n\t\treturn\n\t}\n\n\tfmt.Println(\"Result:\", result)\n}<\/code><\/pre>\n\n\n\n
    The entire philosophy is essentially:<\/p>\n\n\n\n
    Function\n   \u2502\n   \u251c\u2500\u2500 Success\n   \u2502      \u2193\n   \u2502  result, nil\n   \u2502\n   \u2514\u2500\u2500 Failure\n          \u2193\n      zero, error\n          \u2502\n          \u25bc\n    Caller checks\n          \u2502\n     err != nil<\/code><\/pre>\n\n\n\n
    Final Memory Trick<\/h2>\n\n\n\n
    error           = WHAT represents a problem\n\nerrors.New()    = CREATE a simple problem\n\nfmt.Errorf()    = CREATE a problem with values\/details\n\nerr != nil      = CHECK whether a problem happened\n\npanic()         = STOP because something exceptional happened\n\nrecover()       = CATCH a panic\n\ndefer           = WHERE recover is normally placed<\/code><\/pre>\n\n\n\n
    And the single most important distinction:<\/p>\n\n\n\n
    \n
    Errors are normal in Go. Panics are exceptional.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
    For most Go programs, you will spend far more time writing if err != nil<\/code> than writing panic()<\/code> or recover()<\/code>.<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
    The most important rule to remember is: In Go, errors are normal values. A function usually returns an error, and the caller decides what to do with… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1065","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1065","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/comments?post=1065"}],"version-history":[{"count":2,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1065\/revisions"}],"predecessor-version":[{"id":1070,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1065\/revisions\/1070"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/media?parent=1065"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/categories?post=1065"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/tags?post=1065"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}