A variadic function accept varying numbers of arguments.
To declare a variadic function, the type of of the final parameter is preceded by an ellipsis, “…”
func sum(vals ...int) int {}…int ellipsis defined a function can be called with any number of arguments of this type
vals is []int slice, can be access this slice using index or for..range
type Point struct {
x float64
y float64
}The Point struct type has two fields, x and y of float64
func (p Point) DistToOrgin() {
t := math.Pow(p.x, 2) + math.Pow(p.y, 2)
return math.Sqrt(t)
}A method is defined with use of the keyword “func” just like a definition of the function. Just after func keyword, the defined fields of struct used in the body of code of the function as a receiver. It takes a variable of struct type “p Point” as a receiver (input) to the method name DistToOrgin().
func foo() func() int { }
A function name foo() without parameters/arguments return anonymous function without parameter/arguments return an int type. Empty body
1 func foo() func() int {
2 return func() int {
3 return 1
4 }
5
6 }In the line 2, the return for calling func foo() and follow up with the code of anonmoys function func() with return int type signature. In this body of anonymous func() on line 3 the code return 1.
So when a func foo() called, the body code of func foo() executed instead of just return the results. The results of func foo() pass into anonymous function to be process and then return the results.
package main
import (
"fmt"
)
// n! = n * (n-1) * (n-2)...* 2 * 1
// code limited to return value based
// int type interger range
func factorial(num int) int {
if num == 0 {
return 1
}
f := num
for i:=num; i>=3; i-- {
f = f * (i - 1)
}
return f
}
func main() {
// Dn't used value beyond int type integer range
fmt.Println("Factorial:",factorial(20))
}package main
import "fmt"
// n! = n * (n-1) * (n-2)...* 2 * 1
// code limited to return value based
// int type interger range
// Recursive function
func fact(n int) int {
// terminate the loop with return
if n == 0 {
return 1
}
// return call fact() function is recursively repeteatly
return n * fact(n - 1)
}
func main() {
fmt.Println(fact(5))
}Go functions may be closures. A closure is a function value that references variables from outside its body. The function may access and assign to the referenced variables; in this sense the function is “bound” to the variables
package main
import "fmt"
func adder() func(int) int {
sum := 0
return func(x int) int {
sum += x
return sum
}
}
func main() {
pos, neg := adder(), adder()
for i := 0; i < 10; i++ {
fmt.Println(
pos(i),
neg(-2*i),
)
}
}
Let’s utilize a memoization technique to speed up our Fibonacci calculation.
Memoization is an optimization technique used to increase performance by storing the results of expensive function calls and returning the cached result when the same input occurs again.
type Memoized func(int) int
var fibMem MemoizedThe Fibonacci sequence is a sequence of numbers where each number is equal to the previous two numbers added together. Here’s an example of this:
1 1 2 3 5 8 13 21 34So, 1 plus 1 is 2, 2 plus 3 is 5, 5 plus 8 is 13, and so on.
The Rule is xn = xn−1 + xn−2
where:
Let’s use the Fibonacci sequence to help illustrate a number of concepts.
A recursive function is a function that calls itself in order to break down complex input into simpler ones.
func Fibonacci(x int) int {
if x == 0 {
return 0
} else if x <= 2 {
return 1
} else {
return Fibonacci(x-1) + Fibonacci(x-2)
}
}Try this in Go Playground (restrict to 2 digit number only, otherwise timeout by the Go Playground server.
func namedGreeting(name string) {
fmt.Printf("Hey %s!n", name)
}func anonymousGreeting() func(string) {
return func(name string) {
fmt.Printf("Hey %s!n", name)
}
}func main() {
namedGreeting("Alice")
greet := anonymousGreeting()
greet("Bob")
func(name string) {
fmt.Printf("Hello %s!n", name)
}("Cindy")
}