为何在Go语言中使用指针作为包标识符？

本篇文章向大家介绍《为何在Go语言中使用指针作为包标识符？》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

考虑来自 gopl.io/ch2/echo4 的以下代码

package main

import (
    "flag"
    "fmt"
    "strings"
)

var n = flag.Bool("n", false, "omit trailing newline")
var sep = flag.String("s", " ", "separator")

func main() {
    flag.Parse()
    fmt.Print(strings.Join(flag.Args(), *sep))
    if !*n {
        fmt.Println()
    }
}

我很感兴趣为什么变量 n 和 sep 是指向标志变量的指针，而不是普通变量类型。

解决方案

因为它们创建后需要赋值。操作顺序为：

1. 创建变量 var n = flag.bool("n", false, "omit trailing newline") 现在值为 false。
2. 使用 flag.parse() 赋值。现在为变量分配了作为命令行参数传递的值。

如果你检查代码here，你会看到有一个名为commandline的导出变量，它是一个指向flagset的指针。这就是奇迹发生的地方。当您导入该库时，它就会被实例化。当您调用导出函数（例如 flag.bool()）时，该函数会依次调用 bool() 方法，该方法有一个指向...flagset 的指针接收器。 it will create a new bool to store your flag's value, invoke boolvar() to store a pointer to the newly created bool variable within the flagset data structure (you'll need to trace boolvar to see how this is accomplished), and returns指向您的完全相同的指针，以便您稍后可以获得当前值（这可能是默认值，也可能是调用 parse() 的结果的全新值）

// commandline is the default set of command-line flags, parsed from os.args.
// the top-level functions such as boolvar, arg, and so on are wrappers for the
// methods of commandline.
var commandline = newflagset(os.args[0], exitonerror)

// newflagset returns a new, empty flag set with the specified name and
// error handling property. if the name is not empty, it will be printed
// in the default usage message and in error messages.
func newflagset(name string, errorhandling errorhandling) *flagset {
    f := &flagset{
        name:          name,
        errorhandling: errorhandling,
    }
    f.usage = f.defaultusage
    return f
}

// a flagset represents a set of defined flags. the zero value of a flagset
// has no name and has continueonerror error handling.
//
// flag names must be unique within a flagset. an attempt to define a flag whose
// name is already in use will cause a panic.
type flagset struct {
    // usage is the function called when an error occurs while parsing flags.
    // the field is a function (not a method) that may be changed to point to
    // a custom error handler. what happens after usage is called depends
    // on the errorhandling setting; for the command line, this defaults
    // to exitonerror, which exits the program after calling usage.
    usage func()
    name          string
    parsed        bool
    actual        map[string]*flag
    formal        map[string]*flag
    args          []string // arguments after flags
    errorhandling errorhandling
    output        io.writer // nil means stderr; use output() accessor
}

// Bool defines a bool flag with specified name, default value, and usage string.
// The return value is the address of a bool variable that stores the value of the flag.
func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
    p := new(bool)
    f.BoolVar(p, name, value, usage)
    return p
}

// Bool defines a bool flag with specified name, default value, and usage string.
// The return value is the address of a bool variable that stores the value of the flag.
func Bool(name string, value bool, usage string) *bool {
    return CommandLine.Bool(name, value, usage)
}

回到你的问题：

这是因为 parse() 可以操作原始变量，而新变量 n 和 sep 只会捕获原始值的副本。通过使用指针，您和 flagset 正在查看完全相同的变量。

好了，本文到此结束，带大家了解了《为何在Go语言中使用指针作为包标识符？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！