四面体结构的画法（一文带你玩透结构体和方法）

结构体的基本定义和使用package main import ( "fmt" ) //定义结构体类型User type User struct { username string "用户名" password string "密码" mail string "邮箱" } func main() { //初始化方式1 var user User user.username = "ttr" user.password = "abc123" user.mail = "992424875@qq.com" fmt.Println(user) //初始化方式2 user1 := User{"chavis", "1qaz#EDC", "847575@qq.com"} fmt.Println(user1) //初始化方式3 user2 := User{username: "root", password: "abc@9089", mail: "root@11.com"} fmt.Println(user2) } ，接下来我们就来聊聊关于四面体结构的画法?以下内容大家不妨参考一二希望能帮到您!

四面体结构的画法

结构体的基本定义和使用

package main import ( "fmt" ) //定义结构体类型User type User struct { username string "用户名" password string "密码" mail string "邮箱" } func main() { //初始化方式1 var user User user.username = "ttr" user.password = "abc123" user.mail = "992424875@qq.com" fmt.Println(user) //初始化方式2 user1 := User{"chavis", "1qaz#EDC", "847575@qq.com"} fmt.Println(user1) //初始化方式3 user2 := User{username: "root", password: "abc@9089", mail: "root@11.com"} fmt.Println(user2) }

结构体嵌套

package main import "fmt" type Device struct { ip string user string pwd string loginType string `登录类型` } type Idc struct { device Device num int addr string } func main() { idc := Idc{ device: Device{ip: "10.1.1.1", user: "root", pwd: "1qaz#EDC", loginType: "ssh"}, num: 907745, addr: "GZ", } fmt.Println(idc) }

输出：

