如何初始化嵌套结构体？

huangapple
go评论118阅读模式
英文:

How to initialize a nested struct?

问题

我无法弄清楚如何初始化嵌套结构。在这里找到一个示例：
http://play.golang.org/p/NL6VXdHrjh

  1. package main
  3. type Configuration struct {
  4.     Val   string
  5.     Proxy struct {
  6.         Address string
  7.         Port    string
  8.     }
  9. }
  11. func main() {
  13.     c := &Configuration{
  14.         Val: "test",
  15.         Proxy: struct {
  16.             Address string
  17.             Port    string
  18.         }{
  19.             Address: "addr",
  20.             Port:    "80",
  21.         },
  22.     }
  24. }
英文:

I cannot figure out how to initialize a nested struct. Find an example here:
http://play.golang.org/p/NL6VXdHrjh

  1. package main
  3. type Configuration struct {
  4. 	Val   string
  5. 	Proxy struct {
  6. 		Address string
  7. 		Port    string
  8. 	}
  9. }
  11. func main() {
  13. 	c := &Configuration{
  14. 		Val: "test",
  15. 		Proxy: {
  16. 			Address: "addr",
  17. 			Port:    "80",
  18. 		}
  19. 	}
  21. }

答案1

得分: 256

好的，以下是翻译好的内容：

好的，有没有特定的原因不将Proxy作为自己的结构体？

无论如何，你有两个选项：

第一种正确的方式是将Proxy移动到自己的结构体中，例如：

  1. type Configuration struct {
  2.     Val   string
  3.     Proxy Proxy
  4. }
  6. type Proxy struct {
  7.     Address string
  8.     Port    string
  9. }
  11. func main() {
  13.     c := &Configuration{
  14.         Val: "test",
  15.         Proxy: Proxy{
  16.             Address: "addr",
  17.             Port:    "port",
  18.         },
  19.     }
  20.     fmt.Println(c)
  21.     fmt.Println(c.Proxy.Address)
  22. }

第二种不太正确和不太美观的方式，但仍然有效：

  1. c := &Configuration{
  2.     Val: "test",
  3.     Proxy: struct {
  4.         Address string
  5.         Port    string
  6.     }{
  7.         Address: "addr",
  8.         Port:    "80",
  9.     },
  10. }
英文:

Well, any specific reason to not make Proxy its own struct?

Anyway you have 2 options:

The proper way, simply move proxy to its own struct, for example:

  1. type Configuration struct {
  2. 	Val string
  3. 	Proxy Proxy
  4. }
  6. type Proxy struct {
  7. 	Address string
  8. 	Port    string
  9. }
  11. func main() {
  13. 	c := &Configuration{
  14. 		Val: "test",
  15. 		Proxy: Proxy{
  16. 			Address: "addr",
  17. 			Port:    "port",
  18. 		},
  19. 	}
  20. 	fmt.Println(c)
  21.     fmt.Println(c.Proxy.Address)
  22. }

The less proper and ugly way but still works:

  1. c := &Configuration{
  2. 	Val: "test",
  3. 	Proxy: struct {
  4. 		Address string
  5. 		Port    string
  6. 	}{
  7. 		Address: "addr",
  8. 		Port:    "80",
  9. 	},
  10. }

答案2

得分: 172

如果您不想为嵌套结构使用单独的结构定义，并且不喜欢@OneOfOne建议的第二种方法，您可以使用第三种方法：

  1. package main
  2. import "fmt"
  3. type Configuration struct {
  4.     Val   string
  5.     Proxy struct {
  6.         Address string
  7.         Port    string
  8.     }
  9. }
  11. func main() {
  12.     c := &Configuration{
  13.         Val: "test",
  14.     }
  16.     c.Proxy.Address = `127.0.0.1`
  17.     c.Proxy.Port = `8080`
  18. }

您可以在此处查看：https://play.golang.org/p/WoSYCxzCF2

英文:

If you don't want to go with separate struct definition for nested struct and you don't like second method suggested by @OneOfOne you can use this third method:

  1. package main
  2. import "fmt"
  3. type Configuration struct {
  4.     Val   string
  5. 	Proxy struct {
  6.     	Address string
  7. 	    Port    string
  8. 	}
  9. }
  11. func main() {
  12.     c := &Configuration{
  13. 		Val: "test",
  14.     }
  16. 	c.Proxy.Address = `127.0.0.1`
  17. 	c.Proxy.Port = `8080`
  18. }

You can check it here: https://play.golang.org/p/WoSYCxzCF2

答案3

得分: 16

请注意，我将为您翻译以下内容：

