{"id":1076,"date":"2026-08-16T23:12:44","date_gmt":"2026-08-16T23:12:44","guid":{"rendered":"https:\/\/www.devopsschool.com\/tutorials\/?p=1076"},"modified":"2026-08-16T23:34:46","modified_gmt":"2026-08-16T23:34:46","slug":"go-tutorials-go-functions-master-guide","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/tutorials\/go-tutorials-go-functions-master-guide\/","title":{"rendered":"Go Tutorials: Go Functions Master Guide"},"content":{"rendered":"\n
\"\"<\/a><\/figure>\n\n\n\n

A function<\/strong> is one of the most important building blocks in Go.<\/p>\n\n\n\n

If you understand functions properly, concepts such as methods, interfaces, goroutines, error handling, defer<\/code>, callbacks, HTTP handlers, and concurrency<\/strong> become much easier.<\/p>\n\n\n\n

The best mental model is:<\/p>\n\n\n\n

INPUT\n  \u2193\nFUNCTION\n  \u2193\nWORK\n  \u2193\nOUTPUT<\/code><\/pre>\n\n\n\n
For example:<\/p>\n\n\n\n
func add(a int, b int) int {\n    return a + b\n}<\/code><\/pre>\n\n\n\n
a = 10 \u2500\u2510\n        \u251c\u2500\u2500\u25ba add() \u2500\u2500\u2500\u25ba 30\nb = 20 \u2500\u2518<\/code><\/pre>\n\n\n\n
\n\n\n\n
1. What is a Function?<\/h1>\n\n\n\n
A function is a named block of reusable code that performs a task<\/strong>.<\/p>\n\n\n\n
Instead of writing:<\/p>\n\n\n\n
fmt.Println(10 + 20)\nfmt.Println(30 + 40)\nfmt.Println(50 + 60)<\/code><\/pre>\n\n\n\n
you can create:<\/p>\n\n\n\n
func add(a int, b int) int {\n    return a + b\n}<\/code><\/pre>\n\n\n\n
and reuse it:<\/p>\n\n\n\n
add(10, 20)\nadd(30, 40)\nadd(50, 60)<\/code><\/pre>\n\n\n\n
Why use functions?<\/h3>\n\n\n\n
Functions help you:<\/p>\n\n\n\n
    \n
  • avoid duplicate code<\/li>\n\n\n\n
  • divide large programs into small pieces<\/li>\n\n\n\n
  • reuse logic<\/li>\n\n\n\n
  • test code more easily<\/li>\n\n\n\n
  • make code easier to understand<\/li>\n<\/ul>\n\n\n\n
    \n\n\n\n
    2. Basic Function<\/h1>\n\n\n\n
    Let’s start with the simplest possible function.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc greet() {\n    fmt.Println(\"Hello!\")\n}\n\nfunc main() {\n    greet()\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    Hello!<\/code><\/pre>\n\n\n\n
    Understand it<\/h3>\n\n\n\n
    func greet() {<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    func\n \u2502\n \u2514\u2500\u2500 create a function\n\ngreet\n \u2502\n \u2514\u2500\u2500 function name\n\n()\n \u2502\n \u2514\u2500\u2500 no input parameters<\/code><\/pre>\n\n\n\n
    The body is:<\/p>\n\n\n\n
    {\n    fmt.Println(\"Hello!\")\n}<\/code><\/pre>\n\n\n\n
    And:<\/p>\n\n\n\n
    greet()<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    Execute the greet<\/code> function.<\/p>\n<\/blockquote>\n\n\n\n
    \n\n\n\n
    3. Function With One Parameter<\/h1>\n\n\n\n
    Functions can receive information.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc greet(name string) {\n    fmt.Println(\"Hello\", name)\n}\n\nfunc main() {\n    greet(\"Rajesh\")\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    Hello Rajesh<\/code><\/pre>\n\n\n\n
    Here:<\/p>\n\n\n\n
    func greet(name string)<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    name     string\n \u2502         \u2502\n \u2502         \u2514\u2500\u2500 data type\n \u2502\n \u2514\u2500\u2500 parameter name<\/code><\/pre>\n\n\n\n
    When you call:<\/p>\n\n\n\n
    greet(\"Rajesh\")<\/code><\/pre>\n\n\n\n
    then:<\/p>\n\n\n\n
    name = \"Rajesh\"<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    4. Parameter vs Argument<\/h1>\n\n\n\n
    This terminology is useful.<\/p>\n\n\n\n
    Function definition:<\/p>\n\n\n\n
    func greet(name string)<\/code><\/pre>\n\n\n\n
    name<\/code> is a parameter<\/strong>.<\/p>\n\n\n\n
    Function call:<\/p>\n\n\n\n
    greet(\"Rajesh\")<\/code><\/pre>\n\n\n\n
    \"Rajesh\"<\/code> is an argument<\/strong>.<\/p>\n\n\n\n
    Think:<\/p>\n\n\n\n
    Parameter = variable declared by function\nArgument  = actual value sent to function<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    5. Multiple Parameters<\/h1>\n\n\n\n
    A function can receive multiple values.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a int, b int) {\n    fmt.Println(a + b)\n}\n\nfunc main() {\n    add(10, 20)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    30<\/code><\/pre>\n\n\n\n
    The values are mapped by position:<\/p>\n\n\n\n
    add(10, 20)\n\n     \u2502   \u2502\n     \u2502   \u2514\u2500\u2500 b = 20\n     \u2502\n     \u2514\u2500\u2500\u2500\u2500\u2500\u2500 a = 10<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    6. Short Parameter Syntax<\/h1>\n\n\n\n
    Instead of:<\/p>\n\n\n\n
    func add(a int, b int)<\/code><\/pre>\n\n\n\n
    Go allows:<\/p>\n\n\n\n
    func add(a, b int)<\/code><\/pre>\n\n\n\n
    because both parameters have the same type.<\/p>\n\n\n\n
    Example:<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a, b int) {\n    fmt.Println(a + b)\n}\n\nfunc main() {\n    add(10, 20)\n}<\/code><\/pre>\n\n\n\n
    Both versions mean exactly the same thing.<\/p>\n\n\n\n
    \n\n\n\n
    7. Function Returning a Value<\/h1>\n\n\n\n
    Functions can return results.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a, b int) int {\n    return a + b\n}\n\nfunc main() {\n\n    result := add(10, 20)\n\n    fmt.Println(result)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    30<\/code><\/pre>\n\n\n\n
    Look at:<\/p>\n\n\n\n
    func add(a, b int) int<\/code><\/pre>\n\n\n\n
    The final:<\/p>\n\n\n\n
    int<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    This function returns an integer.<\/p>\n<\/blockquote>\n\n\n\n
    And:<\/p>\n\n\n\n
    return a + b<\/code><\/pre>\n\n\n\n
    sends the result back.<\/p>\n\n\n\n
    Flow:<\/p>\n\n\n\n
    10 \u2500\u2500\u2510\n     \u251c\u2500\u2500\u25ba add() \u2500\u2500\u2500\u25ba 30\n20 \u2500\u2500\u2518<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    8. Return Value Directly<\/h1>\n\n\n\n
    You don’t always need another variable.<\/p>\n\n\n\n
    Instead of:<\/p>\n\n\n\n
    result := add(10, 20)\n\nfmt.Println(result)<\/code><\/pre>\n\n\n\n
    you can write:<\/p>\n\n\n\n
    fmt.Println(add(10, 20))<\/code><\/pre>\n\n\n\n
    Complete example:<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a, b int) int {\n    return a + b\n}\n\nfunc main() {\n    fmt.Println(add(10, 20))\n}<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    9. Multiple Return Values<\/h1>\n\n\n\n
    Go functions can return multiple values.<\/p>\n\n\n\n
    This is extremely common in Go.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc calculate(a, b int) (int, int) {\n\n    sum := a + b\n    product := a * b\n\n    return sum, product\n}\n\nfunc main() {\n\n    sum, product := calculate(10, 20)\n\n    fmt.Println(\"Sum:\", sum)\n    fmt.Println(\"Product:\", product)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    Sum: 30\nProduct: 200<\/code><\/pre>\n\n\n\n
    This:<\/p>\n\n\n\n
    (int, int)<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    first result  \u2192 int\nsecond result \u2192 int<\/code><\/pre>\n\n\n\n
    And:<\/p>\n\n\n\n
    return sum, product<\/code><\/pre>\n\n\n\n
    returns both.<\/p>\n\n\n\n
    \n\n\n\n
    10. Ignoring a Return Value With _<\/code><\/h1>\n\n\n\n
    Suppose:<\/p>\n\n\n\n
    func calculate(a, b int) (int, int)<\/code><\/pre>\n\n\n\n
    returns:<\/p>\n\n\n\n
    sum\nproduct<\/code><\/pre>\n\n\n\n
    but you only want the sum.<\/p>\n\n\n\n
    Use _<\/code>.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc calculate(a, b int) (int, int) {\n    return a + b, a * b\n}\n\nfunc main() {\n\n    sum, _ := calculate(10, 20)\n\n    fmt.Println(sum)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    30<\/code><\/pre>\n\n\n\n
    _<\/code> is called the blank identifier<\/strong>.<\/p>\n\n\n\n
    It means:<\/p>\n\n\n\n
    \n
    I received this value but don’t need it.<\/p>\n<\/blockquote>\n\n\n\n
    \n\n\n\n
    11. Named Return Values<\/h1>\n\n\n\n
    Go allows return variables to be named.<\/p>\n\n\n\n
    For example:<\/p>\n\n\n\n
    func calculate(a, b int) (sum int, product int) {\n\n    sum = a + b\n    product = a * b\n\n    return\n}<\/code><\/pre>\n\n\n\n
    Complete example:<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc calculate(a, b int) (sum int, product int) {\n\n    sum = a + b\n    product = a * b\n\n    return\n}\n\nfunc main() {\n\n    sum, product := calculate(10, 20)\n\n    fmt.Println(sum)\n    fmt.Println(product)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    30\n200<\/code><\/pre>\n\n\n\n
    Notice:<\/p>\n\n\n\n
    return<\/code><\/pre>\n\n\n\n
    has no values.<\/p>\n\n\n\n
    That’s because sum<\/code> and product<\/code> were already declared as return variables.<\/p>\n\n\n\n
    Should you use named returns?<\/h3>\n\n\n\n
    They can be useful in small functions, but don’t overuse them.<\/p>\n\n\n\n
    This is usually clearer:<\/p>\n\n\n\n
    return sum, product<\/code><\/pre>\n\n\n\n
    than:<\/p>\n\n\n\n
    return<\/code><\/pre>\n\n\n\n
    especially in larger functions.<\/p>\n\n\n\n
    \n\n\n\n
    12. Functions and Pass-by-Value<\/h1>\n\n\n\n
    This is extremely important<\/strong>.<\/p>\n\n\n\n
    Go passes function arguments by value<\/strong>.<\/p>\n\n\n\n
    Example:<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc changeNumber(number int) {\n\n    number = 100\n\n    fmt.Println(\"Inside:\", number)\n}\n\nfunc main() {\n\n    number := 10\n\n    changeNumber(number)\n\n    fmt.Println(\"Outside:\", number)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    Inside: 100\nOutside: 10<\/code><\/pre>\n\n\n\n
    Why?<\/p>\n\n\n\n
    Because Go creates a copy.<\/p>\n\n\n\n
    Conceptually:<\/p>\n\n\n\n
    main()\n\nnumber = 10\n    \u2502\n    \u2502 copy\n    \u25bc\n\nchangeNumber()\n\nnumber = 10\n\nnumber = 100<\/code><\/pre>\n\n\n\n
    The original variable is untouched.<\/p>\n\n\n\n
    So:<\/p>\n\n\n\n
    Original\nnumber = 10\n\nCopy inside function\nnumber = 100<\/code><\/pre>\n\n\n\n
    This is one of the fundamental rules of Go:<\/p>\n\n\n\n
    \n
    Go passes arguments by value.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
    \n\n\n\n
    13. Pointer Parameters<\/h1>\n\n\n\n
    What if the function really needs to change the original variable?<\/p>\n\n\n\n
    Use a pointer.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc changeNumber(number *int) {\n\n    *number = 100\n}\n\nfunc main() {\n\n    number := 10\n\n    changeNumber(&number)\n\n    fmt.Println(number)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    100<\/code><\/pre>\n\n\n\n
    Two important operators are involved:<\/p>\n\n\n\n
    Operator<\/th>Meaning<\/th><\/tr><\/thead>
    &<\/code><\/td>get address<\/td><\/tr>
    *<\/code><\/td>access value at address<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    So:<\/p>\n\n\n\n
    &number<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    Give me the memory address of number<\/code>.<\/p>\n<\/blockquote>\n\n\n\n
    And:<\/p>\n\n\n\n
    *number<\/code><\/pre>\n\n\n\n
    inside the function means:<\/p>\n\n\n\n
    \n
    Access the value stored at that address.<\/p>\n<\/blockquote>\n\n\n\n
    Conceptually:<\/p>\n\n\n\n
    main\n\nnumber = 10\n   \u2502\n   \u2502 address\n   \u25bc\n0x1000\n\n\nchangeNumber()\n\nnumber\n   \u2502\n   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u25ba 0x1000\n                  \u2502\n                  \u25bc\n               original\n               number<\/code><\/pre>\n\n\n\n
    Then:<\/p>\n\n\n\n
    *number = 100<\/code><\/pre>\n\n\n\n
    changes the original.<\/p>\n\n\n\n
    \n\n\n\n
    14. Incrementing Through a Pointer<\/h1>\n\n\n\n
    Your earlier example contained:<\/p>\n\n\n\n
    (*callCount)++<\/code><\/pre>\n\n\n\n
    Example:<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc increment(count *int) {\n    (*count)++\n}\n\nfunc main() {\n\n    calls := 0\n\n    increment(&calls)\n\n    fmt.Println(calls)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    1<\/code><\/pre>\n\n\n\n
    Breaking it down:<\/p>\n\n\n\n
    &calls<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    Address of calls<\/code>.<\/p>\n<\/blockquote>\n\n\n\n
    count<\/code><\/pre>\n\n\n\n
    stores that address.<\/p>\n\n\n\n
    *count<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    Value stored at the address.<\/p>\n<\/blockquote>\n\n\n\n
    Then:<\/p>\n\n\n\n
    (*count)++<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    Increase that original value by 1.<\/p>\n<\/blockquote>\n\n\n\n
    \n\n\n\n
    15. Variadic Functions \u2014 ...<\/code><\/h1>\n\n\n\n
    A function sometimes needs an unknown number of arguments.<\/p>\n\n\n\n
    Go provides variadic functions<\/strong>.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc total(numbers ...int) int {\n\n    sum := 0\n\n    for _, number := range numbers {\n        sum += number\n    }\n\n    return sum\n}\n\nfunc main() {\n\n    fmt.Println(total(10))\n    fmt.Println(total(10, 20))\n    fmt.Println(total(10, 20, 30))\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    10\n30\n60<\/code><\/pre>\n\n\n\n
    This:<\/p>\n\n\n\n
    numbers ...int<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    Accept zero or more integers.<\/p>\n<\/blockquote>\n\n\n\n
    Inside the function, numbers<\/code> behaves like a slice:<\/p>\n\n\n\n
    [10, 20, 30]<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    16. Variadic Parameter Must Be Last<\/h1>\n\n\n\n
    This is valid:<\/p>\n\n\n\n
    func calculate(name string, numbers ...int)<\/code><\/pre>\n\n\n\n
    This is invalid:<\/p>\n\n\n\n
    func calculate(numbers ...int, name string)<\/code><\/pre>\n\n\n\n
    Rule:<\/p>\n\n\n\n
    \n
    A variadic parameter must always be the final parameter.<\/p>\n<\/blockquote>\n\n\n\n
    \n\n\n\n
    17. Passing a Slice to a Variadic Function<\/h1>\n\n\n\n
    Suppose:<\/p>\n\n\n\n
    numbers := []int{10, 20, 30}<\/code><\/pre>\n\n\n\n
    You can pass the slice using:<\/p>\n\n\n\n
    numbers...<\/code><\/pre>\n\n\n\n
    Example:<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc total(numbers ...int) int {\n\n    sum := 0\n\n    for _, number := range numbers {\n        sum += number\n    }\n\n    return sum\n}\n\nfunc main() {\n\n    numbers := []int{10, 20, 30}\n\n    result := total(numbers...)\n\n    fmt.Println(result)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    60<\/code><\/pre>\n\n\n\n
    Notice the difference:<\/p>\n\n\n\n
    numbers<\/code><\/pre>\n\n\n\n
    is a slice.<\/p>\n\n\n\n
    numbers...<\/code><\/pre>\n\n\n\n
    means:<\/p>\n\n\n\n
    \n
    Expand the slice into individual arguments.<\/p>\n<\/blockquote>\n\n\n\n
    Conceptually:<\/p>\n\n\n\n
    total(numbers...)<\/code><\/pre>\n\n\n\n
    becomes:<\/p>\n\n\n\n
    total(10, 20, 30)<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    18. Your summarize()<\/code> Function<\/h1>\n\n\n\n
    Now your original function becomes much easier to understand.<\/p>\n\n\n\n
    func summarize(\n    label string,\n    callCount *int,\n    scores ...int,\n) (string, int) {\n\n    (*callCount)++\n\n    total := 0\n\n    for _, score := range scores {\n        total += score\n    }\n\n    return strings.ToUpper(label), total\n}<\/code><\/pre>\n\n\n\n
    It contains:<\/p>\n\n\n\n
                     summarize\n                     \u2502\n      \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n      \u2502              \u2502              \u2502\n      \u25bc              \u25bc              \u25bc\n normal param    pointer param   variadic param\n\nlabel string    callCount *int   scores ...int<\/code><\/pre>\n\n\n\n
    And returns:<\/p>\n\n\n\n
    (string, int)<\/code><\/pre>\n\n\n\n
    Complete flow:<\/p>\n\n\n\n
    summarize(\n    \"team score\",\n    &calls,\n    10, 20, 30,\n)\n\n        \u2502\n        \u25bc\n\nlabel\n\"team score\"\n\ncallCount\npoints to calls\n\nscores\n[10,20,30]\n\n        \u2502\n        \u25bc\n\ncalls++\ncalls = 1\n\n        \u2502\n        \u25bc\n\n10 + 20 + 30\ntotal = 60\n\n        \u2502\n        \u25bc\n\nstrings.ToUpper(\"team score\")\n\"TEAM SCORE\"\n\n        \u2502\n        \u25bc\n\nreturn\n\n\"TEAM SCORE\", 60<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    19. Functions Can Call Other Functions<\/h1>\n\n\n\n
    Functions aren’t isolated.<\/p>\n\n\n\n
    One function can call another.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a, b int) int {\n    return a + b\n}\n\nfunc printResult(a, b int) {\n\n    result := add(a, b)\n\n    fmt.Println(result)\n}\n\nfunc main() {\n    printResult(10, 20)\n}<\/code><\/pre>\n\n\n\n
    Flow:<\/p>\n\n\n\n
    main()\n   \u2502\n   \u25bc\nprintResult()\n   \u2502\n   \u25bc\nadd()\n   \u2502\n   \u25bc\n30<\/code><\/pre>\n\n\n\n
    This is how real applications are built: many small functions working together.<\/p>\n\n\n\n
    \n\n\n\n
    20. Functions Are Values in Go<\/h1>\n\n\n\n
    This is an important feature.<\/p>\n\n\n\n
    A function can be stored inside a variable.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a, b int) int {\n    return a + b\n}\n\nfunc main() {\n\n    operation := add\n\n    result := operation(10, 20)\n\n    fmt.Println(result)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    30<\/code><\/pre>\n\n\n\n
    Here:<\/p>\n\n\n\n
    operation := add<\/code><\/pre>\n\n\n\n
    doesn’t execute add<\/code>.<\/p>\n\n\n\n
    It stores the function.<\/p>\n\n\n\n
    Then:<\/p>\n\n\n\n
    operation(10, 20)<\/code><\/pre>\n\n\n\n
    executes it.<\/p>\n\n\n\n
    \n\n\n\n
    21. Function Type<\/h1>\n\n\n\n
    Functions themselves have types.<\/p>\n\n\n\n
    For this function:<\/p>\n\n\n\n
    func add(a int, b int) int<\/code><\/pre>\n\n\n\n
    the function type is:<\/p>\n\n\n\n
    func(int, int) int<\/code><\/pre>\n\n\n\n
    Example:<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a, b int) int {\n    return a + b\n}\n\nfunc main() {\n\n    var operation func(int, int) int\n\n    operation = add\n\n    fmt.Println(operation(10, 20))\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    30<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    22. Passing a Function Into Another Function<\/h1>\n\n\n\n
    Because functions are values, you can pass them into other functions.<\/p>\n\n\n\n
    This is called a higher-order function<\/strong>.<\/p>\n\n\n\n
    package main\n\nimport \"fmt\"\n\nfunc add(a, b int) int {\n    return a + b\n}\n\nfunc calculate(\n    a int,\n    b int,\n    operation func(int, int) int,\n) int {\n\n    return operation(a, b)\n}\n\nfunc main() {\n\n    result := calculate(10, 20, add)\n\n    fmt.Println(result)\n}<\/code><\/pre>\n\n\n\n
    Output:<\/p>\n\n\n\n
    30<\/code><\/pre>\n\n\n\n
    Flow:<\/p>\n\n\n\n
    calculate\n   \u2502\n   \u251c\u2500\u2500 10\n   \u251c\u2500\u2500 20\n   \u2502\n   \u2514\u2500\u2500 add function\n          \u2502\n          \u25bc\n      add(10,20)\n          \u2502\n          \u25bc\n         30<\/code><\/pre>\n\n\n\n
    This pattern is used heavily for:<\/p>\n\n\n\n
      \n
    • callbacks<\/li>\n\n\n\n
    • HTTP handlers<\/li>\n\n\n\n
    • middleware<\/li>\n\n\n\n
    • sorting<\/li>\n\n\n\n
    • concurrency<\/li>\n\n\n\n
    • event processing<\/li>\n<\/ul>\n\n\n\n
      \n\n\n\n
      23. Anonymous Functions<\/h1>\n\n\n\n
      A function doesn’t always need a name.<\/p>\n\n\n\n
      This is called an anonymous function<\/strong>.<\/p>\n\n\n\n
      package main\n\nimport \"fmt\"\n\nfunc main() {\n\n    add := func(a, b int) int {\n        return a + b\n    }\n\n    result := add(10, 20)\n\n    fmt.Println(result)\n}<\/code><\/pre>\n\n\n\n
      Output:<\/p>\n\n\n\n
      30<\/code><\/pre>\n\n\n\n
      Here:<\/p>\n\n\n\n
      func(a, b int) int {\n    return a + b\n}<\/code><\/pre>\n\n\n\n
      has no name.<\/p>\n\n\n\n
      It is assigned to:<\/p>\n\n\n\n
      add<\/code><\/pre>\n\n\n\n
      \n\n\n\n
      24. Immediately Executed Anonymous Function<\/h1>\n\n\n\n
      You can also execute an anonymous function immediately.<\/p>\n\n\n\n
      package main\n\nimport \"fmt\"\n\nfunc main() {\n\n    func() {\n        fmt.Println(\"Hello\")\n    }()\n}<\/code><\/pre>\n\n\n\n
      Notice:<\/p>\n\n\n\n
      }()<\/code><\/pre>\n\n\n\n
      The final ()<\/code> executes the function immediately.<\/p>\n\n\n\n
      \n\n\n\n
      25. Closures<\/h1>\n\n\n\n
      A closure is an anonymous function that remembers variables outside itself.<\/p>\n\n\n\n
      Example:<\/p>\n\n\n\n
      package main\n\nimport \"fmt\"\n\nfunc main() {\n\n    count := 0\n\n    increment := func() {\n\n        count++\n\n        fmt.Println(count)\n    }\n\n    increment()\n    increment()\n    increment()\n}<\/code><\/pre>\n\n\n\n
      Output:<\/p>\n\n\n\n
      1\n2\n3<\/code><\/pre>\n\n\n\n
      The function can access:<\/p>\n\n\n\n
      count<\/code><\/pre>\n\n\n\n
      even though count<\/code> was created outside the function.<\/p>\n\n\n\n
      Conceptually:<\/p>\n\n\n\n
      count = 0\n   \u25b2\n   \u2502\nincrement()\n   \u2502\n   \u251c\u2500\u2500 count++\n   \u2514\u2500\u2500 remembers count<\/code><\/pre>\n\n\n\n
      Closures are commonly used in:<\/p>\n\n\n\n
        \n
      • callbacks<\/li>\n\n\n\n
      • middleware<\/li>\n\n\n\n
      • configuration<\/li>\n\n\n\n
      • state management<\/li>\n\n\n\n
      • goroutines<\/li>\n<\/ul>\n\n\n\n
        \n\n\n\n
        26. Function Returning Another Function<\/h1>\n\n\n\n
        A function can even return another function.<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc createMultiplier(multiplier int) func(int) int {\n\n    return func(number int) int {\n        return number * multiplier\n    }\n}\n\nfunc main() {\n\n    double := createMultiplier(2)\n\n    fmt.Println(double(10))\n    fmt.Println(double(20))\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        20\n40<\/code><\/pre>\n\n\n\n
        double<\/code> remembers:<\/p>\n\n\n\n
        multiplier = 2<\/code><\/pre>\n\n\n\n
        This is another closure example.<\/p>\n\n\n\n
        \n\n\n\n
        27. Callback Functions<\/h1>\n\n\n\n
        A callback is simply:<\/p>\n\n\n\n
        \n
        A function passed to another function so it can be called later.<\/p>\n<\/blockquote>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc process(number int, callback func(int)) {\n\n    result := number * 2\n\n    callback(result)\n}\n\nfunc printResult(result int) {\n\n    fmt.Println(\"Result:\", result)\n}\n\nfunc main() {\n\n    process(10, printResult)\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        Result: 20<\/code><\/pre>\n\n\n\n
        Flow:<\/p>\n\n\n\n
        main\n \u2502\n \u25bc\nprocess(10, printResult)\n \u2502\n \u251c\u2500\u2500 10 \u00d7 2\n \u2502\n \u25bc\n20\n \u2502\n \u25bc\nprintResult(20)<\/code><\/pre>\n\n\n\n
        \n\n\n\n
        28. Returning Errors From Functions<\/h1>\n\n\n\n
        This is perhaps the most common Go function pattern<\/strong>.<\/p>\n\n\n\n
        Instead of exceptions, Go commonly returns:<\/p>\n\n\n\n
        value + error<\/code><\/pre>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport (\n    \"errors\"\n    \"fmt\"\n)\n\nfunc divide(a, b float64) (float64, error) {\n\n    if b == 0 {\n        return 0, errors.New(\"cannot divide by zero\")\n    }\n\n    return a \/ b, nil\n}\n\nfunc main() {\n\n    result, err := divide(10, 2)\n\n    if err != nil {\n        fmt.Println(\"Error:\", err)\n        return\n    }\n\n    fmt.Println(result)\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        5<\/code><\/pre>\n\n\n\n
        Function:<\/p>\n\n\n\n
        func divide(a, b float64) (float64, error)<\/code><\/pre>\n\n\n\n
        returns:<\/p>\n\n\n\n
        result\nerror<\/code><\/pre>\n\n\n\n
        This pattern appears everywhere in Go:<\/p>\n\n\n\n
        value, err := someFunction()<\/code><\/pre>\n\n\n\n
        \n\n\n\n
        29. Early Return<\/h1>\n\n\n\n
        Go code commonly uses early returns<\/strong>.<\/p>\n\n\n\n
        Instead of:<\/p>\n\n\n\n
        if something {\n    \/\/ lots of logic\n}<\/code><\/pre>\n\n\n\n
        you often see:<\/p>\n\n\n\n
        if invalid {\n    return\n}<\/code><\/pre>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc checkAge(age int) {\n\n    if age < 18 {\n        fmt.Println(\"Not allowed\")\n        return\n    }\n\n    fmt.Println(\"Allowed\")\n}\n\nfunc main() {\n\n    checkAge(20)\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        Allowed<\/code><\/pre>\n\n\n\n
        This style keeps Go code simple and flat.<\/p>\n\n\n\n
        \n\n\n\n
        30. defer<\/code> Inside Functions<\/h1>\n\n\n\n
        defer<\/code> means:<\/p>\n\n\n\n
        \n
        Execute this function when the current function is about to finish.<\/p>\n<\/blockquote>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc demo() {\n\n    defer fmt.Println(\"Goodbye\")\n\n    fmt.Println(\"Hello\")\n}\n\nfunc main() {\n    demo()\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        Hello\nGoodbye<\/code><\/pre>\n\n\n\n
        Although:<\/p>\n\n\n\n
        defer fmt.Println(\"Goodbye\")<\/code><\/pre>\n\n\n\n
        appears first, it runs when demo()<\/code> finishes.<\/p>\n\n\n\n
        Flow:<\/p>\n\n\n\n
        demo()\n \u2502\n \u251c\u2500\u2500 register deferred function\n \u2502\n \u251c\u2500\u2500 print Hello\n \u2502\n \u2514\u2500\u2500 finishing\n        \u2502\n        \u25bc\n     print Goodbye<\/code><\/pre>\n\n\n\n
        defer<\/code> is commonly used for cleanup:<\/p>\n\n\n\n
        file.Close()<\/code><\/pre>\n\n\n\n
        rows.Close()<\/code><\/pre>\n\n\n\n
        mutex.Unlock()<\/code><\/pre>\n\n\n\n
        \n\n\n\n
        31. Multiple defer<\/code> Calls<\/h1>\n\n\n\n
        Deferred functions run in reverse order<\/strong>.<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc main() {\n\n    defer fmt.Println(\"One\")\n    defer fmt.Println(\"Two\")\n    defer fmt.Println(\"Three\")\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        Three\nTwo\nOne<\/code><\/pre>\n\n\n\n
        Think of a stack:<\/p>\n\n\n\n
        defer One\ndefer Two\ndefer Three\n\nfinish function\n\nThree\nTwo\nOne<\/code><\/pre>\n\n\n\n
        \n\n\n\n
        32. Recursive Functions<\/h1>\n\n\n\n
        A recursive function calls itself.<\/p>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc countdown(number int) {\n\n    if number == 0 {\n        return\n    }\n\n    fmt.Println(number)\n\n    countdown(number - 1)\n}\n\nfunc main() {\n\n    countdown(5)\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        5\n4\n3\n2\n1<\/code><\/pre>\n\n\n\n
        Flow:<\/p>\n\n\n\n
        countdown(5)\n    \u2193\ncountdown(4)\n    \u2193\ncountdown(3)\n    \u2193\ncountdown(2)\n    \u2193\ncountdown(1)\n    \u2193\ncountdown(0)\n    \u2193\nreturn<\/code><\/pre>\n\n\n\n
        This condition:<\/p>\n\n\n\n
        if number == 0 {\n    return\n}<\/code><\/pre>\n\n\n\n
        is called the base case<\/strong>.<\/p>\n\n\n\n
        Without a base case, recursion would continue until the program fails.<\/p>\n\n\n\n
        \n\n\n\n
        33. Methods vs Functions<\/h1>\n\n\n\n
        This distinction is extremely important.<\/p>\n\n\n\n
        Normal function:<\/p>\n\n\n\n
        func greet(name string) {\n}<\/code><\/pre>\n\n\n\n
        Method:<\/p>\n\n\n\n
        func (user User) greet() {\n}<\/code><\/pre>\n\n\n\n
        A method belongs to a type.<\/p>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\ntype User struct {\n    Name string\n}\n\nfunc (user User) Greet() {\n\n    fmt.Println(\"Hello\", user.Name)\n}\n\nfunc main() {\n\n    user := User{\n        Name: \"Rajesh\",\n    }\n\n    user.Greet()\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        Hello Rajesh<\/code><\/pre>\n\n\n\n
        The special part is:<\/p>\n\n\n\n
        (user User)<\/code><\/pre>\n\n\n\n
        This is called the receiver<\/strong>.<\/p>\n\n\n\n
        Think:<\/p>\n\n\n\n
        FUNCTION\n\ngreet(user)\n\n\nMETHOD\n\nuser.Greet()<\/code><\/pre>\n\n\n\n
        \n\n\n\n
        34. Pointer Receiver Methods<\/h1>\n\n\n\n
        A method that needs to change the original struct usually uses a pointer receiver.<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\ntype User struct {\n    Name string\n}\n\nfunc (user *User) ChangeName(name string) {\n\n    user.Name = name\n}\n\nfunc main() {\n\n    user := User{\n        Name: \"Rajesh\",\n    }\n\n    user.ChangeName(\"Kumar\")\n\n    fmt.Println(user.Name)\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        Kumar<\/code><\/pre>\n\n\n\n
        Pointer receiver:<\/p>\n\n\n\n
        func (user *User)<\/code><\/pre>\n\n\n\n
        allows modification of the original User<\/code>.<\/p>\n\n\n\n
        \n\n\n\n
        35. Function vs Method<\/h1>\n\n\n\n
        Feature<\/th>Function<\/th>Method<\/th><\/tr><\/thead>
        Belongs to type<\/td>No<\/td>Yes<\/td><\/tr>
        Has receiver<\/td>No<\/td>Yes<\/td><\/tr>
        Called as<\/td>add()<\/code><\/td>user.Greet()<\/code><\/td><\/tr>
        Can receive parameters<\/td>Yes<\/td>Yes<\/td><\/tr>
        Can return values<\/td>Yes<\/td>Yes<\/td><\/tr>
        Can be variadic<\/td>Yes<\/td>Yes<\/td><\/tr>
        Can return errors<\/td>Yes<\/td>Yes<\/td><\/tr>
        Can use pointers<\/td>Yes<\/td>Yes<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
        Example:<\/p>\n\n\n\n
        add(10, 20)<\/code><\/pre>\n\n\n\n
        versus:<\/p>\n\n\n\n
        user.Greet()<\/code><\/pre>\n\n\n\n
        \n\n\n\n
        36. Generic Functions<\/h1>\n\n\n\n
        Modern Go supports generics<\/strong>.<\/p>\n\n\n\n
        Suppose you want an add<\/code> function that works with both integers and floats.<\/p>\n\n\n\n
        You can write:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc add[T int | float64](a, b T) T {\n\n    return a + b\n}\n\nfunc main() {\n\n    fmt.Println(add(10, 20))\n\n    fmt.Println(add(10.5, 20.5))\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        30\n31<\/code><\/pre>\n\n\n\n
        Here:<\/p>\n\n\n\n
        [T int | float64]<\/code><\/pre>\n\n\n\n
        means:<\/p>\n\n\n\n
        \n
        T<\/code> may be an int<\/code> or float64<\/code>.<\/p>\n<\/blockquote>\n\n\n\n
        Then:<\/p>\n\n\n\n
        a, b T<\/code><\/pre>\n\n\n\n
        means both parameters use that type.<\/p>\n\n\n\n
        Generics are useful, but I recommend learning ordinary functions thoroughly before going deep into them.<\/p>\n\n\n\n
        \n\n\n\n
        37. main()<\/code> Is Also a Function<\/h1>\n\n\n\n
        Your Go program starts with:<\/p>\n\n\n\n
        func main()<\/code><\/pre>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc main() {\n\n    fmt.Println(\"Hello\")\n}<\/code><\/pre>\n\n\n\n
        main()<\/code> is special because in a runnable Go program:<\/p>\n\n\n\n
        Operating System\n      \u2502\n      \u25bc\nGo program\n      \u2502\n      \u25bc\nmain()<\/code><\/pre>\n\n\n\n
        The program starts executing from main()<\/code> in package main<\/code>.<\/p>\n\n\n\n
        \n\n\n\n
        38. init()<\/code> Function<\/h1>\n\n\n\n
        Go also has a special function named:<\/p>\n\n\n\n
        init()<\/code><\/pre>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc init() {\n\n    fmt.Println(\"init\")\n}\n\nfunc main() {\n\n    fmt.Println(\"main\")\n}<\/code><\/pre>\n\n\n\n
        Output:<\/p>\n\n\n\n
        init\nmain<\/code><\/pre>\n\n\n\n
        init()<\/code> executes before main()<\/code>.<\/p>\n\n\n\n
        Usually it is used sparingly for package initialization.<\/p>\n\n\n\n
        \n\n\n\n
        39. Functions Cannot Be Overloaded in Go<\/h1>\n\n\n\n
        Languages such as Java support:<\/p>\n\n\n\n
        add(int, int)\n\nadd(float, float)<\/code><\/pre>\n\n\n\n
        with the same function name.<\/p>\n\n\n\n
        Go does not<\/strong> support traditional function overloading.<\/p>\n\n\n\n
        You cannot write:<\/p>\n\n\n\n
        func add(a int, b int) {\n}\n\nfunc add(a float64, b float64) {\n}<\/code><\/pre>\n\n\n\n
        because both functions are named add<\/code>.<\/p>\n\n\n\n
        Usually you:<\/p>\n\n\n\n
          \n
        • use different function names<\/li>\n\n\n\n
        • use interfaces<\/li>\n\n\n\n
        • use generics<\/li>\n<\/ul>\n\n\n\n
          depending on the situation.<\/p>\n\n\n\n
          \n\n\n\n
          40. Go Has No Default Function Parameters<\/h1>\n\n\n\n
          Some languages allow:<\/p>\n\n\n\n
          greet(name=\"Rajesh\")<\/code><\/pre>\n\n\n\n
          Go doesn’t support default parameters directly.<\/p>\n\n\n\n
          You normally make them explicit.<\/p>\n\n\n\n
          For example:<\/p>\n\n\n\n
          func greet(name string) {\n}<\/code><\/pre>\n\n\n\n
          and call:<\/p>\n\n\n\n
          greet(\"Rajesh\")<\/code><\/pre>\n\n\n\n
          \n\n\n\n
          41. Go Has No Optional Parameters Directly<\/h1>\n\n\n\n
          Go doesn’t have standard optional arguments like Python.<\/p>\n\n\n\n
          But variadic arguments sometimes provide similar behavior:<\/p>\n\n\n\n
          func log(messages ...string)<\/code><\/pre>\n\n\n\n
          You can call:<\/p>\n\n\n\n
          log()<\/code><\/pre>\n\n\n\n
          or:<\/p>\n\n\n\n
          log(\"hello\")<\/code><\/pre>\n\n\n\n
          or:<\/p>\n\n\n\n
          log(\"hello\", \"world\")<\/code><\/pre>\n\n\n\n
          For complex configuration, Go often uses structs or the functional options pattern<\/strong>.<\/p>\n\n\n\n
          That’s an advanced topic for later.<\/p>\n\n\n\n
          \n\n\n\n
          42. Function Scope<\/h1>\n\n\n\n
          Variables created inside a function normally exist only inside that function.<\/p>\n\n\n\n
          Example:<\/p>\n\n\n\n
          package main\n\nimport \"fmt\"\n\nfunc test() {\n\n    message := \"Hello\"\n\n    fmt.Println(message)\n}\n\nfunc main() {\n\n    test()\n}<\/code><\/pre>\n\n\n\n
          You cannot access:<\/p>\n\n\n\n
          message<\/code><\/pre>\n\n\n\n
          directly from main()<\/code>.<\/p>\n\n\n\n
          Because its scope belongs to:<\/p>\n\n\n\n
          test()<\/code><\/pre>\n\n\n\n
          Conceptually:<\/p>\n\n\n\n
          main scope\n\u2502\n\u2502\n\u2514\u2500\u2500 test scope\n      \u2502\n      \u2514\u2500\u2500 message<\/code><\/pre>\n\n\n\n
          \n\n\n\n
          43. Local vs Package-Level Variables<\/h1>\n\n\n\n
          Variable outside a function:<\/p>\n\n\n\n
          var count = 10<\/code><\/pre>\n\n\n\n
          is package-level.<\/p>\n\n\n\n
          Example:<\/p>\n\n\n\n
          package main\n\nimport \"fmt\"\n\nvar count = 10\n\nfunc show() {\n\n    fmt.Println(count)\n}\n\nfunc main() {\n\n    show()\n}<\/code><\/pre>\n\n\n\n
          Output:<\/p>\n\n\n\n
          10<\/code><\/pre>\n\n\n\n
          Functions inside the package can access count<\/code>.<\/p>\n\n\n\n
          But generally, prefer passing data to functions rather than relying heavily on global\/package variables.<\/p>\n\n\n\n
          \n\n\n\n
          44. Exported Functions<\/h1>\n\n\n\n
          In Go, capitalization controls package visibility.<\/p>\n\n\n\n
          Lowercase:<\/p>\n\n\n\n
          func calculate()<\/code><\/pre>\n\n\n\n
          means:<\/p>\n\n\n\n
          \n
          Only accessible within the same package.<\/p>\n<\/blockquote>\n\n\n\n
          Uppercase:<\/p>\n\n\n\n
          func Calculate()<\/code><\/pre>\n\n\n\n
          means:<\/p>\n\n\n\n
          \n
          Exported and accessible from other packages.<\/p>\n<\/blockquote>\n\n\n\n
          Example:<\/p>\n\n\n\n
          calculator.Add()<\/code><\/pre>\n\n\n\n
          Here Add<\/code> needs to start with a capital letter if another package uses it.<\/p>\n\n\n\n
          This Go rule applies to:<\/p>\n\n\n\n
            \n
          • functions<\/li>\n\n\n\n
          • methods<\/li>\n\n\n\n
          • structs<\/li>\n\n\n\n
          • fields<\/li>\n\n\n\n
          • interfaces<\/li>\n\n\n\n
          • variables<\/li>\n\n\n\n
          • constants<\/li>\n<\/ul>\n\n\n\n
            \n\n\n\n
            45. Function Signature<\/h1>\n\n\n\n
            You will often hear the term function signature<\/strong>.<\/p>\n\n\n\n
            Example:<\/p>\n\n\n\n
            func add(a int, b int) int<\/code><\/pre>\n\n\n\n
            Important parts are essentially:<\/p>\n\n\n\n
            function name\nparameters\nparameter types\nreturn types<\/code><\/pre>\n\n\n\n
            Example:<\/p>\n\n\n\n
            add(int, int) \u2192 int<\/code><\/pre>\n\n\n\n
            Another:<\/p>\n\n\n\n
            func summarize(\n    label string,\n    callCount *int,\n    scores ...int,\n) (string, int)<\/code><\/pre>\n\n\n\n
            You can mentally read its signature as:<\/p>\n\n\n\n
            summarize(\n    string,\n    pointer-to-int,\n    many-int\n)\n\u2192\n(string, int)<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            46. Function Anatomy \u2014 Master View<\/h1>\n\n\n\n
            Consider:<\/p>\n\n\n\n
            func summarize(label string, callCount *int, scores ...int) (string, int) {\n    \/\/ body\n}<\/code><\/pre>\n\n\n\n
            The anatomy is:<\/p>\n\n\n\n
            func summarize(label string, callCount *int, scores ...int) (string, int)\n \u2502       \u2502          \u2502             \u2502              \u2502             \u2502\n \u2502       \u2502          \u2502             \u2502              \u2502             \u2502\n \u2502       \u2502          \u2502             \u2502              \u2502             \u2514 return types\n \u2502       \u2502          \u2502             \u2502              \u2502\n \u2502       \u2502          \u2502             \u2502              \u2514 variadic parameter\n \u2502       \u2502          \u2502             \u2502\n \u2502       \u2502          \u2502             \u2514 pointer parameter\n \u2502       \u2502          \u2502\n \u2502       \u2502          \u2514 normal parameter\n \u2502       \u2502\n \u2502       \u2514 function name\n \u2502\n \u2514 function declaration<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            47. The Most Important Function Patterns<\/h1>\n\n\n\n
            You will see these constantly.<\/p>\n\n\n\n
            No input, no output<\/h3>\n\n\n\n
            func hello() {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Input, no output<\/h3>\n\n\n\n
            func hello(name string) {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Input and output<\/h3>\n\n\n\n
            func add(a, b int) int {\n    return a + b\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Multiple outputs<\/h3>\n\n\n\n
            func calculate(a, b int) (int, int) {\n    return a + b, a * b\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Value + error<\/h3>\n\n\n\n
            func load() (string, error) {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Pointer parameter<\/h3>\n\n\n\n
            func update(value *int) {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Variadic<\/h3>\n\n\n\n
            func total(values ...int) int {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Function parameter<\/h3>\n\n\n\n
            func calculate(\n    operation func(int, int) int,\n) {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Method<\/h3>\n\n\n\n
            func (user User) Greet() {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            Pointer receiver method<\/h3>\n\n\n\n
            func (user *User) Update() {\n}<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            48. Master Comparison Table<\/h1>\n\n\n\n
            Concept<\/th>Syntax<\/th>Purpose<\/th><\/tr><\/thead>
            Basic function<\/td>func hello()<\/code><\/td>reusable code<\/td><\/tr>
            Parameter<\/td>name string<\/code><\/td>send data<\/td><\/tr>
            Multiple parameters<\/td>a, b int<\/code><\/td>send multiple values<\/td><\/tr>
            Return<\/td>func f() int<\/code><\/td>return result<\/td><\/tr>
            Multiple return<\/td>(int, string)<\/code><\/td>return multiple values<\/td><\/tr>
            Named return<\/td>(result int)<\/code><\/td>name result variable<\/td><\/tr>
            Blank identifier<\/td>_<\/code><\/td>ignore value<\/td><\/tr>
            Pointer parameter<\/td>value *int<\/code><\/td>modify indirectly<\/td><\/tr>
            Address<\/td>&value<\/code><\/td>get memory address<\/td><\/tr>
            Dereference<\/td>*ptr<\/code><\/td>access pointed value<\/td><\/tr>
            Variadic<\/td>values ...int<\/code><\/td>any number of arguments<\/td><\/tr>
            Slice expansion<\/td>values...<\/code><\/td>pass slice as arguments<\/td><\/tr>
            Anonymous function<\/td>func() {}<\/code><\/td>unnamed function<\/td><\/tr>
            Closure<\/td>anonymous function + outer variable<\/td>preserve\/access state<\/td><\/tr>
            Function variable<\/td>f := add<\/code><\/td>store function<\/td><\/tr>
            Function parameter<\/td>func(int) int<\/code><\/td>callback<\/td><\/tr>
            Higher-order function<\/td>function receives\/returns function<\/td>flexible behavior<\/td><\/tr>
            Recursion<\/td>function calls itself<\/td>recursive problems<\/td><\/tr>
            defer<\/code><\/td>defer cleanup()<\/code><\/td>run when function exits<\/td><\/tr>
            Method<\/td>func (x T) F()<\/code><\/td>function associated with type<\/td><\/tr>
            Pointer receiver<\/td>func (x *T) F()<\/code><\/td>mutate receiver<\/td><\/tr>
            Generic function<\/td>func F[T ...]<\/code><\/td>work with multiple types<\/td><\/tr>
            Exported function<\/td>func Add()<\/code><\/td>accessible from packages<\/td><\/tr>
            main()<\/code><\/td>func main()<\/code><\/td>program entry<\/td><\/tr>
            init()<\/code><\/td>func init()<\/code><\/td>package initialization<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            \n\n\n\n
            49. What You Should Learn First<\/h1>\n\n\n\n
            Don’t try to master everything simultaneously.<\/p>\n\n\n\n
            Learn functions in this order:<\/p>\n\n\n\n
            LEVEL 1\n\u2502\n\u251c\u2500\u2500 Basic function\n\u251c\u2500\u2500 Parameters\n\u251c\u2500\u2500 Return values\n\u2514\u2500\u2500 Multiple returns\n       \u2502\n       \u25bc\nLEVEL 2\n\u2502\n\u251c\u2500\u2500 Pass by value\n\u251c\u2500\u2500 Pointers\n\u251c\u2500\u2500 Blank identifier\n\u2514\u2500\u2500 Variadic parameters\n       \u2502\n       \u25bc\nLEVEL 3\n\u2502\n\u251c\u2500\u2500 Anonymous functions\n\u251c\u2500\u2500 Function variables\n\u251c\u2500\u2500 Callbacks\n\u2514\u2500\u2500 Closures\n       \u2502\n       \u25bc\nLEVEL 4\n\u2502\n\u251c\u2500\u2500 defer\n\u251c\u2500\u2500 recursion\n\u251c\u2500\u2500 errors\n\u2514\u2500\u2500 function types\n       \u2502\n       \u25bc\nLEVEL 5\n\u2502\n\u251c\u2500\u2500 Methods\n\u251c\u2500\u2500 Pointer receivers\n\u251c\u2500\u2500 Interfaces\n\u2514\u2500\u2500 Generics<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            50. The 10 Rules I Would Memorize<\/h1>\n\n\n\n
            If you’re learning Go, these ten rules cover most function confusion:<\/p>\n\n\n\n
              \n
            1. A function is created using:<\/li>\n<\/ol>\n\n\n\n
              func<\/code><\/pre>\n\n\n\n
                \n
              1. Parameters go inside:<\/li>\n<\/ol>\n\n\n\n
                ()<\/code><\/pre>\n\n\n\n
                  \n
                1. Return type comes after the parameters:<\/li>\n<\/ol>\n\n\n\n
                  func add(a, b int) int<\/code><\/pre>\n\n\n\n
                    \n
                  1. Multiple values can be returned:<\/li>\n<\/ol>\n\n\n\n
                    func f() (int, string)<\/code><\/pre>\n\n\n\n
                      \n
                    1. _<\/code> means:<\/li>\n<\/ol>\n\n\n\n
                      ignore this value<\/code><\/pre>\n\n\n\n
                        \n
                      1. Go passes arguments by value<\/strong>.<\/li>\n\n\n\n
                      2. &x<\/code> means:<\/li>\n<\/ol>\n\n\n\n
                        address of x<\/code><\/pre>\n\n\n\n
                          \n
                        1. *ptr<\/code> means:<\/li>\n<\/ol>\n\n\n\n
                          value at that address<\/code><\/pre>\n\n\n\n
                            \n
                          1. ...int<\/code> means:<\/li>\n<\/ol>\n\n\n\n
                            zero or more integers<\/code><\/pre>\n\n\n\n
                              \n
                            1. A method is basically a function with a receiver<\/strong>:<\/li>\n<\/ol>\n\n\n\n
                              func (user User) Greet()<\/code><\/pre>\n\n\n\n
                              \n\n\n\n
                              51. One Final Example Combining the Important Concepts<\/h1>\n\n\n\n
                              Now revisit your example:<\/p>\n\n\n\n
                              package main\n\nimport (\n    \"fmt\"\n    \"strings\"\n)\n\nfunc summarize(\n    label string,\n    callCount *int,\n    scores ...int,\n) (string, int) {\n\n    \/\/ Modify the original calls variable\n    (*callCount)++\n\n    \/\/ Create total\n    total := 0\n\n    \/\/ Loop through all scores\n    for _, score := range scores {\n\n        \/\/ Add each score\n        total += score\n    }\n\n    \/\/ Return two values\n    return strings.ToUpper(label), total\n}\n\nfunc main() {\n\n    calls := 0\n\n    label, total := summarize(\n        \"team score\",\n        &calls,\n        10,\n        20,\n        30,\n    )\n\n    fmt.Println(label)\n    fmt.Println(\"Total:\", total)\n    fmt.Println(\"Function calls:\", calls)\n}<\/code><\/pre>\n\n\n\n
                              Output:<\/p>\n\n\n\n
                              TEAM SCORE\nTotal: 60\nFunction calls: 1<\/code><\/pre>\n\n\n\n
                              This tiny program demonstrates:<\/p>\n\n\n\n
                              \u2713 function declaration\n\n\u2713 normal parameter\n    label string\n\n\u2713 pointer parameter\n    callCount *int\n\n\u2713 variadic parameter\n    scores ...int\n\n\u2713 multiple return values\n    (string, int)\n\n\u2713 pointer dereferencing\n    (*callCount)++\n\n\u2713 local variable\n    total := 0\n\n\u2713 range loop\n    range scores\n\n\u2713 blank identifier\n    _\n\n\u2713 return\n    return ...\n\n\u2713 calling another package's function\n    strings.ToUpper()\n\n\u2713 receiving multiple values\n    label, total := ...\n\n\u2713 address operator\n    &calls<\/code><\/pre>\n\n\n\n
                              The master mental model<\/h2>\n\n\n\n
                              Whenever you see a Go function, don’t try to understand the entire line at once.<\/p>\n\n\n\n
                              Read it in this order:<\/p>\n\n\n\n
                              1. What is the function called?\n\n2. What goes IN?\n\n3. Does anything use a pointer?\n\n4. Is anything variadic?\n\n5. What happens inside?\n\n6. What comes OUT?<\/code><\/pre>\n\n\n\n
                              For example:<\/p>\n\n\n\n
                              func summarize(\n    label string,\n    callCount *int,\n    scores ...int,\n) (string, int)<\/code><\/pre>\n\n\n\n
                              read it as:<\/p>\n\n\n\n
                              NAME\n\u2502\n\u2514\u2500\u2500 summarize\n\nINPUT\n\u2502\n\u251c\u2500\u2500 label      \u2192 string\n\u251c\u2500\u2500 callCount  \u2192 pointer to int\n\u2514\u2500\u2500 scores     \u2192 many integers\n\nOUTPUT\n\u2502\n\u251c\u2500\u2500 string\n\u2514\u2500\u2500 int<\/code><\/pre>\n\n\n\n
                              Once you develop this habit, even complicated Go function declarations become much easier to read.<\/p>\n","protected":false},"excerpt":{"rendered":"
                              A function is one of the most important building blocks in Go. If you understand functions properly, concepts such as methods, interfaces, goroutines, error handling, defer, callbacks,… <\/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-1076","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1076","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=1076"}],"version-history":[{"count":2,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1076\/revisions"}],"predecessor-version":[{"id":1079,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1076\/revisions\/1079"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/media?parent=1076"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/categories?post=1076"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/tags?post=1076"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}