Go函数及与函数相关机制 【Go语言圣经笔记】

func name(param-list) (res-list) {
    body
}

// 注意res-list隐含了函数返回值可以是多个
// 除了python和go之外，其他主流语言的函数都是只返回一个值

func hypot(x, y float64) float64 {
    return math.Sqrt(x*x + y*y)
}
fmt.Println(hypot(3, 4)) // "5"

func f(i, j, k int, s, t string)                { /*...*/ }
func f(i int, j int, k int, s string, t string) { /*...*/ }

func add(x int, y int) int { return x+y }
func sub(x, y int) (z int ) { z = x-y; return}
func first(x int, _ int) int { return x }
func zero(int, int) int {return 0}

fmt.Printf("%T\n", add)   // func(int, int) int
fmt.Printf("%T\n", sub)   // func(int, int) int
fmt.Printf("%T\n", first) // func(int, int) int
fmt.Printf("%T\n", zero)  // func(int, int) int

package math

func Sin(x float) float  // implented in asseembly language 

package html

type Node struct {
    Type                    NodeType
    Data                    string
    Attr                    []Attrubute
    FirstChild, NextSibling *Node
} // 这是树的第二种定义方法

type NodeType int32

const (
    ErrorNode NodeType = iota
    TextNode
    DocumentNode
    ElementNode
    CommentNode
    DoctypeNode
)

type Attribute struct {
    Key, Val string
}

func Parse(r io.Rearder) (*Node, error)

package main

import (
    "fmt"
    "os"
    "golang.org/x/net/html"
)

func main() {
    doc, err := html.Parse(os.Stdin)
    if err != nil {
        fmt.Fprintf(os.Stderr, "findlink1: %v\n", err)
        os.Exit(1)
    }
    for _, link := range visit(nil, doc) {
        fmt.Println(link)
    }
}

// visit appends to links each link found in n and returns the result
func visit(links []string, n *html.Node) []string {
    for n.Type == html.ElementType && n.Data == "a" {
        for _, a := range n.Attr{
            if a.Key == "href" {
                links = append(links, a.Val)
            }
        }
    }
    for c := n.FirstChild; c != nil; c = NextSibling {
        links = visit(links, c)
    }
    return links
}

$ go build gopl.io/ch1/fetch
$ go build gopl.io/ch5/findlinks1
$ ./fetch https://golang.org | ./findlinks1
#
/doc/
/pkg/
/help/
/blog/
http://play.golang.org/
//tour.golang.org/
https://golang.org/dl/
//blog.golang.org/
/LICENSE
/doc/tos.html
http://www.google.com/intl/en/policies/privacy/

func main() {
    doc, err := html.Parse(os.Stdin)
    if err != nil {
        fmt.Fprintf(os.Stderr, "outline: %v\n", err)
        os.Exit(1)
    }
    outline(nil, doc)
}

func outline(stack []string, n *html.Node) {
    if n.Type == html.ElementNode {
        stack = append(stack, n.Data)
        fmt.Println(stack)
    }
    for c := n.FirstChild; c != nil; c = c.NextSibling {
        outline(stack, c)
    }
}

// 此时stack依然是未调用 outline方法之前的状态

$ go build gopl.io/ch5/outline
$ ./fetch https://golang.org | ./outline
[html]
[html head]
[html head meta]
[html head title]
[html head link]
[html body]
[html body div]
[html body div]
[html body div div]
[html body div div form]
[html body div div form div]
[html body div div form div a]
...

func mian() {
    for _, url := range os.Args[1:] {
        links, err := findLinks(url)
        if err != nil {
            fmt.Fprintf(os.Stderr, "findLinks2: %v\n", err)
            continue
        }
        for _, link := range links {
            fmt.Println(link)
        }
    }
}

