函数基础 #

func 函数名(参数列表) 返回值类型 {
    // 函数体
}

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

func greet(name string) {
    fmt.Println("Hello, " + name)
}

func sayHello() {
    fmt.Println("Hello!")
}

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

// 相邻同类型参数可简写
func add(a, b int) int {
    return a + b
}

// 不同类型参数
func printInfo(name string, age int) {
    fmt.Printf("%s is %d years old\n", name, age)
}

func double(n int) {
    n = n * 2
}

func main() {
    x := 10
    double(x)
    fmt.Println(x)  // 10，未改变
}

func double(n *int) {
    *n = *n * 2
}

func main() {
    x := 10
    double(&x)
    fmt.Println(x)  // 20
}

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

fmt.Println(sum(1, 2, 3))        // 6
fmt.Println(sum(1, 2, 3, 4, 5))  // 15

func printNumbers(numbers ...int) {
    fmt.Printf("%T\n", numbers)  // []int
}

nums := []int{1, 2, 3, 4, 5}
fmt.Println(sum(nums...))  // 展开切片

func greet(name string, age ...int) {
    a := 0
    if len(age) > 0 {
        a = age[0]
    }
    fmt.Printf("%s is %d years old\n", name, a)
}

greet("Tom")       // Tom is 0 years old
greet("Tom", 25)   // Tom is 25 years old

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

result := add(1, 2)

func divmod(a, b int) (int, int) {
    return a / b, a % b
}

quotient, remainder := divmod(10, 3)
fmt.Println(quotient, remainder)  // 3 1

quotient, _ := divmod(10, 3)

func divmod(a, b int) (quotient, remainder int) {
    quotient = a / b
    remainder = a % b
    return  // 裸返回
}

q, r := divmod(10, 3)

func counter() (count int) {
    fmt.Println(count)  // 0
    count = 10
    return
}

result := add(1, 2)

import "fmt"

fmt.Println("Hello")

type Person struct {
    Name string
}

func (p Person) SayHello() {
    fmt.Println("Hello, I'm", p.Name)
}

p := Person{Name: "Tom"}
p.SayHello()

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

func main() {
    var f func(int, int) int = add
    fmt.Println(f(1, 2))  // 3
}

func apply(a, b int, f func(int, int) int) int {
    return f(a, b)
}

func main() {
    result := apply(1, 2, add)
    fmt.Println(result)  // 3
}

func getOperator(op string) func(int, int) int {
    switch op {
    case "+":
        return func(a, b int) int { return a + b }
    case "-":
        return func(a, b int) int { return a - b }
    default:
        return nil
    }
}

func main() {
    add := getOperator("+")
    fmt.Println(add(1, 2))  // 3
}

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Println(result)

type Config struct {
    Host string
    Port int
}

func NewConfig(host string, port int) *Config {
    return &Config{
        Host: host,
        Port: port,
    }
}

config := NewConfig("localhost", 8080)

func processItems(items []string, callback func(string)) {
    for _, item := range items {
        callback(item)
    }
}

processItems([]string{"a", "b", "c"}, func(item string) {
    fmt.Println(item)
})

func getUser() User {}
func saveUser(u User) error {}
func isValid(s string) bool {}

type RequestOptions struct {
    Timeout time.Duration
    Retry   int
    Headers map[string]string
}

func request(url string, opts RequestOptions) {}

func doSomething() error {
    if err := step1(); err != nil {
        return fmt.Errorf("step1 failed: %w", err)
    }
    return nil
}