Structs in Go

We can use functions to capture logic involving our structs and simplify it. 

Structs will often have important operations that can be performed on them. For example, with a struct representing a geometric shape, it would be natural to have functions that compute its area and perimeter. 

Let’s say we have a struct describing a rectangle. The `rectangle` struct will contain two fields: the length and the width. We define this struct:

```go
type Rectangle struct {
  length float32
  width  float32
}
```

We can define a function that computes the area of the rectangle; the product of the length and the width.

```go
func (rectangle Rectangle) area() float32 {
  return rectangle.length * rectangle.width
}
```

The key thing to notice is the line `(rectangle Rectangle)`. This line signals to Go that the `area()` function belongs to the `Rectangle` struct. Note that functions associated with a struct are written outside of the struct!

If we have an instance of `Rectangle` called `rect`, we can call the `area()` function like so:

```go
rect.area()
```

Defining a function in this way will only pass in a copy of the rectangle: that is, we will not be able to use the function to alter the value of a field!

If we want to write a function that allows us to modify the value of a struct field, we have to pass in a pointer to a struct. We will see how this works in the next exercise.

Before we modify our structs in functions, let's practice writing basic struct functions!


Functions that Access a Struct

We've defined our struct and created an instance, it's time to use them. In this exercise, we will explore how to access and modify a struct's variables. 

Let’s say we have an instance of the `Student` struct:

```go
john := Student{"John", "Smith", 14, 9}
```

We can access individual fields within struct using the name of the variable, a `.`, and the name of the field. We could access John's first name like so: 

```go
fmt.Println(john.firstName)
```

We can change the value of a field with an assignment statement:

```go
john.age = 15
```

John's just turned 15!

Using field access and modification finally allows us to be able to use structs in calculations for our program.

Now let’s practice this concept!


Accessing and Modifying Struct Variables

We've just learned the importance of structs in grouping complex data types. But how do we define the structs we'll use in our programs? In this exercise, we will introduce the syntax for defining structs.
	
The definition of a struct includes its name and its fields. A **field** is one of the internal variables inside a struct. We use the following template:

```go
// Struct names begin with a capital letter in Go
type NameOfStruct struct {
  // Struct fields go here
}
```

Let’s say we want to define a 2D point with an x and y coordinate. We could define two variables `x` and `y` and use them throughout our program. However, using multiple related variables in this way is error-prone. We might use `x` when we mean `y`, and dealing with many points could cause confusion.

A better way to represent a 2D point is to create a struct called `Point` which contains both coordinates. Defining `Point` in this way logically groups together the relevant data types. We would define the struct for `Point` like so:

```go
type Point struct {
  x int
  y int
}
```

Using this new type, we would be able to pass `Point` information around our program as a single variable!

Now that have our struct defined, we need to be able to use them. In the next exercise will learn to create instances of our defined structs. First, let's practice defining them in our programs.

Defining a Struct

What can we do when dealing with many structs of the same type? We can use them in an array together! Let’s say we want to create an array of the following points:
{1, 1}
{7, 27}
{12, 7}
{9, 25}

We create an array of `Point`s like so:

```go
points := []Point{{1, 1}, {7, 27}, {12, 7}, {9, 25}}
```
If the points have names, we can also create the array like this:

```go
a = {1, 1}
b = {7, 27}
c = {12, 7}
d = {9, 25}

points := []Point{a, b, c, d}
```

We can access the contents of this array like we would for an ordinary array. We can also access and modify the fields of each of the array elements.

```go
points := []Point{{1, 1}, {7, 27}, {12, 7}, {9, 25}}

fmt.Println(points[0]) // Output will be {1, 1}
```

```go
points := []Point{{1, 1}, {7, 27}, {12, 7}, {9, 25}}

points[1].x = 8
points[1].y = 16

fmt.Println(points[1]) // Output will be {8, 16}
```
Arrays of structs allow us access many instances of our structs together in our programs!
In the following checkpoints, we will practice working with arrays of structs.


Arrays of Structs

Without pointers, when a variable is passed into a function, only a copy of it is used inside the function. We can use pointers to modify values in our structs within a function. But how do we get a pointer to our struct?

Let’s explore this concept using the following struct as an example:

```go
type Employee struct {
  firstName string
  lastName string
  age int
  title string
}
```

We must first create an instance of `Employee` and then we create a pointer that will point to this instance. This is done like so:

```go
func main() {
  steve := Employee{“Steve”, “Stevens”, 34, “Junior Manager”}
  pointerToSteve := &steve
}
```

We can now use this pointer to change the values of the fields for `steve`. There are two ways to do this in Go:

```
(*pointerToSteve).firstName
```

Or a simpler, recommended method:

```
pointerToSteve.firstName
```

We can use these pointers to modify structs in our functions. Consider the following example:

```go
func (rectangle *Rectangle) modify(newLength float32){
  rectangle.length = newLength
}
```

Notice that just inside the function `modify()` that `rectangle` is also a pointer. It is dereferenced without the use of the dereferencing operator just like `pointerToSteve`!