// findLinks performs an HTTP GET request for url
// parse the response as HTML, and extracts and return the link
func findLinks(url string) ([]string, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    if resp.StatusCode != http.StatusOK {
        resp.Body.Close()
        return nil, fmt.Errorf("getting %s: %s, url, resp.Status")
    }
    doc, err := http.Parse(resp.Body)
    resp.Body.Close()
    if err != nil {
        return nil, fmt.Fprintf("parsing %s as HTML: %v", url, err)
    }
    return visit(nil, doc), nil
}

links, err := findLinks(url)

links, _ := findLinks(url) // errors ignored

func findlinsLog(url string) ([]string, error) {
    log.Printf("findLinks %s", url)
    return findLinks(url)
}

log.Println(findLinks(url))
links, err := findLinks(url)
log.Println(links, err)

func Size(rect image.Rectangle) (width, height int)
func Split(path string) (dir, file string)
func HourMinSec(t time.Time) (hour, minute, second int)

// CountWordsAndImages does an HTTP GET request for the HTML
// docment url and returns the number of words and iamges in it
func CountWordAndImages(url string) (words, image int, err error) {
    resp, err := http.Get(url)
    if err != nil {
        return
    }
    doc, err := html.Parse(resp.Body)
    resp.Body.Close()
    if err != nil {
        err = fmt.Errorf("parsing HTML: %s", err)
        return
    }
    words, iamges = countWordsAndImages(doc)
}

func countWordsAndImages(n *html.Node) (words, image int)

return words, images, err

value, ok := cache.LookUp(key)
if !ok {
    // ...cache[key] does not exist...
}

fmt.Println(err)
fmt.Printf("%v", err)

resp, err := http.Get(url)
if err != nil {
    return nil, err
}

doc, err := html.Parse(resp.Body)
resp.Body.Close()
if err != nil {
    return nil, fmt.Errorf("parsing %s as HTML: &v", url, err)
}

genesis: crashed: no parachute: G-switch failed: bad relay orientation

// WaitForServer attempts to contact the server of a URL.
// It tries for one minute using exponential back-off.
// It reports an error if all attempts fail.

func WaitForServer(url string) error {
    const timeout = 1 * time.Minute
    deadline := time.Now().Add(timeout)
    for tries := 0; time.Now().Before(deadline); tries++ {
        _, err := http.Head(url)
        if err == nil {
            return nil
        }
        log.Printf("server not responding (%s): retrying...", err)
        time.Sleep(time.Second << uint(tries))  // exponetial back-off
    }
    return fmt.Errorf("server %s failed to respond after %s", url, timeout)
}

// (In function main.)
if err := WaitForServer(url): err != nil {
    fmt.Fprintf(os.Stderr, "Site is down: %v\n", err)
    os.Exit(1)  // 强制退出
}

if err := WaitForServer(url); err != nil {
    log.Fatalf("Site is down: %v\n", err)
}

2006/01/02 15:04:05 Site is down: no such domain:
bad.gopl.io

log.SetPrefix("wait: ")
log.SetFlags(0)

if err := Ping(); err != nil {
    log.Printf("ping failed: %v; networking disabled", err)
}

if err := Ping(); err != nil {
    fmt.Fprintf(os.Stderr, "ping failed: %v; networking disabled\n", err)
} 

dir, err := ioutil.TempDir("", "scratch")
if err != nil {
    return fmt.Errorf("failed to create temp dir: %v", err)
}

// ...use temp dit...
os.RemoveAll(dir)  // gnore errors; $TMPDIR is cleaned periodically

package io

import "errors"

// EOF is the error returned by Read when no more input is available.
var EOF = errors.New("EOF")

