Golang中如何将变量分组命名？

Golang中如何将变量分组命名？我想在代码中创建一些常量数据，这些数据可以从其他 .go 文件中访问。

decl.go

package declarations

type keydata struct {
    bufkeyvalue       uint8
    bufforeignvalue   uint8
}

我的问题是如何给 bufkeyvalue 和 bufforeignvalue 赋值？我尝试使用 const() 来做同样的事情，但当我尝试像下面这样给一个名称时：

const keydata (
    bufkeyvalue = 05
    bufforeignvalue = 0A
)

我遇到了错误。

下面的写法不会报错：

const (
    bufkeyvalue = 05
    bufforeignvalue = 0A
)

但我希望将 bufkeyvalue 和 bufforeignvalue 分组在一个父名称下。

这些声明还有改进的空间吗？谢谢。

更多关于Golang中如何将变量分组命名？的实战教程也可以访问 https://www.itying.com/category-94-b0.html

phonegap100 1楼

我会把这段代码加入我的程序中，然后向你反馈更新。非常感谢。

更多关于Golang中如何将变量分组命名？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html

caililin 2楼

你不能像那样对常量进行分组。只需使用清晰的名称，或许可以加上前缀或后缀，例如：

KeyDataBufKeyValue = 0x5
KeyDataBufForeignValue = 0xA

yibo5220 3楼

忘记检查了。我一直在学习Go教程，虽然他们说“map”可以接受任何数据类型，但没有提到十六进制。

例如

var n = map[string] hex { }

我看到很多使用int/float32的例子，但没有提到十六进制。

eggper 4楼

你的意思是想要存储 fmt.Printf 打印的字符串吗？如果是这样，你可以使用 fmt.Sprintf，它会将值作为字符串返回，而不是打印到标准输出：

hexString := fmt.Sprintf("%X", baseValues["DefaultA"])

wuwangju 5楼

感谢。是的，我希望其他包能够访问这些变量（DefaultA…C），其默认值是在映射内部定义的。我尝试了您发送的命令，并且成功获取到了实际值。

               hexString := fmt.Sprintf("%X\n", baseValues["DefaultA"])
                    fmt.Println(hexString)

10300010002

caililin 6楼

amelia:

有没有一种直接的方法可以将16字节的十六进制值存储到变量中，并在不转换的情况下将相同的十六进制值传递给另一个变量？

你好 @amelia 所有数据都仅以二进制格式存储在变量中。编译器理解十进制、八进制和十六进制的立即值，并将它们转换为二进制。以何种表示形式显示它们，这已经是你的任务了。

caililin 7楼

我认为这就是 @nezabudka 所提到的：“十六进制”不是一种数据类型；它是一种表示数据的符号。数字 4275878552 可以用十六进制表示为 fedcba98，也可以用二进制表示为 11111110110111001011101010011000，但它们都是相同的数据类型；区别仅在于你如何展示数据。

我无意吹毛求疵。我只是提一下，看看这是否真的是你想要的 ¯_(ツ)_/¯

如果你想将 int64 的十六进制表示形式存储为字符串，那么你可以这样做：

func hexInt64(i int64) string {
    return fmt.Sprintf("%X", i)}
}

var n = map[string]string{
    "DefaultA": hexInt64(0x0000010300010002),
    "DefaultB": hexInt64(0x0000010300020002),
    "DefaultC": hexInt64(11),
}

eggper 8楼

// 我声明的大多数变量都应该被导出。因此这些变量都是大写的。 // 这是必须分配给已声明变量的默认值。

import (
 "encoding/hex"
 "fmt"
)

var baseValues = map[string] int64 {    
    "DefaultA" :      0x0000010300010002,
    "DefaultB" :      0x0000010300020002,
    "DefaultC"  :     11,
}

当我打印这些值时，我得到以下输出：

Map Values : map[DefaultA:138781130753 DefaultB:2220498157569 DefaultC:11]

我查阅了 golang.org 上的一些示例，其中提到了解码器/编码器。

我使用了 fmt.Printf("%X",baseValues[“DefaultA”])，得到的输出是 10300010002。

我的问题是：“是否有任何直接的方法可以将 16 字节的十六进制值存储到一个变量中，并在不进行转换的情况下将相同的十六进制值传递给另一个变量？谢谢。”

vueper 9楼

首先，尝试创建一个不使用常量的可运行程序。这是为了理解以大写字母开头的名称导出原则。示例： decl/decl.go：

package decl

type Keydata struct {
	Bufkeyvalue uint8
	Bufforeignvalue uint8
}

main.go：

package main

import (
    "fmt"
	"./decl"
)

func main() {
	//var k = decl.Keydata{Bufkeyvalue: 0x5, Bufforeignvalue: 0xA}
	k := decl.Keydata{0x5, 0xA}
	fmt.Println(k.Bufkeyvalue, k.Bufforeignvalue)
}

如果我没记错的话，Go语言不支持结构体中的常量。你可能需要在程序中考虑其他数据类型，但为了好玩，你可以应用这个变通方法。 decl/decl.go：

package decl

type keydata struct {
	bufkeyvalue uint8
	bufforeignvalue uint8
}

func ConstKeydata() keydata {
	return keydata{0x5, 0xA}
}

main.go：

package main

import (
    "fmt"
	"./decl"
	"reflect"
)

func main() {
	k := decl.ConstKeydata()
	val := reflect.ValueOf(&k)
	fmt.Println(val.Elem().FieldByName("bufkeyvalue"),
		val.Elem().FieldByName("bufforeignvalue"))
}

抱歉，我的法语不好。

h691938207 10楼

在Go语言中，你可以使用以下几种方式将常量分组命名：

方法1：使用结构体常量（推荐）

package declarations

type KeyData struct {
    BufKeyValue      uint8
    BufForeignValue  uint8
}

var Constants = KeyData{
    BufKeyValue:     0x05,
    BufForeignValue: 0x0A,
}

在其他文件中使用：

package main

import (
    "fmt"
    "yourmodule/declarations"
)

func main() {
    fmt.Println(declarations.Constants.BufKeyValue)      // 输出: 5
    fmt.Println(declarations.Constants.BufForeignValue)  // 输出: 10
}

方法2：使用iota枚举（适用于相关常量）

package declarations

const (
    BufKeyValue uint8 = iota + 5  // 5
    BufForeignValue               // 6
)

方法3：使用常量块和前缀命名

package declarations

const (
    KeyDataBufKeyValue     uint8 = 0x05
    KeyDataBufForeignValue uint8 = 0x0A
)

方法4：使用函数返回分组常量

package declarations

func KeyData() struct {
    BufKeyValue, BufForeignValue uint8
} {
    return struct {
        BufKeyValue, BufForeignValue uint8
    }{
        BufKeyValue:     0x05,
        BufForeignValue: 0x0A,
    }
}

方法5：使用包级变量和init函数

package declarations

var (
    BufKeyValue     uint8
    BufForeignValue uint8
)

func init() {
    BufKeyValue = 0x05
    BufForeignValue = 0x0A
}

对于你的具体需求，方法1（结构体常量）是最清晰且符合Go习惯的方式，它提供了良好的命名空间分组，同时保持了类型安全和可访问性。