我有这些类型:
type Value interface{}
type NamedValue struct {
Name string
Value Value
}
type ErrorValue struct {
NamedValue
Error error
}
我可以使用v := NamedValue{Name: "fine", Value: 33},但我无法使用e := ErrorValue{Name: "alpha", Value: 123, Error: err}
似乎嵌入语法没问题,但使用它不起作用？
为什么对f 的函数值赋值不是复合文字？
Go lang规范复合文字如下所述，因此函数值不能用复合文字构造。
复合文字为结构体、数组、切片和映射构造值，并在每次求值时创建一个新值
但是，代码中对f 的函数值赋值看起来像是func() int类型的复合文字表达式。
是否存在无法将函数对象构造为复合文字的原因？
package main
import (
"fmt"
)
func main(){
var x int = 0
var f func() int
f = func() int{ x++; return x * x } // <---- Why this cannot be a composite literal?
fmt.Println(f()) // 1
fmt.Println(f()) // 4
fmt.Println(f()) // 9
// Define a type for "func() int" type
type SQUARE func() int
g := SQUARE{ x++; return x * …知道为什么for循环初始化程序中的这个结构表达式在编译时会出现语法错误吗？在这种情况下,指向struct的指针工作正常但是我需要像bellow这样的局部变量.谢谢你的建议!
type Request struct {
id int
line []byte
err error
}
go func() {
for r := Request{}; r.err == nil; r.id++ {
r.line, r.err = input.ReadSlice(0x0a)
channel <- r
}
}()
我正在阅读“Go 编程语言”一书。这对我们（而是）有经验的程序员来说非常好，并解释了其他语言交叉点之间的差异——但我发现了一个我不完全理解的案例。
我非常了解 C++，并且我知道 Go 调用（在 C++ 中会被称为）rvalues/xvalues“不可寻址”。只有“变量” [GOPL 的话] 是可寻址的。
好，可以; 这说得通。
因此，例如，这是非法的（根据第一次印刷的第 159 页）
Point{1, 2}.ScaleBy(2) // compile error: can't take address of Point literal
因为(*Point).ScaleBy将 a*Point作为接收器参数，而Point文字是不可寻址的。
（如果你还没有读过这本书，Point是一个带有 fields 的结构体X, Y float64。
然而，在第 162 页，我们有
type ColoredPoint struct {
*Point
Color color.RGBA
}
p := ColoredPoint(&Point{1, 1}, red)
// ...more code ...
这显然是有效的并且会编译。
题：
为什么Point第二种情况下的文字是可寻址的？
这是为了方便起见的特例，还是我在大局中遗漏了什么？
我有一个较大的结构,直到刚才我用struct literal语法实例化,例如:
Thing{
"the name",
...
}
我刚刚添加了一个未导出的字段Thing结构,现在Go正在抱怨:implicit assignment of unexported field 'config' in Thing literal.
有没有什么方法可以继续使用文字语法,即使结构上现在有一个未导出的字段？
通常,我会初始化一个结构,如:
item1 := Item{1, "Foo"}
但是,我最近看到用parens初始化的代码:
item2 := (Item{2, "Bar"})
reflect返回相同的Item名称.
括号中的初始化是什么以及什么时候首选？
试试这个是一些Go代码:
我有一个原始文件：
syntax = "proto3";
package main;
message Client {
int32 Id = 1;
string Name = 2;
string Email = 3;
}
编译后的Client结构如下：
type Client struct {
Id int32 `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
Name string `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
Email string `protobuf:"bytes,3,opt,name=Email,proto3" json:"Email,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
当我尝试Client像下面这样初始化此结构时：
client := &Client{123, "John", "john@aol.com"}
我收到建筑错误：too few values in struct initializer。我发现了一种通过增加来解决它XXX_NoUnkeyedLiteral，XXX_unrecognized，XXX_sizecache。我不知道这些是什么，并且想知道这是否是正确的方法：
client := &Client{123, "John", "john@aol.com", struct{}{}, []byte{}, …考虑这个例子。假设我有一个在我的代码库中无处不在的对象：
type Person struct {
Name string
Age int
[some other fields]
}
在代码库的某个深处，我也有一些代码可以创建新的Person结构。也许类似于以下实用程序功能：
func copyPerson(origPerson Person) *Person {
copy := Person{
Name: origPerson.Name,
Age: origPerson.Age,
[some other fields]
}
return ©
}
随之而来的是另一个开发人员，Gender并向该Person结构添加了新字段。但是，由于该copyPerson函数位于一段遥远的代码中，因此它们忘记更新copyPerson。如果在创建结构时省略参数，golang不会引发任何警告或错误，因此代码将编译并可以正常工作；唯一的区别是该copyPerson方法现在将无法在Gender结构上进行复制，并且的结果copyPerson将Gender被替换为nil值（例如，空字符串）。
防止这种情况发生的最佳方法是什么？有没有一种方法可以让golang在特定的结构初始化中不强制执行任何遗失的参数？是否有短毛绒可以检测到这种潜在的错误？
我正在尝试从字面上初始化GO中的以下结构：
这是结构：
type tokenRequest struct {
auth struct {
identity struct {
methods []string
password struct {
user struct {
name string
domain struct {
id string
}
password string
}
}
}
}
}
这是我的代码：
req := &tokenRequest{
auth: struct {
identity: struct {
methods: []string{"password"},
password: {
user: {
name: os.Username,
domain: {
id: "default",
},
password: os.Password,
},
},
},
},
}
https://play.golang.org/p/e8Yuk-37_nN
我可以初始化，而无需单独定义所有嵌套的结构（即auth，identity，password，user）
谢谢。
我有以下结构：
type InstructionSet struct {
Inst map[string]interface{}
}
在Inst地图上我想放一些类似的东西
Inst["cmd"] = "dir"
Inst["timeout"] = 10
现在我想直接从代码初始化它，但我没有找到正确的方法来做到这一点
info := InstructionSet{
Inst: {
"command": "dir",
"timeout": 10,
},
}
这样我就得到一个错误说missing type in composite literal. 我尝试了一些变化，但我找不到正确的方法。
我必须string要struct在这样定义的映射golang:
var Foo = map[string]struct{}{
"foo": struct{}{},
}
Gogland默认将此声明标记为警告,并说"冗余类型声明".
var Foo = map[string]struct{}{
"foo": {},
}
上面的代码解决了警告,但我找不到任何关于struct{}{}和{}声明之间的区别的信息.这是一种"短记"吗？
我正在尝试为函数 ReadField() 编写测试代码，但我在定义测试用例时遇到困难。
它给出错误“复合文字中缺少类型”。我相信这只是一些语法错误。
我尝试在函数体外部定义结构，但它仍然会给出相同的错误。
ReadField(string, string, bool) (bool, string)
func TestReadField(t *testing.T){
testCases := []struct {
Name string
Input struct{
FirstString string
SecondString string
SomeBool bool
}
Expected struct{
IsValid bool
Message string
}
}{
//This is where the error points to.
//Valid
{"Test Case 1",
//Missing type error
{"FirstString", "SecondString", true},
//Missing type error
{true, "testMessage"},},
//Same goes for the remaining
{"Test Case 2",
{"FirstString", "SecondString", false},
{true, "testMessage"},},
{"Test Case 3",
{"FirstString", "SecondString", true},
{false, "testMessage"},},
} …我是 golang 的新手，有一个基本问题。我从网上的一个例子中提取了以下代码
func (d Direction) String() string {
return [...]string{"North", "East", "South", "West"}[d]
}
我很困惑[d]方法体中的作用是什么？