in := bufio.NewReader(os.Stdin)
for {
    r, _, err := in.ReadRune()
    if err == io.EOF {
        break // finshed reading
    }
    if err != nil {
        return fmt.Errorf("read failed:%v", err)
    }
}
// .. use r ..

    func square(n int) int { return n*n }
    func negative(n int) int { return -n }
    func product(m, n int) int { return m*n}
    
    f := square
    fmt.Println(f(3))  // 9
    
    f := negative
    fmt.Println(f(3))  // -3
    fmt.Printf("%T\n", f)  // func(int) int
    
    f = product  // compile error: can't assign func(int, int) int to func(int) int

    var f func(int) int  // 只是声明了函数类型 并未指定具体函数
    f(3)  // 此处f的值为nil, 会引起panic错误

    var f fun(int) int
    if f != nil {
        f(3)
    }

func add1(r rune) rune { return r+1 }

fmt.Println(strings.Map(add1, "HAL-9000"))
fmt.Println(strings.Map(add1, "VMS"))
fmt.Println(strings.Map(add1, "Admix"))

// forEachNode针对每个结点x,都会调用pre(x)和post(x)。
// pre和post都是可选的。
// 遍历孩子结点之前,pre被调用
// 遍历孩子结点之后，post被调用
// 笔者注：pre是预定义的函数 post是在参数列表内定义的函数
func forEachNode(n *html.Node, pre, post func(n *html.Node)) {
    if pre != nil {
        pre(n)
    }
    for c := n.FirstChild; c != nil; c = c.Nextsibling {
        forEachNode(c, pre, post)
    }
    if post != nil {
        post(n)
    }
}

var depth int
func startElement(n *html.Node) {
    if n.Type == html.ElementNode {
        fmt.Printf("%*s<%s>\n", depth*2, "", n.Data)
        depth++
    }
}

func endElement(n *html.Node) {
    if n.Type == html.ElementNode {
        depth--
        fmt.Printf("%*s<%s>\n", depth*2, "", n.Data)
    }
}

forEachNode(doc, startElement, endElement)

$ go build gopl.io/ch5/outline2
$ ./outline2 http://gopl.io
<html>
  <head>
    <meta>
    </meta>
    <title>
    </title>
    <style>
    </style>
  </head>
  <body>
    <table>
      <tbody>
        <tr>
          <td>
            <a>
              <img>
              </img>
...

strings.Map(func(r rune) rune { return r+1 }, "HAL-9000")

func squares() func() int {
    var x int
    return func() int {
        x++
        return x * x
    }
}

func main() {
    f := squares()
    fmt.Println(f()) // 1
    fmt.Println(f()) // 4
    fmt.Println(f()) // 9
    fmt.Println(f()) // 16
    
    // 笔者注
    // 这非常类似于闭包的作用 事实上就是基于闭包实现
}

// prereqs记录了每个课程的前置课程
var prereqs = map[string][]string {
    "algorithms": {"data structures"}
    "calculus": {"linear algebra"},
    "compilers": {
        "data sturctures",
        "formal language",
        "computer organization",
    },
    "data structure":       {"discrete math"},
    "databases":            {"data structures"},
    "discrete math":        {"intro to programming"},
    "formal languages":     {"discrate math"},
    "networks":             {"operating systems"},
    "operating systems":    {"data sturcture", "computer organization"},
    "programming language": {"data sturcture", "computer organization"}
}

func main() {
    for i, course := range topoSort(prereqs) {
        fmt.Printf("%d:\t%s\n", i+1, course)
    }
}

func topoSort(m map[string][]string) []string {
    var order []string
    seen := make(map[string]bool)
    var vivistAll func(items []string)
    visitAll = func(items []string) {
        for _, item :=  range items {
            if !seen[item] {
                seen[item] = true
                visitAll(m[item])
                order = append(order, item)
            }
        }
    }
    
    var keys []string
    for key := range m {
        keys = append(keys, key)
    }
    sort.String(keys)
    visitAll(keys)
    return order
}

visitAll := func(items []string) {
    // ...
    visitAll(m[item]) // compile error: undefined: visitAll
    // ...
}

1: intro to programming
2: discrete math
3: data structures
4: algorithms
5: linear algebra
6: calculus
7: formal languages
8: computer organization
9: compilers
10: databases
11: operating systems
12: networks
13: programming languages