将您的Proxy结构体单独定义在Configuration之外，如下所示：

  1. type Proxy struct {
  2.     Address string
  3.     Port    string
  4. }
  6. type Configuration struct {
  7.     Val string
  8.     P   Proxy
  9. }
  11. c := &Configuration{
  12.     Val: "test",
  13.     P: Proxy{
  14.         Address: "addr",
  15.         Port:    "80",
  16.     },
  17. }

请参考 http://play.golang.org/p/7PELCVsQIc

英文:

Define your Proxy struct separately, outside of Configuration, like this:

  1. type Proxy struct {
  2. 	Address string
  3. 	Port    string
  4. }
  6. type Configuration struct {
  7. 	Val string
  8. 	P   Proxy
  9. }
  11. c := &Configuration{
  12. 	Val: "test",
  13. 	P: Proxy{
  14. 		Address: "addr",
  15. 		Port:    "80",
  16. 	},
  17. }

See http://play.golang.org/p/7PELCVsQIc

答案4

得分: 12

你还有这个选项：

  1. type Configuration struct {
  2.     Val string
  3.     Proxy
  4. }
  6. type Proxy struct {
  7.     Address string
  8.     Port    string
  9. }
  11. func main() {
  12.     c := &Configuration{"test", Proxy{"addr", "port"}}
  13.     fmt.Println(c)
  14. }
英文:

You have this option also:

  1. type Configuration struct {
  2.     	Val string
  3.     	Proxy
  4. }
  6. type Proxy struct {
  7.     	Address string
  8.     	Port    string
  9. }
  11. func main() {
  12.     	c := &Configuration{"test", Proxy{"addr", "port"}}
  13.     	fmt.Println(c)
  14. }

答案5

得分: 11

你也可以使用new来分配内存，并手动初始化所有字段。

  1. package main
  3. type Configuration struct {
  4.     Val   string
  5.     Proxy struct {
  6.         Address string
  7.         Port    string
  8.     }
  9. }
  11. func main() {
  12. 	c := new(Configuration)
  13. 	c.Val = "test"
  14. 	c.Proxy.Address = "addr"
  15. 	c.Proxy.Port = "80"
  16. }

在playground中查看：https://play.golang.org/p/sFH_-HawO_M

英文:

You also could allocate using new and initialize all fields by hand

  1. package main
  3. type Configuration struct {
  4.     Val   string
  5.     Proxy struct {
  6.         Address string
  7.         Port    string
  8.     }
  9. }
  11. func main() {
  12. 	c := new(Configuration)
  13. 	c.Val = "test"
  14. 	c.Proxy.Address = "addr"
  15. 	c.Proxy.Port = "80"
  16. }

See in playground: https://play.golang.org/p/sFH_-HawO_M

答案6

得分: 9

一个陷阱出现在你想要实例化一个外部包中定义的公共类型，并且该类型嵌入了其他私有类型的情况下。

示例：

  1. package animals
  3. type otherProps{
  4.   Name string
  5.   Width int
  6. }
  8. type Duck{
  9.   Weight int
  10.   otherProps
  11. }

如何在你自己的程序中实例化一个 Duck？这是我能想到的最好方法：

  1. package main
  3. import "github.com/someone/animals"
  5. func main(){
  6.   var duck animals.Duck
  7.   // 不能使用 something.Duck{Weight: 2, Name: "Henry"} 实例化一个 duck，因为 `Name` 是私有类型 `otherProps` 的一部分
  8.   duck.Weight = 2
  9.   duck.Width = 30
  10.   duck.Name = "Henry"
  11. }
英文:

One gotcha arises when you want to instantiate a public type defined in an external package and that type embeds other types that are private.

Example:

  1. package animals
  3. type otherProps{
  4.   Name string
  5.   Width int
  6. }
  8. type Duck{
  9.   Weight int
  10.   otherProps
  11. }

How do you instantiate a Duck in your own program? Here's the best I could come up with:

  1. package main
  3. import "github.com/someone/animals"
  5. func main(){
  6.   var duck animals.Duck
  7.   // Can't instantiate a duck with something.Duck{Weight: 2, Name: "Henry"} because `Name` is part of the private type `otherProps`
  8.   duck.Weight = 2
  9.   duck.Width = 30
  10.   duck.Name = "Henry"
  11. }

答案7

得分: 7

你需要重新定义&Configuration{}中的未命名结构体。

  1. package main
  3. import "fmt"
  5. type Configuration struct {
  6.     Val   string
  7.     Proxy struct {
  8.         Address string
  9.         Port    string
  10.     }
  11. }
  13. func main() {
  15.     c := &Configuration{
  16.         Val: "test",
  17.         Proxy: struct {
  18.             Address string
  19.             Port    string
  20.         }{
  21.             Address: "127.0.0.1",
  22.             Port:    "8080",
  23.         },
  24.     }
  25.     fmt.Println(c)
  26. }

