Why is it necessary to pass pointers when using Go and viper libraries?

Go pointer syntax and addressing problems in the use of viper library

When programming in Go, it is crucial to understand the syntax and usage of pointers, especially when used in combination with third-party libraries such as Viper, you may encounter some issues that require deep understanding. The question we are going to discuss today is about how to correctly pass parameters in the use of the viper library and why passing a pointer to a pointer is necessary.

There are several modules in our project: setting, section, global and main. The specific code is as follows:

Setting module:

 type setting struct {
    vp *viper.viper
}

func newssetting() (*setting, error) {
    vp := viper.new()
    vp.setconfigname("config")
    vp.addconfigpath("configs/")
    vp.setconfigtype("yaml")
    err := vp.readinconfig()
    if err != nil {
        return nil, err
    }

    return &setting{vp: vp}, nil
}

Section module:

 type serversettings struct {
    runmode string
    httpport string
    readtimeout time.duration
    writetimeout time.duration
}

func (s *setting) readsection(k string, v interface{}) error {
    err := s.vp.unmarshalkey(k, v)
    if err != nil {
        return err
    }

    return nil
}

Global module:

 var serversetting *setting.serversettings

Main module:

 setting, err := setting.newsetting()

setting.readsection("server", &global.serversetting)

Now, if you modify the second line to setting.readsection("server", global.serversetting) in the main module, the error result must be addressable (a pointer). Why is this?

The problem is that global.serversetting is already a pointer, why do you need to pass its address when calling the readsection method?

There is a description in the source code of the viper library:

 // newdecoder returns a new decoder for the given configuration. once
// a decoder has been returned, the same configuration must not be used
// again.
func newdecoder(config *decoderconfig) (*decoder, error) {
    val := reflect.valueof(config.result)
    if val.kind() != reflect.ptr {
        return nil, errors.new("result must be a pointer")
    }

    val = val.elem()
    if !val.canaddr() {
        return nil, errors.new("result must be addressable (a pointer)")
    }
}

From this code, we can see that the passed parameters need not only be a pointer, but also need to be addressable (can be addressable). When you pass a pointer to a structure, it cannot be addressed by itself, thus causing an error.

To verify this, we can take a look at the following example:

 package main

import (
    "fmt"
    "reflect"
)

var a *db

type db struct {
}

func main() {
    val := reflect.valueof(a)
    val = val.elem()
    fmt.println(val.canaddr())

    val = reflect.valueof(&a)
    val = val.elem()
    fmt.println(val.canaddr())
}

Running this code will get the following output:

 false
true

This shows that when a is passed (i.e. a pointer), its elements cannot be addressed, while when &a is passed (i.e. a pointer of the pointer), its elements can be addressed.

Therefore, when using the readsection method, we need to pass &global.serversetting, because in this way, the address of a pointer is passed, which can be addressed, thus meeting the requirements of the viper library.

The above is the detailed content of Why is it necessary to pass pointers when using Go and viper libraries?. For more information, please follow other related articles on the PHP Chinese website!