Preview

Start a free Courses trial
to watch this video

Structs

7:43 with Jay McGavren

Arrays, slices, and maps can hold groups of data that's all the same type: all ints, all strings, etc. But sometimes you need to group data of different types together. A real estate listing might need a string for the address together with a float for the price. A catalog record might need a part name together with a part number. And so on. Like the C programming language before it, Go solves this sort of situation by offering "structs".

Teacher's Notes
Questions?
Video Transcript
Downloads
Workspaces

A struct is a group of named elements, called fields, each of which has a name and a type.
Fields accessed through dot notation

package main

import "fmt"

type Monitor struct {
    Resolution string
    Connector  string
    Value      float64
}

func main() {
    monitor := Monitor{}
    monitor.Resolution = "1080p"
    monitor.Connector = "HDMI"
    monitor.Value = 249.99
    fmt.Println(monitor.Resolution, monitor.Connector, monitor.Value)
}

Struct literals are similar to the literals for arrays, slices, and maps.
monitor := Monitor{"1080p", "HDMI", 249.99}
- Must be in order, must include all fields.
With field names: monitor := Monitor{Value: 249.99, Resolution: "1080p", Connector: "HDMI"}
- Can be in any order
- Can leave a field off, and it will just get initialized to its zero value.

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Arrays, slices, and 0:00

maps can hold groups of data that's all same type, all ints, all strings, etc. 0:01

But sometimes you need to group data of different types together. 0:07

A real estate listing might need a string for 0:10

the address together with a float for the price. 0:12

A catalog record might need a part name together with a part number, and so on. 0:15

Like the C programming language before it, 0:20

Go solves this sort of situation by offering structs. 0:22

A struct is a group of named elements called fields. 0:26

Each of which has a name and a type. 0:30

So here in this monitor, struct we have a resolution field which is of type string, 0:34

a connector field which is also of type string. 0:40

And a value field which is of type float64. 0:42

Although it's possible to create an anonymous struct, you'll almost always 0:45

want to declare a named type based on the struct so that you can access it later. 0:50

This is done in the same way as the custom types that we showed you earlier. 0:54

You use the type keyword, followed by the name you wanna use for the type, and 0:58

then in place of the basic type that you would use such as inter string, 1:01

you use your struct as the type. 1:07

You create a new instance of your struct type in a way similar to slices or maps. 1:09

You use the name of your type followed by curly braces. 1:14

Once you have a new instance of your value, 1:18

that you can then assign it to a variable. 1:20

Fields within a structure access through dot notation. 1:23

Similar to methods on the type. 1:26

So you put struct value followed by a dot and 1:28

the name of the field you wanna access. 1:31

To assign to that field, you use an equal sign. 1:34

And to get the value back out of that field, 1:37

you just use the value followed by a dot, followed by the field name. 1:40

So here in this code, I create a new instance of our monitor type 1:45

that's based on the struct defined above. 1:50

None of its fields are set initially. 1:55

I set the resolution to the string 1080p and I set the connector tag to 1:57

the string HDMI and I set the value field to the float 249.99. 2:02

Then I go through and print values of each of those fields and 2:06

you can see them in here in the output. 2:10

Struct literals use curly braces similar to the literals for 2:14

arrays, slices, and maps. 2:17

To show off what a struct literal can create, I've added a function here 2:19

which simply prints out the values for the various fields of a monitor argument. 2:23

So the first way to use a struct literal is to just include values for 2:30

all the fields one by one. 2:35

So the resolution field we can use a string of 1080p, that's 2:37

immediately followed by the connector field which is the next one defined. 2:42

And that will be a string of HDMI, and a value field of 249,99. 2:46

I'll save that and run it. 2:51

And we have a call to show fields 2:56

which we'll pass our monitor value to show what it's set to. 2:59

And we see it prints out a resolution of 1080p. 3:04

A connector of HDMI and a value of 249.99. 3:05

If we use a struct literal in this way, the fields have to appear in order and 3:10

we have include all of them. 3:15

If we leave one off, that's an error. 3:16

If we instead were to provide field names, we can do that by putting the field 3:18

name followed by a colon followed by the value that we want that field to have. 3:24

And if we do this, the field's gonna appear in any order we want. 3:29

We can also leave certain fields off if we want and that field will just be set to 3:33

the zero value for its type, for a string to zero value would be an empty sting. 3:37

For float64 the zero value would be zero. 3:42

So let's provide just a value and a resolution here. 3:46

String 1080p. 3:49

Save that. 3:55

And run it again. 3:57

And this time show field prints a resolution of 1080p. 3:59

Our connector is set to its zero value, which is an empty string. 4:04

Because we didn't specify one in the struct literal. 4:08

And then the value is set to 249.99. 4:12

And as we did when we first created the monitor value, we can also 4:14

leave all the fields off, and everything will just be set to its zero value. 4:18

So no resolution, that's an empty string. 4:24

No connector, that's an empty string. 4:27

And the value is set to 0. 4:28

Here's an updated version of our minutes type from before. 4:30

We've moved it to a clock package and we've set up increment and 4:33

display methods for it. 4:38

But it's still using an underlying type of int. 4:39

That means it's possible to set the number of minutes to an invalid value. 4:42

Here we create a new minutes value that's set to 58 minutes. 4:46

And here, we use the addition operator to add 5 on to that value, well 4:49

58 plus 5 is 63, which is invalid for the number of minutes displayed on a clock. 4:55

If we try running this, 5:00

when minutes display gets called down here at the bottom, it prints out the value 63. 5:03

If we switch the minutes type to use a struct as an underlying type and 5:09

move the int value to an unexported field within the struct, 5:13

then only method within the clock package will be able to access the int value. 5:16

That means the other code won't be able to set the int to an int valid value. 5:21

This is how Go handles the process of encapsulation, the practice of protecting 5:26

a types fields from being altered by code outside that type. 5:30

If you wanna setup data that can only be accessed via getter and 5:34

setter methods, store it in an unexported field of a struct type, and 5:37

then add exported methods to that type that access the field. 5:41

Now that the imager value that holds our number of minutes is 5:45

stored in an unexported struct field, that means other code can't set it all. 5:48

So we've added a set method that can be used to set the number of minutes. 5:53

We use another modulo operator here to ensure that if we set a number of minutes 5:57

greater than 60, it will wrap around a start at zero. 6:01

Here we have some code that uses our strut base minutes type. 6:04

We test our set method by passing an a value greater than 60. 6:08

The set method should change the starting value to 3. 6:10

Then we have a loop that increments and 6:15

displays the number of minute several times. 6:16

But if we try running the program it just prints the value 0, 0, 0. 6:19

The problem is that we forgot to update the increment and 6:24

set methods to take point of receivers. 6:26

So they're just updating a copy of the receiver's chart. 6:28

If we update the receiver parameters to take pointers, like this. 6:31

Then the increment and set method should begin working correctly. 6:38

Let's try this out. 6:42

And there we are, 6:44

our initial call to the set method sets the number of minutes not to 63 but 3. 6:45

And then we increment it to four and display that value, increment it to five 6:50

and display that value and increment it to six and display that value as well. 6:54

Notice, by the way we did not have to get the value from the pointers using code 7:01

like value at m. 7:05

Equals value at m.value. 7:12

When you access a struct field through a pointer, 7:17

the pointer is automatically converted to a value. 7:19

Since the display method just prints the receiver value, 7:22

rather than updating it, it works. 7:25

Even though we didn't change the parameter to a pointer. 7:27

But for consistency, it's good style to make the methods either all take values as 7:29

Go Language Overview

Structs

Related Discussions

Related Discussions