content: structs

Author: AmanuelCh

src/components/TopicList.tsx

@@ -59,6 +59,14 @@ const topics = {
     'early-returns',
     'wrapping-up',
   ],
+  structs: [
+    'structs-in-go',
+    'nested-structs',
+    'anonymous-structs',
+    'embedded-structs',
+    'struct-methods',
+    'wrapping-up',
+  ],
 };
 
 export default TopicList;

src/data/structs/anonymous-structs.md

@@ -0,0 +1,33 @@
+# Anonymous Structs
+
+An anonymous struct is just like a normal struct, but it is defined without a name and therefore cannot be referenced elsewhere in the code. To create an anonymous struct, just instantiate the instance immediately using a second pair of brackets after declaring the type:
+
+```go
+myCar := struct {
+  Make string
+  Model string
+} {
+  Make: "tesla",
+  Model: "model 3"
+}
+```
+
+You can even nest anonymous structs as fields within other structs:
+
+```go
+type car struct {
+  Make string
+  Model string
+  Height int
+  Width int
+  // Wheel is a field containing an anonymous struct
+  Wheel struct {
+    Radius int
+    Material string
+  }
+}
+```
+
+## When Should you use an Anonymous struct?
+
+In general, *prefer named structs*. Named structs make it easier to read and understand your code, and they have the nice side-effect of being reusable. I sometimes use anonymous structs when I *know* I won't ever need to use a struct again. For example, sometimes I'll use one to create the shape of some JSON data in HTTP handlers. If a struct is only meant to be used once, then it makes sense to declare it in such a way that developers down the road won’t be tempted to accidentally use it again. You can read more about [anonymous structs here](https://www.willem.dev/articles/anonymous-structs/) if you're curious.

src/data/structs/embedded-structs.md

@@ -0,0 +1,38 @@
+# Embedded Structs
+
+Go is not an [object-oriented](https://en.wikipedia.org/wiki/Object-oriented_programming) language. However, embedded structs provide a kind of *data-only* inheritance that can be useful at times. Keep in mind, Go doesn't support classes or inheritance in the complete sense, embedded structs are just a way to elevate and share fields between struct definitions.
+
+```go
+type car struct {
+  make string
+  model string
+}
+
+type truck struct {
+  // "car" is embedded, so the definition of a "truck" now also additionally contains all of the fields of the car struct
+  car
+  bedSize int
+}
+```
+
+## Embedded vs Nested Struct
+
+- An embedded struct's fields are accessed at the top level, unlike nested structs.
+- Promoted fields can be accessed like normal fields except that they can't be used in [composite literals](https://golang.org/ref/spec#Composite_literals)
+
+```go
+lanesTruck := truck{
+  bedSize: 10,
+  car: car{
+    make: "toyota",
+    model: "camry",
+  },
+}
+
+fmt.Println(lanesTruck.bedSize)
+
+// embedded fields promoted to the top-level
+// instead of lanesTruck.car.make
+fmt.Println(lanesTruck.make)
+fmt.Println(lanesTruck.model)
+```

src/data/structs/nested-structs.md

@@ -0,0 +1,26 @@
+# Nested structs in Go
+
+Structs can be nested to represent more complex entities:
+
+```go
+type car struct {
+  Make string
+  Model string
+  Height int
+  Width int
+  FrontWheel Wheel
+  BackWheel Wheel
+}
+
+type Wheel struct {
+  Radius int
+  Material string
+}
+```
+
+The fields of a struct can be accessed using the dot `.` operator.
+
+```go
+myCar := car{}
+myCar.FrontWheel.Radius = 5
+```

src/data/structs/struct-methods.md

@@ -0,0 +1,25 @@
+# Struct Methods in Go
+
+While Go is **not** object-oriented, it does support methods that can be defined on structs. Methods are just functions that have a receiver. A receiver is a special parameter that syntactically goes *before* the name of the function.
+
+```go
+type rect struct {
+  width int
+  height int
+}
+
+// area has a receiver of (r rect)
+func (r rect) area() int {
+  return r.width * r.height
+}
+
+r := rect{
+  width: 5,
+  height: 10,
+}
+
+fmt.Println(r.area())
+// prints 50
+```
+
+A receiver is just a special kind of function parameter. Receivers are important because they will allow us to define interfaces that our structs (and other types) can implement.

src/data/structs/structs-in-go.md

@@ -0,0 +1,16 @@
+# Structs in Go
+
+We use `structs` in Go to represent structured data. A struct type is defined with the keyword type, the name of the struct type, the keyword struct, and a pair of braces ({}). Within the braces, you list the fields in the struct. Just as you put the variable name first and the variable type second in a var declaration, you put the struct field name first and the struct field type second. It's often convenient to group different types of variables together. For example, if we want to represent a car we could do the following:
+
+```go
+type car struct {
+  Make string
+  Model string
+  Height int
+  Width int
+}
+```
+
+This creates a new struct type called `car`. All cars have a `Make`, `Model`, `Height` and `Width`. In Go, you will often use a `struct` to represent information that you would have used a dictionary for in Python, or an object literal for in JavaScript. You can define a struct type inside or outside of a function. A struct type that’s defined within a function can be used only within that function.
+
+> If you already know an object-oriented language, you might be wondering about the difference between classes and structs. The difference is simple: Go doesn’t have classes, because it doesn’t have inheritance. This doesn’t mean that Go doesn’t have some of the features of object-oriented languages it just does things a little differently.