Go语言的斐波那契数量。
package main
import (
"fmt"
)
func fibonacci(n int) int {
if n <= 2 {
return 1
}
return fibonacci(n-1) + fibonacci(n-2)
}
func main() {
for i := 1; i <= 10; i++ {
fmt.Println(fibonacci(i))
}
}
package main
import (
"fmt"
)
func fib(n int) int {
one, two := 1, 0
for i := 1; i < n; i++ {
one, two = one+two, one
}
return one
}
func main() {
for i:= 1; i <= 10; i++ {
fmt.Println(fib(i))
}
}
package main
import(
"fmt"
)
var se chan int
func f() int {
return <-se
}
func lazy() chan int {
temp := make(chan int)
one, two := 1,0
go func() {
temp <- one
for {
one, two = one+two, one
temp <- one
}
}()
return temp
}
func main() {
se = lazy()
for i := 0; i < 10; i++ {
fmt.Println(f())
}
}
Go语言函数参数传递。
package main
import (
"fmt"
)
//值传递, 参数为切片
func modify3(a []int) {
a = []int{3, 4}
}
//引用传递, 参数为切片
func modify4(a []int) {
a[0] = 3
}
func main() {
var arr []int = []int{1, 2}
fmt.Println(arr)
modify3(arr)
fmt.Println(arr)
modify4(arr)
fmt.Println(arr)
}
package main
import (
"fmt"
)
//自定义类型
type MyType struct {
a int
}
//值传递
func modify1(myType MyType) {
myType.a = 1
}
//引用传递
func modify2(myType *MyType) {
myType.a = 1
}
func main() {
myType := MyType{0}
fmt.Println(myType.a)
modify1(myType)
fmt.Println(myType.a)
modify2(&myType)
fmt.Println(myType.a)
}
package main
import(
"fmt"
)
//定义可选参数
type Options struct {
one string
two int
three bool
}
//使用struct来聚合可变参数
func f1(a int, options Options){
fmt.Println(options.one)
fmt.Println(options.two)
fmt.Println(options.three)
}
//使用interface{} 接口来统一变量类型
func f2(a int, values ...interface{}) {
for _, v := range values {
switch v.(type) {
case string:
fmt.Println("string: ", v.(string))
case int:
fmt.Println("int: ", v.(int))
case bool:
fmt.Println("bool: ", v.(bool))
}
}
}
func main() {
fmt.Println("f1: ")
f1(3, Options{one:"haha", two:10, three:true })
fmt.Println("f2:")
f2(3, "haha", 10, true)
}
/* 函数的调用方式
1. 普通函数
2. 函数闭包
3. 匿名函数
4. 方法调用
*/
package main
import (
"fmt"
)
type MyType int
func (myType MyType)f() {
fmt.Println("方法函数的调用")
}
//普通函数
func f() {
fmt.Println("普通函数")
}
func main() {
f();
//函数闭包x
x := func(){
fmt.Println("闭包调用")
}
//用闭包名调动
x()
//匿名函数的调用
//()代表调用
func() {
fmt.Println("匿名函数调用")
}()
//定义类型变量,进行方法调用
var myType MyType
myType.f()
}
package main
import (
"log"
)
type ByteSlice []byte
//指针和值传递
func(slice ByteSlice) Append1(data []byte)[]byte {
slice = append(slice, data...)
log.Println("in Append1 func: ", string(slice))
return slice
}
func (slice *ByteSlice) Append2(data []byte) {
lenSlice := len(*slice)
lenNewSlice := lenSlice + len(data)
newSlice := make([]byte, lenNewSlice)
copy(newSlice[0:lenSlice], *slice)
copy(newSlice[lenSlice:lenNewSlice], data)
*slice = newSlice
}
func main() {
var a ByteSlice
a = []byte("hello")
b := a.Append1([]byte(" world1"))
log.Println("main a: ", string(a))
log.Println("main b: ", string(b))
log.Println("a: ", string(a))
a.Append2([]byte("world2"))
log.Println("a: ", string(a))
}