We now have the ability to change Struct values in our functions! Let’s get some practice in!


Pointers to a Struct

We often have many variables related to each other, but managing using them all together can be a headache. Luckily, Go provides us with a way to group several variables into one custom data type. These types make the code cleaner, more intuitive, and less error-prone.

In Go, grouping together related variables is done using a `struct`. Throughout this lesson we will explore:

* What a struct is
* How to define a struct
* How to access and modify a struct's fields
* How to write functions that work with structs
* How to nest structs inside each other

With structs, we can define custom types that allow us to handle any kind of related data. 
To use these structs, we need to define what is inside of it. In the next exercise, we will discuss how to define structs we can use in our programs.


Introduction

Good job on completing the module on struct in Go! You now have a strong understanding of how to create and use structs. Let’s review everything we went over.

A group of related variables can be defined as a struct. Each variable within a struct is known as a field.

A struct must be defined before it can be used in a program. The definition of a struct includes its name and its fields.

```go

type Point struct{
  x int
  y int
}

```

An instance of a defined struct can be created by providing its name followed by a set of curly braces with optional values.

```go
p1 := Point{x: 10, y: 12}
```

Fields within a struct can be accessed or modified using the `.` operator.

```go
p1 := Point{x:10, y:12}
fmt.Println(p1.x)
```

Methods can be associated with a struct by naming a struct parameter in parentheses before the function name.

```go
func (rectangle Rectangle) area()  float32{
  return rectangle.length * rectangle.height
}

func main() {
  rect.area()
}
```

The values of a struct can only be modified in a function if the struct is passed as a pointer.

```go
func (rectangle *Rectangle) modify(newLength float32){
  rectangle.length = newLength
}
```

Accessing the fields of a pointer to a struct does not require dereferencing. The fields of the struct pointer can be accessed using the normal `.` syntax.

```go
steve := Employee{“Steve”, “Stevens”, 34, “Junior Manager”}
pointerToSteve := &steve
fmt.Println(pointerToSteve.firstName)
```

Arrays can be used to store many of the same struct's instances.

```go
points := []Point{{1, 1}, {7, 27}, {12, 7}, {9, 25}}
```

A struct can contain fields that are themselves other structs.

```go
type Name struct{
  firstName string
  lastName string
}

type Employee struct{
  name Name
  age int
  title string
}
```

Congratulations on finishing the lesson. Now that you understand structs, you can use them to define custom collections of variables in your programs!


Review

When we have complex groups of fields in our structs, they can be combined into their own struct! For example, in the `Employee` struct, we have two separate fields for the first and last name of the employee. We can combine those two strings into their own struct called `Name`:

```go
type Name struct{
  firstName string
  lastName string
}

type Employee struct{
  name Name
  age int
  title string
}
```

We create an instance of `Employee` like so:

```go
carl := Employee{Name{“Carl”, “Carlson”}, 32, “Engineer”}
```

To access the fields of the nested struct (`Name` in this case), we chain together the field accesses like so:

```go
fmt.Println(carl.name.lastName) // Output will be “Carlson”
```

We can also define the employee struct with the `Name` struct anonymously like so:

```go
type Employee struct{
  Name
  age int
  title string
}
```

Notice how the `Name` file has no associated variable name with it.

Composing a struct in this way allows us to access the `firstName` and `lastName` fields directly from the `Employee` struct.

```go
carl := Employee{Name{“Carl”, “Carlson”}, 32, “Engineer”}

fmt.Println(carl.firstName) // Output will be “Carl”
fmt.Println(carl.lastName) // Output will be “Carlson”
```
We, of course, cannot have two anonymous fields of the same type (i.e., two `Name` fields) as that would make it impossible to tell which field is being accessed (which `firstName` if two anonymous `Name` fields).

An anonymous field is used to field access easier and leads to cleaner code.

We now have the ability to organize struct information inside of existing structs! Let's get some hands-on practice.


Nested Structs

We've defined our structs, but how do we create variables of that type? To use a struct we just defined, we have to create an instance of it. Assume we defined `Point` from the last exercise. We could create an instance of it like so:

```go
p1 := Point{x: 10, y: 12}
```
or

```go
var p1 = Point{x: 10, y: 12}
```

Using this syntax, we can define values for each of the struct's fields. However, Go allows us to rely on default values as well. We can omit fields:

```go
p1 := Point{x: 10}
// y will be set to 0
```

In fact, we can omit all fields to rely only on default values:

```go
p1 := Point{}
// x and y will be set to 0
```

The order of our struct definition allows us to avoid labeling our fields. The values are assigned from left to right according to how the fields are defined in the struct from top to bottom.

```go
p1 := Point{10, 12}
// Same as var p1 = Point{10, 12}
```

When not using labels, we must provide values for every field; otherwise, our code will not compile.

We've learned how to create struct instances, but how do we use them? In the next exercise, we will discover how to access and modify a struct's values in our programs. For now, let’s practice creating some instances!