// Package links provides a link-extraction function.
package links
import (
    "fmt"
    "net/http"
    "golang.org/x/net/html"
)
// Extract makes an HTTP GET request to the specified URL, parses
// the response as HTML, and returns the links in the HTML document.
func Extract(url string) ([]string, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    if resp.StatusCode != http.StatusOK {
    resp.Body.Close()
        return nil, fmt.Errorf("getting %s: %s", url, resp.Status)
    }
    doc, err := html.Parse(resp.Body)
    resp.Body.Close()
    if err != nil {
        return nil, fmt.Errorf("parsing %s as HTML: %v", url, err)
    }
    var links []string
    visitNode := func(n *html.Node) {
        if n.Type == html.ElementNode && n.Data == "a" {
            for _, a := range n.Attr {
                if a.Key != "href" {
                    continue
                }
                link, err := resp.Request.URL.Parse(a.Val)
                if err != nil {
                    continue // ignore bad URLs
                }
                links = append(links, link.String())
            }
        }
    }
    forEachNode(doc, visitNode, nil)
    return links, nil
}

// breadthFirst calls f for each item in the worklist.
// Any items returned by f are added to the worklist.
// f is called at most once for each item.
func breadthFirst(f func(item string) []string, worklist []string)  {
    seen := make(map[string] bool)
    for len(worklist) > 0 {
        items := worklist
        worklist = nil
        for _, item := range items {
            if !seen[item] {
                seen[item] = true
                worklist = append(worklist, f(item)...)
            }
        }
    }
}

func crawl(url string) []string {
    fmt.Println(url)
    list, err :=  links.Extract(url)
    if err != nil {
        log.Print(err)
    }
    return list
}

func main() {
    // Crawl the web breadth-first,
    // starting from the command-line arguments.
    breadthFirst(crawl, os.Args[1:])
}

$ go build gopl.io/ch5/findlinks3
$ ./findlinks3 https://golang.org
https://golang.org/
https://golang.org/doc/
https://golang.org/pkg/
https://golang.org/project/
https://code.google.com/p/go-tour/
https://golang.org/doc/code.html
https://www.youtube.com/watch?v=XCsL89YtqCs
http://research.swtch.com/gotour

var rmdirs []func()
for _, d := range tempDirs() {
    dir := d // NOTE: necessary
    os.Mkdir(dir, 0755) // creates parent directories too
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir)
    })
}
// ...do some work...
for _ rmdir := range rmdirs {
    rmdir()
}

var rmdirs []func()
for _, dir := range tempDirs() {
    os.MkdirAll(dir, 0755)
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir) // NOTE: incorrect!
    })
}

for _, dir := range tempDirs() {
    dir := dir  // declares inner dir as outer inner
}

var rmdirs []func()  // 函数值数组
dirs := tempDirs()
for i := 0; i < len(dirs); i++ {
    os.MkdirAll(dirs[i], 0755) // OK
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dirs[i]) // NOTE: incorrect!
    })
}

func sum(vals...int) int {
    total := 0
    for _, vals := range vals {
        total += val
    }
    return total
}

fmt.Println(sum())           // "0"
fmt.Println(sum(3))          // "3"
fmt.Println(sum(1, 2, 3, 4)) // "10"

values := []int{1, 2, 3, 4}
fmt.Println(sum(values...))  // 10

func errorf(linenum int, format string, args ...interface{}) {
    fmt.Fprintf(os.Stderr, "Line %d: ", linenum)
    fmt.Fprintf(os.Stderr, format, args...)
    fmt.Fprintln(os.Stderr)
}
linenum, name := 12, "count"
errorf(linenum, "undefined: %s", name)
// line 12: undefined: count

