Golang 函数的应用创新：扩展技术边界

func Add(a, b int) int {
    return a + b
}

func Square(n int) int {
    return n * n
}

func AddAndSquare(a, b int) int {
    return Add(a, b)
}

func CreateCounter() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

func main() {
    counter := CreateCounter()
    fmt.Println(counter()) // 1
    fmt.Println(counter()) // 2
    fmt.Println(counter()) // 3
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
    "time"
)

// ReaderWithTimeout reads from a file and sets a timeout for each read operation. 它使用闭包来跟踪读取时间和错误。
func ReaderWithTimeout(path string, timeout time.Duration) (*bufio.Reader, error) {
    // 创建一个通道，用于当读取超时时暂停读取操作。
    errorChan := make(chan error)
    // 创建一个带有超时的 bufio.Reader。
    reader := bufio.NewReader(os.Open(path))

    go func() {
        defer close(errorChan)
        timeoutTimer := time.NewTimer(timeout)
        // 循环读取文件，直到读取完毕或超时。
        for {
            _, err := reader.ReadString('\n')
            if err != nil {
                // 超时或文件读取错误，发送错误到 channel 并退出循环。
                errorChan <- err
                break
            }
            // 重置超时计时器。
            timeoutTimer.Reset(timeout)
        }
    }()

    ticker := time.NewTicker(200 * time.Millisecond)
    defer ticker.Stop()
    for {
        select {
        case err := <-errorChan:
            // 从 errorChan 中接收到错误，返回错误。
            return nil, err
        case <-ticker.C:
            // 超时计时器未触发，继续读取文件。
            continue
        }
    }
}

func main() {
    reader, err := ReaderWithTimeout("./data.txt", 500*time.Millisecond)
    if err != nil {
        fmt.Println(err)
        return
    }
    scanner := bufio.NewScanner(reader)
    for scanner.Scan() {
        fmt.Println(strings.TrimSpace(scanner.Text()))
    }
    if err := scanner.Err(); err != nil {
        fmt.Println(err)
    }
}