How to avoid code duplication within Golang functions?

To avoid code duplication in Go functions, you can use the following methods: Use inline functions: embed the function body into the function call and reduce the number of lines of code. Use anonymous functions: Define functions without a name that can be executed immediately or passed to other functions without naming and calling. Create an extension library: encapsulate common logic and import the same code block into multiple functions to achieve code reuse.

How to avoid code duplication within Go functions

Introduction

When writing When writing Go code, you may encounter code duplication, which can lead to code that is difficult to maintain and error-prone. To avoid code duplication, you can use several features provided by Go.

Using inline functions

Inline functions allow you to embed the body of a function within a call to another function. This eliminates the need to create separate functions, thereby reducing lines of code and potential errors.

func main() {
    fmt.Println(sum(1, 2))
}

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

Using Anonymous Functions

Anonymous functions allow you to define a function without a name that can be executed immediately or passed to another function. This eliminates the need to name the function and call it.

func main() {
    fmt.Println(func(a, b int) int { return a + b }(1, 2))
}

Create your own extension library

If you often use the same block of code for multiple functions, you may consider creating your own extension library and importing it in your program. This helps encapsulate common logic and simplify code.

// utils.go
package utils

import "fmt"

// Sum returns the sum of two integers.
func Sum(a, b int) int {
    return a + b
}

// main.go
package main

import "github.com/username/customlib/utils"

func main() {
    fmt.Println(utils.Sum(1, 2))
}

Practical Case

Suppose you have a function that needs to perform multiple operations on the input string, such as trimming, uppercase and lowercase conversion. You don't want to split these operations into separate functions, but you want to avoid code duplication.

You can use an anonymous function to avoid this situation:

func formatString(s string) string {
    f := func(op string) string {
        switch op {
        case "trim":
            return strings.TrimSpace(s)
        case "upper":
            return strings.ToUpper(s)
        case "lower":
            return strings.ToLower(s)
        default:
            return s
        }
    }

    return f("trim") + f("upper") + f("lower")
}

This function can be called as follows:

s := "  Hello, World!  "
fmt.Println(formatString(s))
// 输出：
// HELLO, WORLD!hello, world!

The above is the detailed content of How to avoid code duplication within Golang functions?. For more information, please follow other related articles on the PHP Chinese website!