func title(url string) error {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    // check content-type
    ct := resp.Header.Get("Content-Type")
    if ct != "text/html" && !string.HasPrefix(ct, "text/html;") {
        resp.Body.Close()
        return fmt.Errorf("%s has type %s, not text/html, url, ct")
    }
    doc, err := html.Parse(resp.Body)
    resp.Body.Close()
    if err != nil {
        return fmt.Errorf("parsing %s as HTML: %v", url, err)
    }
    visitNode := func(n *html.Node) {
        if n.Type == html.ElementNode && n.Data == "title" && n.FirstChild != nil {
            fmt.Println(n.FirstChild.Data)
        }
    }
    forEachNode(doc, visitNode, nil)
    return nil
}

$ go build gopl.io/ch5/title1
$ ./title1 http://gopl.io
The Go Programming Language
$ ./title1 https://golang.org/doc/effective_go.html
Effective Go - The Go Programming Language
$ ./title1 https://golang.org/doc/gopher/frontpage.png
title: https://golang.org/doc/gopher/frontpage.png has type image/png, not text/html

func title(url string) error {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()  // 函数中的defer语句会在函数结束时运行 无论结束状态如何 
    // check content-type
    ct := resp.Header.Get("Content-Type")
    if ct != "text/html" && !string.HasPrefix(ct, "text/html;") {
        return fmt.Errorf("%s has type %s, not text/html, url, ct")
    }
    doc, err := html.Parse(resp.Body)
    if err != nil {
        return fmt.Errorf("parsing %s as HTML: %v", url, err)
    }
    visitNode := func(n *html.Node) {
        if n.Type == html.ElementNode && n.Data == "title" && n.FirstChild != nil {
            fmt.Println(n.FirstChild.Data)
        }
    }
    forEachNode(doc, visitNode, nil)
    return nil
}

package ioutil
func ReadFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    return ReadAll(f)
}

var mu sync.Mutex
var m = make(map[string]int)
func lookup(key string) int {
    mu.Lock()
    defer mu.Unlock()
    return m[key]
}

func bigSlowOperation() {
    defer trace("bigSlowOperation")() // extra parentheses
    // trace 返回一个函数 加()表示调用这个函数
    // .. lots of work
    time.Sleep(10 * time.Second)
}

func trace(msg string) func() {
    start := time.Now()
    log.Printf("enter %s", msg)
    return func() {
        log.Printf("exit %s (%s)", msg, time.Since(start))
    }
}

$ go build gopl.io/ch5/trace
$ ./trace
2015/11/18 09:53:26 enter bigSlowOperation
2015/11/18 09:53:36 exit bigSlowOperation (10.000589217s)

func Double(x int) int {
    return x + x
}

func double(x int) (res int) {
    defer func() { fmt.Printf("double(%d) = %d\n", x, res) }  ()
    // 这里为什么有两个括号
    // func(）创建了一个匿名函数 ()调用了这个匿名函数
}

_ = double(4)
// double(4) = 8

func triple(x int) (res int) {
    defer func() { res += x} ()
    return double(x)
}

for _, filename := range filenames {  // for 循环
    f, err := os.Open(filename)  // 因为defaer 后调用先运行的特性 循环结束时才会调用最后一次调用的函数
    if err != nil {
        return err
    }
    defer f.Close() 
}

for _, filename := range filenames {
    if err := doFile(filename); err != nil {
        return err
    }
}
func doFile(filename string) error {
    f, err = os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close()
    // ...
}

// Fetch downloads the URL and returns the
// name and length of the local file.
func fetch(url string) (filename string, n int64, err error) {
    resp, err := http.Get(url)
    if err != nil {
        return "", 0, err
    }
    defer resp.Body.Close()
    local := path.Base(resp.Request.URL.Path)
    if local == "/" {
        local = "index.html"
    }
    f, err := os.Create(local)
    if err != nil {
        return "", 0, err
    }
    n, err = io.Copy(f, resp.Body)
    // Close file, but prefer error from Copy, if any.
    if closeErr := f.Close(); err == nil {
        err = closeErr
    }
    return local, n, err
}

