funcs, func expressions, closure, returning funcs, recursion, the stack -gopherlabs
0 likes154 views
The document provides an overview of functions in Go including function definitions, parameters and arguments, returning values, func expressions, closures, callbacks, recursion, and defer statements. It begins with basic concepts like defining functions and calling them, then covers more advanced topics like func expressions where a function is assigned to a variable, closures which allow functions to access variables from the enclosing scope, callbacks where functions are passed as arguments to other functions, and recursion where functions call themselves. Examples are provided for each concept using Go playground links. The document aims to explain how functions work and behave as first-class citizens in Go, providing a hands-on tutorial of key function-related ideas.
![● another callback
“If you’ve done functional programming like Lisp or Haskell, this way of dealing with functions is super common; it’s an
approach to development; you get used to passing functions around. Go allows you to do that [passing functions around]
but it’s not the most common way of writing code. The more normal way you’d write code [for something like the code
above] would just be a simple for loop. For loops are easy to understand.”
~ Caleb Doxsey](https://image.slidesharecdn.com/func-200224235312/85/funcs-func-expressions-closure-returning-funcs-recursion-the-stack-gopherlabs-30-320.jpg)
funcs, func expressions, closure, returning funcs, recursion, the stack -gopherlabs
- 1. An Ultimate GopherLabs Hands-on Labs funcs, func expressions, closure, returning funcs, recursion, the stack
- 2. • Docker Community Leader , Bangalore • Author :- lightweight Kubernetes with k3s with packt Publication • Gopherlabs – 500+ tutorials • Okteto – Kubernetes For Developer , Bangalore Meetup Organizer Who Am I? @BiradarSangam Sangam Biradar EngineITops.com
- 3. ● function ● functions in go are types ○ functions behave as types in go ○ use like any other type ■ declare them as variables ■ pass functions around just as you'd pass types around ■ pass functions just like any other argument / parameter ● pass them into functions as arguments ● return them from functions ■ declare functions inside other functions ○ similar to JavaScript
- 4. ● func main – the entry to your program
- 5. ● parameter and arguments https://play.golang.org/p/gwfVXFxKi21 parameter argument
- 6. ● calling func https://play.golang.org/p/V_yybIPjmiN calling a function You need the ()
- 13. https://play.golang.org/p/cJL4Z6ksIRC parameter name does not have to match argument name
- 14. ● Exercise Write a function which takes an integer and returns two values: ● the integer divided by 2 ● whether or not the integer is even (true, false) For example ● half(1) should return (0, false) ● half(2) should return (1, true).
- 15. ● func expression - setting a variable equal to a function this is not a func expression this is our code before using a func expression
- 16. ● func expression func expression setting a variable equal to a func the scope of greeting is func main() this is not a func expression this is a func expression https://play.golang.org/p/ux-KmWuN0Lf
- 17. https://play.golang.org/p/KQrnwYAZHil interesting to look at greeting’s type
- 18. ● func expression another func expression setting a variable equal to a func https://play.golang.org/p/nulzHEt-d96
- 19. ● Closure my definition: “one thing enclosing another thing”
- 20. ● closure https://play.golang.org/p/p3kWmzBrLcx closure func main encloses func increment closure helps us limit the scope of variables that are used by multiple functions without closure, for two or more funcs to have access to the same variable, that variable would need to be package scope func main is enclosing increment; increment is enclosing x
- 21. ● not closure https://play.golang.org/p/H5tfU6SUocI not using closure closure helps us limit the scope of variables that are used by multiple functions without closure, for two or more funcs to have access to the same variable, that variable would need to be package scope
- 22. ● returning a func https://play.golang.org/p/9t8CtlKWHwS closure closure helps us limit the scope of variables that are used by multiple functions without closure, for two or more funcs to have access to the same variable, that variable would need to be package scope
- 23. another func expression setting a variable equal to a func returning a func (not part of func expression) a func is returned
- 25. ● callback - passing a func as an argument func visit takes two arguments a slice of ints another func the callback pass in the slice of ints https://play.golang.org/p/yyV7chHfFR6
- 26. ● passin a func the callback func visit takes two arguments a slice of ints another func the callback pass in the slice of ints pass in a func the callback
- 27. ● How its work … the func passed as an argument (the callback) is assigned to the parameter “callback” and then gets used
- 30. ● another callback “If you’ve done functional programming like Lisp or Haskell, this way of dealing with functions is super common; it’s an approach to development; you get used to passing functions around. Go allows you to do that [passing functions around] but it’s not the most common way of writing code. The more normal way you’d write code [for something like the code above] would just be a simple for loop. For loops are easy to understand.” ~ Caleb Doxsey
- 31. ● recursion - a func that can call itself ● factorial(4) ○ returns: 4 * factorial(3) ● factorial(3) ○ returns: 3 * factorial(2) ● factorial(2) ○ returns: 2 * factorial(1) ● factorial(1) ○ returns: 1 * factorial(0) ● factorial(0) ○ returns: 1 ---------------------------------------------------- returns: 4 * 3 * 2 * 1 * 1 ---------------------------------------------------- The End Result: ● 4 * 3 * 2 * 1 https://play.golang.org/p/ZG03lKqaipD
- 32. ● recursion ● You can always use loops to solve any problem that can be solved with recursion. ● Loops are more performant than recursion. This is called the base case
- 33. ● defer - run this at the last possible moment https://play.golang.org/p/QHsLIbenzxa
- 34. ●
- 35. ● defer doc
- 38. Review ● func main() {} ● calling a function ● greeting() ● parameters vs arguments ○ two params ○ variadic ■ …params ■ args... ● returns ○ named returns ○ multiple returns ● variable shadowing ● func expression ○ setting a variable equal to a function ○ greeting := func(){<code here>} ■ greeting’s type is func ● closure ○ one thing enclosing another ○ helps us limit scope of variables ● returning a func ○ functional programming ● callback ○ passing a func as an argument ● recursion ● defer ● the stack ○ the order in which functions are called