Go函數式編程篇

函數式編程並不是Go語言所特有

函數與閉包

Go語言閉包應用：

1）不須要修飾如何訪問自由變量

2）沒有Lambda表達式，可是有匿名函數  （其實兩者作的事情差很少，同樣）

Go語言對函數式編程主要是體如今閉包上面。

函數式編程 vs 函數指針：

函數是一等公民：參數，變量，返回值均可以是函數（c++裏只有函數指針，Java裏函數只是一個名字）

高階函數：函數的參數能夠是一個函數

函數-->閉包

函數閉包：

其餘語言中對閉包的支持

Python中的閉包：python原生支持閉包、使用_closure_來查看閉包內容
def adder():
      sum = 0
      def  f(value):
            nonlocal sum
            sum += value
            return sum 
      return f

C++中的閉包：過去stl或者boost帶有相似庫；C++11及之後：支持閉包   如下是C++14下編譯經過的
auto adder(){
　　auto sum = 0;
   return [-] (int value) mutable {
　　　　sum += value;
　　　　return sum;
　　}
} 

Java中的閉包：1.8之後：使用Function接口和Lambda表達式來建立函數對象  函數自己不能做爲參數和返回值的
1.8之前 匿名類或Lambda表達式均支持閉包
Function<Integer,Integer> adder() {
　　final Holder<Integer> sum = new Holder<>(0);
   return (Integer value) -> {
　　　　sum.value += value;
　　　　return sum.value;
　　}
}

 

 

「正統」函數式編程

1）不可變性：不能有狀態，只有常量和函數 2）函數只能有一個參數  可是學習的這篇視頻不做這個嚴格規定

示例fib

目錄

adder.go

package main

import "fmt"
//閉包
func adder() func(int) int {
    sum := 0
    return func(v int) int {
        sum += v
        return sum
    }
}
//實現正統函數式編程不能有狀態 應該放在一個新的函數裏面
type iAdder func(int) (int, iAdder)

func adder2(base int) iAdder {
    return func(v int) (int, iAdder) {
        return base + v, adder2(base + v)
    }
}

func main() {
    // a := adder() is trivial and also works.
    a := adder2(0)
    for i := 0; i < 10; i++ {
        var s int
        s, a = a(i)
        fmt.Printf("0 + 1 + ... + %d = %d\n",
            i, s)
    }
}

 

輸出：

0 + 1 + ... + 0 = 0
0 + 1 + ... + 1 = 1
0 + 1 + ... + 2 = 3
0 + 1 + ... + 3 = 6
0 + 1 + ... + 4 = 10
0 + 1 + ... + 5 = 15
0 + 1 + ... + 6 = 21
0 + 1 + ... + 7 = 28
0 + 1 + ... + 8 = 36
0 + 1 + ... + 9 = 45

Process finished with exit code 0

 

fib.go

package fib

// 1, 1, 2, 3, 5, 8, 13, ...
func Fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

　　

main.go

package main

import (
    "bufio"
    "fmt"
    "io"
    "strings"

    "learngo/functional/fib"
)

type intGen func() int

func (g intGen) Read(
    p []byte) (n int, err error) {
    next := g() //取下一個元素
    if next > 10000 {//達到10000以上結束
        return 0, io.EOF
    }
    s := fmt.Sprintf("%d\n", next)//轉換成字符串

    // TODO: incorrect if p is too small!
    return strings.NewReader(s).Read(p)
}
//把裏面的內容打印出來
func printFileContents(reader io.Reader) {
    scanner := bufio.NewScanner(reader)

    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

func main() {
    var f intGen = fib.Fibonacci()
    printFileContents(f)
}

　　

 輸出：

1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765

Process finished with exit code 0

 示例遍歷二叉樹

使用函數遍歷二叉樹

tree詳情見以前的https://www.cnblogs.com/ycx95/p/9361122.html