switch s := suit(drawCard()); s {
    case "Spades":
    case "Hearts":
    case "Diamonds":
    case "Clubs":
    default:
        panic(fmt.Sprintf("invalid suit % q", s))  // 预期之外的逻辑分支
}

func Reset(x *Buffer) {
    if x == nil {
        panic("x is nil") // 
    }
    x.elements = nil
}

package regexp
func Compile(expr string) (*reqexp, error) { /*...*/ }
func MustCompile(expr string) *Regexp {
    re, err := Compile(expr)
    if err != nil {
        panic(err)
    }
    
    return re
}

var httpSchemeRE = regexp.MustCompile(`^https?:`)  // http or https

func main () {
    f(3)
}

func f(x int) {
    fmt.Printf("f(%d)\n", x+0/x) // it will panic if x == 0
    defer fmt.Printf("defer %d\n", x)
    f(x - 1)
}

f(3)
f(2)
f(1)
defer 1
defer 2
defer 3
// f(0) panic

panic: runtime error: integer divide by zero
main.f(0)
src/gopl.io/ch5/defer1/defer.go:14
main.f(1)
src/gopl.io/ch5/defer1/defer.go:16
main.f(2)
src/gopl.io/ch5/defer1/defer.go:16
main.f(3)
src/gopl.io/ch5/defer1/defer.go:16
main.main()
src/gopl.io/ch5/defer1/defer.go:10

f(3)
f(2)
f(1)
defer 1
defer 2
defer 3
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.f(0x0)
        /Users/admin/go/src/test/main/test.go:8 +0x1e5
main.f(0x1)
        /Users/admin/go/src/test/main/test.go:10 +0x185
main.f(0x2)
        /Users/admin/go/src/test/main/test.go:10 +0x185
main.f(0x3)
        /Users/admin/go/src/test/main/test.go:10 +0x185
main.main()
        /Users/admin/go/src/test/main/test.go:14 +0x2a

Process finished with exit code 2

func main() {
    defer printfStack()
    f(3)
}

func printStack() {
    var buf [4096]byte
    n := runetime.Stack(buf[:], false)
    os.Stdout.Write(buf[:n])
}

goroutine 1 [running]:
main.printStack()
src/gopl.io/ch5/defer2/defer.go:20
main.f(0)
src/gopl.io/ch5/defer2/defer.go:27
main.f(1)
src/gopl.io/ch5/defer2/defer.go:29
main.f(2)
src/gopl.io/ch5/defer2/defer.go:29
main.f(3)
src/gopl.io/ch5/defer2/defer.go:29
main.main()
src/gopl.io/ch5/defer2/defer.go:15

func Parse(input string) (s *Syntax, err error) {
    defer func() {  // 第一个括号 匿名函数
        if p := recover(); p != nil {
            err = fmt.Errorf("internal error: %v", p)
        }
    }()  // 最后一个括号表示发生了函数调用 即调用了匿名函数
    // ...parse...
}

// soleTitle returns the text of the first non-empty title element in doc
// and an error if there was not exactly one

func soleTitle(doc *html.Node) (title string, err error) {
    type bailout struct{}
    defer func() {
        switch p := recover(); p {
        case nil:      // no panic do nothing
        case bailout{} // expected panic defined print error
            err = fmt.Errorf("multiple title elements")
        default:
            panic(p)
        }
    }()
    
    // baild out of recursion if we find more than one nonempty title
    forEachNode(doc, func(n *html.Node) {
        if n.Type == html.ElementNode && n.Data == "title" & n.FirstChild != nil {
            if title != "" {
                panic(bailout{})  // multiple title elems
            }
            title = n.FirstChild.Data
        }
    }, nil)
    
    if title == "" {
        return "", fmt.Errorf("no title elem")
    }
    return title, nil
}