<\/p>\n
Updated July 2, 2026.<\/strong> Refreshed for Go 1.22+ and current SEO best practices.<\/p>\n<\/div>\n In this lesson we cover Go structs and methods<\/strong> \u2014 the primary way to model real-world entities in Go. If you completed Go Arrays, Slices, and Maps<\/a>, you know how to store collections. Now you will learn how to group related fields into a single type and attach functions to that type. This Go structs tutorial<\/strong> builds the foundation for interfaces, error handling, and the REST API you will build in Lesson 12.<\/p>\n Prerequisites:<\/strong> Lessons 1\u20137 completed, Go 1.22 or newer installed. Estimated time:<\/strong> 45\u201360 minutes.<\/p>\n A struct<\/strong> is a composite type that groups named fields together. Each field has a name and a type. Structs are Go’s answer to objects in other languages \u2014 but without class inheritance. You define a struct with the Field names that start with an uppercase letter are exported<\/strong> (visible outside the package). Lowercase field names are private to the package \u2014 the same export rule you learned for identifiers in the Basic Syntax lesson.<\/p>\n Create struct values with literals. You can list fields in order (positional) or by name (recommended for clarity):<\/p>\n Named field literals are safer \u2014 they survive field reordering and make code self-documenting. Use A method<\/strong> is a function with a receiver<\/em> \u2014 a special parameter that binds the function to a type. Methods let you write The receiver appears between Choosing between a value receiver Consistency rule:<\/strong> If any method on a type uses a pointer receiver, use pointer receivers for all<\/em> methods on that type. This avoids confusion about whether a method mutates the struct or not.<\/p>\n Go does not have class inheritance. Instead, it uses embedding<\/strong> \u2014 placing one struct type inside another anonymously. The embedded struct’s fields and methods are promoted<\/em> to the outer type, so you can access them directly.<\/p>\n Embedding is how Go achieves code reuse without inheritance hierarchies. A type can embed multiple structs. If two embedded types have a field with the same name, you must qualify the access: Embedding also works with interfaces \u2014 a struct that embeds an interface must satisfy that interface at runtime. You will explore this pattern in the Interfaces lesson.<\/p>\n Here is a practical example that combines struct definition, literals, methods, and pointer receivers:<\/p>\n Notice the constructor pattern You now understand Go structs and methods<\/strong> \u2014 defining types, creating literals, writing methods with value and pointer receivers, and composing types through embedding. In the next lesson we dive deeper into pointers<\/strong> \u2014 when to use them, how they interact with structs, and common patterns you will see in production Go code.<\/p>\n Continue the series: Lesson 7 \u2013 Arrays, Slices, and Maps<\/a> \u00b7 Lesson 9 \u2013 Pointers<\/a><\/p>\n What is a struct in Go?<\/strong> What is the difference between value and pointer receivers?<\/strong> What is struct embedding in Go?<\/strong> <\/p>\n1. Defining a Struct<\/h4>\n
type<\/code> keyword:<\/p>\npackage main\n\nimport \"fmt\"\n\n\/\/ Person is a struct with three fields\ntype Person struct {\n\tName string\n\tAge int\n\tCity string\n}\n\nfunc main() {\n\tvar p Person\n\tfmt.Println(p) \/\/ { 0 } \u2014 zero value: empty string, 0 for int\n\n\tp.Name = \"Ada\"\n\tp.Age = 28\n\tp.City = \"Lagos\"\n\tfmt.Println(p.Name, p.Age, p.City)\n}\n<\/code><\/pre>\n2. Struct Literals<\/h4>\n
package main\n\nimport \"fmt\"\n\ntype Book struct {\n\tTitle string\n\tAuthor string\n\tPages int\n}\n\nfunc main() {\n\t\/\/ Named field literal (preferred)\n\tb1 := Book{\n\t\tTitle: \"The Go Programming Language\",\n\t\tAuthor: \"Donovan & Kernighan\",\n\t\tPages: 380,\n\t}\n\n\t\/\/ Positional literal \u2014 must supply all fields in order\n\tb2 := Book{\"Learning Go\", \"Jon Bodner\", 350}\n\n\t\/\/ Pointer to a struct with &\n\tb3 := &Book{Title: \"Concurrency in Go\", Author: \"Katherine Cox-Buday\", Pages: 300}\n\n\tfmt.Println(b1.Title)\n\tfmt.Println(b2.Author)\n\tfmt.Println(b3.Pages)\n}\n<\/code><\/pre>\n&Type{...}<\/code> when you need a pointer to a struct, which is common when passing structs to functions that should modify them.<\/p>\n3. Methods \u2014 Functions with a Receiver<\/h4>\n
p.Greet()<\/code> instead of Greet(p)<\/code>, which reads more naturally for types that represent entities.<\/p>\npackage main\n\nimport \"fmt\"\n\ntype Rectangle struct {\n\tWidth float64\n\tHeight float64\n}\n\n\/\/ Area is a method with a value receiver\nfunc (r Rectangle) Area() float64 {\n\treturn r.Width * r.Height\n}\n\n\/\/ Scale is a method with a pointer receiver\nfunc (r *Rectangle) Scale(factor float64) {\n\tr.Width *= factor\n\tr.Height *= factor\n}\n\nfunc main() {\n\trect := Rectangle{Width: 10, Height: 5}\n\tfmt.Println(\"Area:\", rect.Area()) \/\/ 50\n\n\trect.Scale(2)\n\tfmt.Println(\"Scaled area:\", rect.Area()) \/\/ 200\n}\n<\/code><\/pre>\nfunc<\/code> and the method name. It looks like an extra parameter, but it is not part of the call \u2014 rect.Area()<\/code> passes rect<\/code> implicitly as the receiver.<\/p>\n4. Value Receivers vs Pointer Receivers<\/h4>\n
(r Rectangle)<\/code> and a pointer receiver (r *Rectangle)<\/code> is one of the most important decisions in Go struct design:<\/p>\n\n
\n\n
\n \nAspect<\/th>\n Value Receiver<\/th>\n Pointer Receiver<\/th>\n<\/tr>\n<\/thead>\n \n Syntax<\/td>\n func (r Rect) M()<\/code><\/td>\nfunc (r *Rect) M()<\/code><\/td>\n<\/tr>\n\n Can modify struct?<\/td>\n No (works on a copy)<\/td>\n Yes (modifies original)<\/td>\n<\/tr>\n \n Memory<\/td>\n Copies entire struct each call<\/td>\n Copies only a pointer (8 bytes)<\/td>\n<\/tr>\n \n Nil receiver<\/td>\n Not applicable<\/td>\n Can panic if receiver is nil<\/td>\n<\/tr>\n \n Best for<\/td>\n Small structs, getters, String()<\/td>\n Mutators, large structs, consistency<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n package main\n\nimport \"fmt\"\n\ntype Counter struct {\n\tCount int\n}\n\n\/\/ Pointer receiver \u2014 modifies the original\nfunc (c *Counter) Increment() {\n\tc.Count++\n}\n\n\/\/ Pointer receiver for consistency, even though it only reads\nfunc (c *Counter) String() string {\n\treturn fmt.Sprintf(\"Count: %d\", c.Count)\n}\n\nfunc main() {\n\tc := Counter{}\n\tc.Increment()\n\tc.Increment()\n\tfmt.Println(c) \/\/ Count: 2\n}\n<\/code><\/pre>\n5. Struct Embedding \u2014 Composition Over Inheritance<\/h4>\n
package main\n\nimport \"fmt\"\n\ntype Address struct {\n\tStreet string\n\tCity string\n}\n\nfunc (a Address) FullAddress() string {\n\treturn a.Street + \", \" + a.City\n}\n\ntype Employee struct {\n\tName string\n\tAddress \/\/ embedded \u2014 fields promoted to Employee\n\tSalary float64\n}\n\nfunc main() {\n\temp := Employee{\n\t\tName: \"Chidi\",\n\t\tAddress: Address{\n\t\t\tStreet: \"12 Broad Street\",\n\t\t\tCity: \"Lagos\",\n\t\t},\n\t\tSalary: 75000,\n\t}\n\n\t\/\/ Promoted fields \u2014 no need for emp.Address.City\n\tfmt.Println(emp.City)\n\tfmt.Println(emp.FullAddress()) \/\/ promoted method\n}\n<\/code><\/pre>\nemp.Address.City<\/code>.<\/p>\n6. Putting It Together \u2014 A Simple Bank Account<\/h4>\n
package main\n\nimport (\n\t\"fmt\"\n\t\"log\"\n)\n\ntype Account struct {\n\tOwner string\n\tBalance float64\n}\n\nfunc NewAccount(owner string) *Account {\n\treturn &Account{Owner: owner, Balance: 0}\n}\n\nfunc (a *Account) Deposit(amount float64) error {\n\tif amount <= 0 {\n\t\treturn fmt.Errorf(\"deposit amount must be positive\")\n\t}\n\ta.Balance += amount\n\treturn nil\n}\n\nfunc (a *Account) Withdraw(amount float64) error {\n\tif amount <= 0 {\n\t\treturn fmt.Errorf(\"withdrawal amount must be positive\")\n\t}\n\tif amount > a.Balance {\n\t\treturn fmt.Errorf(\"insufficient funds\")\n\t}\n\ta.Balance -= amount\n\treturn nil\n}\n\nfunc (a *Account) String() string {\n\treturn fmt.Sprintf(\"%s: $%.2f\", a.Owner, a.Balance)\n}\n\nfunc main() {\n\tacct := NewAccount(\"Ngozi\")\n\tif err := acct.Deposit(500); err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tif err := acct.Withdraw(150); err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tfmt.Println(acct) \/\/ Ngozi: $350.00\n}\n<\/code><\/pre>\nNewAccount<\/code> \u2014 a common Go idiom that returns a pointer to a newly initialized struct. Error returns on Deposit<\/code> and Withdraw<\/code> preview the error-handling style you will master in Lesson 10.<\/p>\n7. Next Steps<\/h4>\n
Frequently Asked Questions<\/h4>\n
\nA struct groups related fields into a single type \u2014 Go’s primary way to model data. Structs do not have inheritance; use embedding for composition.<\/p>\n
\nPointer receivers can modify the struct and avoid copying large values. Value receivers copy the struct and cannot change the original. Use pointer receivers when methods mutate state or for consistency across all methods on a type.<\/p>\n
\nEmbedding one struct inside another anonymously promotes its fields and methods to the outer type \u2014 Go’s composition pattern instead of class inheritance.<\/p>\n