链接：https://play.golang.org/p/Fv5QYylFGAY

英文:

You need to redefine the unnamed struct during &Configuration{}

  1. package main
  3. import "fmt"
  4.     
  5. type Configuration struct {
  6.     Val   string
  7.     Proxy struct {
  8.         Address string
  9.         Port    string
  10.     }
  11. }
  12.     
  13. func main() {
  14.     
  15.     c := &Configuration{
  16.         Val: "test",
  17.         Proxy: struct {
  18.             Address string
  19.             Port    string
  20.         }{
  21.             Address: "127.0.0.1",
  22.             Port:    "8080",
  23.         },
  24.     }
  25.     fmt.Println(c)
  26. }

https://play.golang.org/p/Fv5QYylFGAY

答案8

得分: 2

你可以在另一个结构体中定义一个结构体，并创建其对象，就像我下面所做的那样：

  1. package main
  3. import "fmt"
  5. type Address struct {
  6.     streetNumber int
  7.     streetName   string
  8.     zipCode      int
  9. }
  11. type Person struct {
  12.     name    string
  13.     age     int
  14.     address Address
  15. }
  17. func main() {
  18.     var p Person
  19.     p.name = "Vipin"
  20.     p.age = 30
  21.     p.address = Address{
  22.         streetName:   "Krishna Pura",
  23.         streetNumber: 14,
  24.         zipCode:      475110,
  25.     }
  26.     fmt.Println("Name: ", p.name)
  27.     fmt.Println("Age: ", p.age)
  28.     fmt.Println("StreetName: ", p.address.streetName)
  29.     fmt.Println("StreeNumber: ", p.address.streetNumber)
  30. }

希望对你有帮助 如何初始化嵌套结构体？

英文:

You can define a struct and create its object in another struct like i have done below:

  1. package main
  3. import "fmt"
  5. type Address struct {
  6. 	streetNumber int
  7. 	streetName   string
  8. 	zipCode      int
  9. }
  11. type Person struct {
  12. 	name    string
  13. 	age     int
  14. 	address Address
  15. }
  17. func main() {
  18. 	var p Person
  19. 	p.name = "Vipin"
  20. 	p.age = 30
  21. 	p.address = Address{
  22. 		streetName:   "Krishna Pura",
  23. 		streetNumber: 14,
  24. 		zipCode:      475110,
  25. 	}
  26. 	fmt.Println("Name: ", p.name)
  27. 	fmt.Println("Age: ", p.age)
  28. 	fmt.Println("StreetName: ", p.address.streetName)
  29. 	fmt.Println("StreeNumber: ", p.address.streetNumber)
  30. }

Hope it helped you 如何初始化嵌套结构体？

答案9

得分: 1

包 main

类型 Proxy 结构体 {
地址 string
端口 string
}

类型 Configuration 结构体 {
Proxy
值 string
}

主函数 main() {
c := &Configuration{
值: "test",
Proxy: Proxy {
地址: "addr",
端口: "80",
},
}
}

英文: 
  1. package main
  3. type	Proxy struct {
  4. 		Address string
  5. 		Port    string
  6. 	}
  8. type Configuration struct {
  9. 	Proxy
  10. 	Val   string
  12. }
  14. func main() {
  16. 	c := &Configuration{
  17. 		Val: "test",
  18. 		Proxy: Proxy {
  19. 			Address: "addr",
  20. 			Port:    "80",
  21. 		},
  22. 	}
  24. }

答案10

得分: 0

当你的配置是全局的时候，你可以这样做：

  1. package main
  3. var Configuration struct {
  4.     Val   string
  5.     Proxy struct {
  6.         Address string
  7.         Port    string
  8.     }
  9. }
  11. func main() {
  12.     Configuration.Val = "test"
  13.     Configuration.Proxy.Address = "addr"
  14.     Configuration.Proxy.Port = "80"
  15. }

这段代码定义了一个名为Configuration的结构体变量，其中包含了Val和Proxy两个字段。Proxy字段又包含了Address和Port两个字段。通过给这些字段赋值，你可以设置全局配置的值。在main函数中，示例代码给Val、Proxy.Address和Proxy.Port分别赋了相应的值。

英文:

When your configuration is something global, you can do it this way:

  1. package main
  3. var Configuration struct {
  4.     Val   string
  5.     Proxy struct {
  6.         Address string
  7.         Port    string
  8.     }
  9. }
  11. func main() {
  12.     Configuration.Val = "test"
  13.     Configuration.Proxy.Address = "addr"
  14.     Configuration.Proxy.Port = "80"
  15. }

huangapple
  • 本文由 发表于 2014年7月18日 00:48:22
  • 转载请务必保留本文链接：https://go.coder-hub.com/24809235.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定