2.2 ساختار (struct)

1type employee struct {
2    name   string
3    age    int
4    salary int
5}

1type point struct {
2    x float64
3    y float64
4}

1emp := employee{}

1emp := employee{name: "Sam", age: 31, salary: 2000}

1emp := employee{
2   name:   "Sam",
3   age:    31,
4   salary: 2000,
5}

1emp := employee{
2   name: "Sam",
3   age: 31,
4}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name   string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    emp1 := employee{}
13    fmt.Printf("Emp1: %+v\n", emp1)
14
15    emp2 := employee{name: "Sam", age: 31, salary: 2000}
16    fmt.Printf("Emp2: %+v\n", emp2)
17
18    emp3 := employee{
19        name:   "Sam",
20        age:    31,
21        salary: 2000,
22    }
23    fmt.Printf("Emp3: %+v\n", emp3)
24
25    emp4 := employee{
26        name: "Sam",
27        age:  31,
28    }
29    fmt.Printf("Emp4: %+v\n", emp4)
30}

1$ go run main.go
2Emp1: {name: age:0 salary:0}
3Emp2: {name:Sam age:31 salary:2000}
4Emp3: {name:Sam age:31 salary:2000}
5Emp4: {name:Sam age:31 salary:0}

1emp := employee{"Sam", 31, 2000}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name   string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    emp := employee{"Sam", 31, 2000}
13    fmt.Printf("Emp: %+v\n", emp)
14}

1$ go run main.go
2Emp2: {name:Sam age:31 salary:2000}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name   string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    emp := employee{name: "Sam", age: 31, salary: 2000}
13
14    //Accessing a struct field
15    n := emp.name
16    fmt.Printf("Current name is: %s\n", n)
17
18    //Assigning a new value
19    emp.name = "John"
20    fmt.Printf("New name is: %s\n", emp.name)
21}

1$ go run main.go
2Current name is: Sam
3New name is: John

1emp := employee{name: "Sam", age: 31, salary: 2000}
2empP := &emp

1empP := &employee{name: "Sam", age: 31, salary: 2000}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name   string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    emp := employee{name: "Sam", age: 31, salary: 2000}
13    empP := &emp
14    fmt.Printf("Emp: %+v\n", empP)
15    empP = &employee{name: "John", age: 30, salary: 3000}
16    fmt.Printf("Emp: %+v\n", empP)
17}

1$ go run main.go
2Emp: &{name:Sam age:31 salary:2000}
3Emp: &{name:John age:30 salary:3000}

1func new(Type) *Type

1empP := new(employee)

1fmt.Printf("Emp Pointer: %p\n", empP)

1fmt.Printf("Emp Value: %+v\n", *empP)

1$ go run main.go
2Emp Value: {name: age:0 salary:0}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name   string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    empP := new(employee)
13    fmt.Printf("Emp Pointer Address: %p\n", empP)
14    fmt.Printf("Emp Pointer: %+v\n", empP)
15    fmt.Printf("Emp Value: %+v\n", *empP)
16}

1$ go run main.go
2Emp Pointer Address: 0xc000130000
3Emp Pointer: &{name: age:0 salary:0}
4Emp Value: {name: age:0 salary:0}

1emp := employee{name: "Sam", age: 31, salary: 2000}

1fmt.Printf("%v", emp)  -  {Sam 31 2000}

1fmt.Printf("%+v", emp) - {name:Sam age:31 salary:2000}

1fmt.Println(emp) - {Sam 31 2000}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name   string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    emp := employee{name: "Sam", age: 31, salary: 2000}
13    fmt.Printf("Emp: %v\n", emp)
14    fmt.Printf("Emp: %+v\n", emp)
15    fmt.Printf("Emp: %#v\n", emp)
16    fmt.Println(emp)
17}

1$ go run main.go
2Emp: {Sam 31 2000}
3Emp: {name:Sam age:31 salary:2000}
4Emp: main.employee{name:"Sam", age:31, salary:2000}
5{Sam 31 2000}

1Marshal(v interface{}) ([]byte, error)

1MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)

 1package main
 2
 3import (
 4    "encoding/json"
 5    "fmt"
 6    "log"
 7)
 8
 9type employee struct {
10    Name   string
11    Age    int
12    salary int
13}
14
15func main() {
16    emp := employee{Name: "Sam", Age: 31, salary: 2000}
17    //Marshal
18    empJSON, err := json.Marshal(emp)
19    if err != nil {
20        log.Fatalf(err.Error())
21    }
22    fmt.Printf("Marshal funnction output %s\n", string(empJSON))
23
24    //MarshalIndent
25    empJSON, err = json.MarshalIndent(emp, "", "  ")
26    if err != nil {
27        log.Fatalf(err.Error())
28    }
29    fmt.Printf("MarshalIndent funnction output %s\n", string(empJSON))
30}

1$ go run main.go
2Marshal funnction output {"Name":"Sam","Age":31}
3
4MarshalIndent funnction output {
5  "Name": "Sam",
6  "Age": 31
7}

1type strutName struct{
2   fieldName type `key:"value" key2:"value2"`
3}

1type employee struct {
2    Name   string `json:"n"`
3    Age    int    `json:"a"`
4    Salary int    `json:"s"`
5}

 1package main
 2
 3import (
 4    "encoding/json"
 5    "fmt"
 6    "log"
 7)
 8
 9type employee struct {
10    Name   string `json:"n"`
11    Age    int    `json:"a"`
12    Salary int    `json:"s"`
13}
14
15func main() {
16    emp := employee{Name: "Sam", Age: 31, Salary: 2000}
17    //Converting to jsonn
18    empJSON, err := json.MarshalIndent(emp, '', '  ')
19    if err != nil {
20        log.Fatalf(err.Error())
21    }
22    fmt.Println(string(empJSON))
23}

1$ go run main.go
2{
3  "n": "Sam",
4  "a": 31,
5  "s": 2000
6}

1type employee struct {
2    string
3    age    int
4    salary int
5}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    emp := employee{string: "Sam", age: 31, salary: 2000}
13    //Accessing a struct field
14    n := emp.string
15    fmt.Printf("Current name is: %s\n", n)
16    //Assigning a new value
17    emp.string = "John"
18    fmt.Printf("New name is: %s\n", emp.string)
19}

1$ go run main.go
2Current name is: Sam
3New name is: John

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name    string
 7    age     int
 8    salary  int
 9    address address
10}
11
12type address struct {
13    city    string
14    country string
15}
16
17func main() {
18    address := address{city: "London", country: "UK"}
19    emp := employee{name: "Sam", age: 31, salary: 2000, address: address}
20    fmt.Printf("City: %s\n", emp.address.city)
21    fmt.Printf("Country: %s\n", emp.address.country)
22}

1$ go run main.go
2City: London
3Country: UK

1type Person struct {
2    Name string
3    age  int
4}
5
6type company struct {
7    Name string
8}

 1package main
 2
 3import "fmt"
 4
 5type employee struct {
 6    name   string
 7    age    int
 8    salary int
 9}
10
11func main() {
12    emp1 := employee{name: "Sam", age: 31, salary: 2000}
13    emp2 := employee{name: "Sam", age: 31, salary: 2000}
14    if emp1 == emp2 {
15        fmt.Println("emp1 annd emp2 are equal")
16    } else {
17        fmt.Println("emp1 annd emp2 are not equal")
18    }
19}

1$ go run main.go
2emp1 annd emp2 are equal