{{10.1.1.1 root 1qaz#EDC ssh} 907745 GZ}

结构体实例化的3种方式

结构体定义完后是没有分配内存的，需要实例话之后才可以使用结构体。实例化有3种方式：变量定义、new、&符号。

package main import "fmt" type Host struct { user string pwd string } func main() { // 变量定义的方式实例化结构体 var h Host h.user = "root" h.pwd = "1qaz#EDC" fmt.Println(h) // new的方式实例化结构体 var h1 = new(Host) h1.user = "admin" h1.pwd = "2345#EDC" fmt.Println(h1) // &符号定义的方式实例化结构体 var h2 = &Host{} h2.user = "ttr" h2.pwd = "98768#EDC" fmt.Println(h2) }

带标签的结构体，标签用于对字段进行说明

package main import ( "fmt" ) type User struct { username string "用户名" //"用户名"是标签 password string "密码" mail string "邮箱" } func main() { user := User{username: "ttr", password: "1qaz@WSX", mail: "996298929@qq.com"} fmt.Println(user) }

匿名结构体

匿名结构体不用类型名称，不用使用type关键字定义。

package main import "fmt" func main() { //基本结构 user := struct { }{} fmt.Println(user) //定义和初始化 user1 := struct { name string age int }{ "tantianran", 18, } fmt.Println(user1) fmt.Println(user1.name) fmt.Println(user1.age) }

给结构体User添加方法show()，该方法输出一个hello

package main import ( "fmt" ) type User struct { name string age int } func (User) show() { fmt.Println("hello") } func main() { u := User{name: "ttr", age: 17} u.show() }

给结构体添加方法，并将已经初始化好的值可以在方法内拿到

package main import ( "fmt" ) type User struct { name string age int } func (u User) show() { fmt.Println(u.name, u.age) } func main() { u := User{name: "ttr", age: 17} //初始化并实例化 u.show() //调用方法 }

输出：

ttr 17

给结构体添加方法，并将已经初始化好的值可以在方法内进行修改，注意这里是*User，也就是指针类型

package main import ( "fmt" ) type User struct { name string age int } func (u *User) chage() { u.name = "chavis" u.age = 30 } func main() { u := User{name: "ttr", age: 17} //初始化和实例化 fmt.Println(u.name, u.age) //修改前 u.chage() //调用chage方法修改已经初始化好的值 fmt.Println(u.name, u.age) //修改后 }

输出：

ttr 17 chavis 30

如果是指针类型，在方法内是无法修改外部已经初始化好的结构体的值，看下面效果

package main import "fmt" type User struct { name string age int } func (u User) chage() { u.name = "chavis" u.age = 30 } func main() { u := User{name: "ttr", age: 17} u.chage() fmt.Println(u) }

输出：

{ttr 17}

看上面的效果可以知道没有被修改成功，因为是值传递，而如果是指针的话，就是直接指向了已经初始化了值且实例化完并赋给变量u所在的那块内存地址。

在上一个栗子的基础上做改造，使其有返回值，且返回值类型为指针类型

package main import ( "fmt" ) type User struct { name string age int } func (u *User) chage() *User { u.name = "chavis" u.age = 30 return u } func main() { u := User{name: "ttr", age: 17} a := u.chage() fmt.Println(*a) }

输出：

{chavis 30}

在一个普通的函数内修改外部结构体的值

package main import "fmt" type User struct { name string age int } func chage(data *User) { data.name = "tantianran" data.age = 30 } func main() { u := &User{name: "ttr", age: 17} chage(u) fmt.Println(*u) //也可以这样 u1 := User{name: "ttr", age: 17} chage(&u1) fmt.Println(u1) }

任意的类型也都是可以添加方法的，比如给int类型添加一个方法

package main import "fmt" type MyInt int func (x MyInt) check() bool { if x > 100 { return true } else { return false } } func main() { a := MyInt(56) ret := a.check() fmt.Println(ret) }

输出：

false

在上一个栗子的基础上，做一个加法，案例1

package main import "fmt" type MyInt int func (x MyInt) add(y MyInt) MyInt { return x y } func main() { a := MyInt(56) ret := a.add(54) fmt.Println(ret) }

输出：

110

结构体转成json

package main import ( "encoding/json" "fmt" ) type Host struct { Hostname string Ip string } func main() { h := Host{ Hostname: "web01", Ip: "10.1.1.23", } if jsonStr, err := json.Marshal(h); err != nil { fmt.Println(err) } else { fmt.Println(string(jsonStr)) } }

输出：

{"Hostname":"web01","Ip":"10.1.1.23"}

注意：结构体的字段首写字母要大写，否则json包无法读取到字段，进而转换失败（报错），Go语言是通过首字母的大小写来控制访问权限。无论是方法，变量，常量或是自定义的变量类型，如果首字母大写，则可以被外部包访问，反之则不可以。而结构体中的字段名，如果首字母小写的话，则该字段无法被外部包访问和解析。

刚说到结构体的字段首写字母要大写，如果想转换成json后首字母是小写，可以增加标签来做到，看下面代码

package main import ( "encoding/json" "fmt" ) type Host struct { Hostname string `json:"hostname"` //标签加在这里 Ip string `json:"ip"` //标签加在这里 } func main() { h := Host{ Hostname: "web01", Ip: "10.1.1.23", } if jsonStr, err := json.Marshal(h); err != nil { fmt.Println(err) } else { fmt.Println(string(jsonStr)) } }

输出：

{"hostname":"web01","ip":"10.1.1.23"}

将json解析回结构体

package main import ( "encoding/json" "fmt" ) type Host struct { Hostname string Ip string } func main() { jsonData := `{"hostname":"web01","ip":"10.1.1.23"}` var h Host if err := json.Unmarshal([]byte(jsonData), &h); err != nil { fmt.Println("error =", err) return } fmt.Println(h.Hostname) fmt.Println(h.Ip) fmt.Println(h) }

输出：

web01 10.1.1.23 {web01 10.1.1.23}

本文转载于（喜欢的盆友关注我们）：https://mp.weixin.qq.com/s/g62pZW8h_vUbx-SQyBVw_g

,