In Go, structs are user-defined types that allow you to group together fields of different types under a single entity. Structs are useful for organizing data and building more complex types like objects in object-oriented languages.
1️⃣ Declaring a Struct
To define a struct, you use the type keyword followed by the struct name and the struct keyword. The fields of the struct are defined inside curly braces {}.
🔹 Example:
package main
import "fmt"
// Declaring a Person struct
type Person struct {
name string
age int
}
func main() {
// Creating an instance of the struct
var p1 Person
// Assigning values to the fields
p1.name = "Alice"
p1.age = 25
// Accessing struct fields
fmt.Println("Name:", p1.name)
fmt.Println("Age:", p1.age)
}
🔹 Output:
Name: Alice
Age: 25
👉 In this example, we defined a struct called Person with two fields: name (a string) and age (an integer). Then we created an instance of the struct and assigned values to its fields.
2️⃣ Creating and Initializing a Struct
There are multiple ways to create and initialize a struct in Go.
🔹 Example:
package main
import "fmt"
type Person struct {
name string
age int
}
func main() {
// Method 1: Field by field initialization
p1 := Person{name: "Bob", age: 30}
// Method 2: Default zero values (if not initialized)
p2 := Person{}
// Method 3: Using a pointer to a struct
p3 := &Person{name: "Charlie", age: 28}
fmt.Println("Person 1:", p1)
fmt.Println("Person 2:", p2)
fmt.Println("Person 3:", *p3)
}
🔹 Output:
Person 1: {Bob 30}
Person 2: { 0}
Person 3: {Charlie 28}
👉 Here, p1 is initialized with specific values, p2 is created with default zero values, and p3 is a pointer to a struct.
3️⃣ Accessing and Modifying Struct Fields
You can access and modify struct fields using the dot (.) operator.
🔹 Example:
package main
import "fmt"
type Person struct {
name string
age int
}
func main() {
p := Person{name: "Eve", age: 22}
// Accessing fields
fmt.Println("Before Update:")
fmt.Println("Name:", p.name)
fmt.Println("Age:", p.age)
// Modifying fields
p.name = "Evelyn"
p.age = 23
fmt.Println("After Update:")
fmt.Println("Name:", p.name)
fmt.Println("Age:", p.age)
}
🔹 Output:
Before Update:
Name: Eve
Age: 22
After Update:
Name: Evelyn
Age: 23
👉 You can easily update the fields of a struct by accessing them directly and assigning new values.
4️⃣ Structs with Methods
In Go, you can define methods for structs. A method is a function with a receiver, which can be a struct.
🔹 Example:
package main
import "fmt"
// Defining a struct
type Person struct {
name string
age int
}
// Method for the Person struct
func (p Person) greet() {
fmt.Println("Hello, my name is", p.name)
}
func main() {
p := Person{name: "David", age: 40}
p.greet() // Calling the method on the struct
}
🔹 Output:
Hello, my name is David
👉 In this example, the greet method is associated with the Person struct and can be called using an instance of Person.
5️⃣ Pointer Receivers with Struct Methods
If you want a method to modify the struct fields, you need to use a pointer receiver. Otherwise, the method will work on a copy of the struct.
🔹 Example:
package main
import "fmt"
// Defining a struct
type Person struct {
name string
age int
}
// Method with a pointer receiver
func (p *Person) updateAge(newAge int) {
p.age = newAge // Modifying the original struct
}
func main() {
p := Person{name: "Emma", age: 29}
fmt.Println("Before:", p.age)
// Calling the method with pointer receiver
p.updateAge(30)
fmt.Println("After:", p.age)
}
🔹 Output:
Before: 29
After: 30
👉 By using a pointer receiver *Person, the updateAge method modifies the original struct instead of a copy.
6️⃣ Anonymous Fields in Structs
Go allows you to define anonymous fields in a struct, which means you can embed one struct within another.
🔹 Example:
package main
import "fmt"
// Defining a struct
type Address struct {
city string
state string
}
// Defining another struct with anonymous fields
type Person struct {
name string
age int
Address // Anonymous field (embedded struct)
}
func main() {
p := Person{
name: "John",
age: 35,
Address: Address{
city: "New York",
state: "NY",
},
}
fmt.Println("Name:", p.name)
fmt.Println("City:", p.city) // Accessing embedded struct fields
fmt.Println("State:", p.state) // Accessing embedded struct fields
}
🔹 Output:
Name: John
City: New York
State: NY
👉 By embedding Address in Person, the fields of Address can be accessed directly through Person.
.) operator.Structs are essential for organizing and managing data effectively in Go, making them a powerful tool for building complex applications!
গো (Go) তে স্ট্রাক্ট হল ইউজার-ডিফাইন্ড টাইপ যা বিভিন্ন টাইপের ফিল্ডগুলোকে একটি একক এনটিটির অধীনে গ্রুপ করার সুযোগ দেয়। স্ট্রাক্ট ব্যবহার করে আপনি ডেটা গুছিয়ে রাখতে এবং আরও জটিল টাইপ তৈরিতে সক্ষম হবেন।
1️⃣ স্ট্রাক্ট ডিক্লার করা
স্ট্রাক্ট সংজ্ঞায়িত করতে type কীওয়ার্ডের পর স্ট্রাক্টের নাম এবং তারপরে struct কীওয়ার্ড ব্যবহার করা হয়। স্ট্রাক্টের ফিল্ডগুলো {} এর মধ্যে সংজ্ঞায়িত করা হয়।
🔹 উদাহরণ:
package main
import "fmt"
// Person নামের একটি স্ট্রাক্ট ঘোষণা করা হলো
type Person struct {
name string
age int
}
func main() {
// স্ট্রাক্টের একটি ইনস্ট্যান্স তৈরি করা হলো
var p1 Person
// ফিল্ডগুলিতে মান সেট করা হলো
p1.name = "Alice"
p1.age = 25
// স্ট্রাক্ট ফিল্ডগুলো অ্যাক্সেস করা হলো
fmt.Println("Name:", p1.name)
fmt.Println("Age:", p1.age)
}
🔹 আউটপুট:
Name: Alice
Age: 25
👉 এখানে Person নামে একটি স্ট্রাক্ট ডিফাইন করা হয়েছে, যাতে দুটি ফিল্ড রয়েছে: name (স্ট্রিং টাইপ) এবং age (ইন্টিজার টাইপ)। পরে আমরা স্ট্রাক্টের একটি ইনস্ট্যান্স তৈরি করেছি এবং এর ফিল্ডে মান সেট করেছি।
2️⃣ স্ট্রাক্ট তৈরি এবং ইনিশিয়ালাইজ করা
গো তে স্ট্রাক্ট তৈরি এবং ইনিশিয়ালাইজ করার বিভিন্ন উপায় রয়েছে।
🔹 উদাহরণ:
package main
import "fmt"
type Person struct {
name string
age int
}
func main() {
// পদ্ধতি ১: ফিল্ড বাই ফিল্ড ইনিশিয়ালাইজেশন
p1 := Person{name: "Bob", age: 30}
// পদ্ধতি ২: ডিফল্ট জিরো ভ্যালু দিয়ে তৈরি করা হলো
p2 := Person{}
// পদ্ধতি ৩: স্ট্রাক্টের একটি পয়েন্টার তৈরি করা হলো
p3 := &Person{name: "Charlie", age: 28}
fmt.Println("Person 1:", p1)
fmt.Println("Person 2:", p2)
fmt.Println("Person 3:", *p3)
}
🔹 আউটপুট:
Person 1: {Bob 30}
Person 2: { 0}
Person 3: {Charlie 28}
👉 এখানে p1 নির্দিষ্ট মান সহ ইনিশিয়ালাইজ করা হয়েছে, p2 ডিফল্ট মান সহ তৈরি হয়েছে, এবং p3 হল একটি স্ট্রাক্টের পয়েন্টার।
3️⃣ স্ট্রাক্টের ফিল্ড অ্যাক্সেস ও মডিফাই করা
স্ট্রাক্টের ফিল্ডগুলোতে অ্যাক্সেস করতে এবং সেগুলো পরিবর্তন করতে ডট (.) অপারেটর ব্যবহার করা হয়।
🔹 উদাহরণ:
package main
import "fmt"
type Person struct {
name string
age int
}
func main() {
p := Person{name: "Eve", age: 22}
// ফিল্ড অ্যাক্সেস করা হলো
fmt.Println("আপডেট করার আগে:")
fmt.Println("নাম:", p.name)
fmt.Println("বয়স:", p.age)
// ফিল্ড মডিফাই করা হলো
p.name = "Evelyn"
p.age = 23
fmt.Println("আপডেট করার পরে:")
fmt.Println("নাম:", p.name)
fmt.Println("বয়স:", p.age)
}
🔹 আউটপুট:
আপডেট করার আগে:
নাম: Eve
বয়স: 22
আপডেট করার পরে:
নাম: Evelyn
বয়স: 23
👉 ডট অপারেটর ব্যবহার করে আপনি স্ট্রাক্টের ফিল্ডগুলিতে মান অ্যাসাইন এবং সেগুলোকে মডিফাই করতে পারেন।
4️⃣ স্ট্রাক্টের সাথে মেথড ডিফাইন করা
গো তে স্ট্রাক্টের জন্য মেথড ডিফাইন করা যায়। মেথড হল একটি ফাংশন যা একটি রিসিভার নেয়, যা হতে পারে স্ট্রাক্ট।
🔹 উদাহরণ:
package main
import "fmt"
// স্ট্রাক্ট ডিফাইন করা হলো
type Person struct {
name string
age int
}
// Person স্ট্রাক্টের জন্য মেথড
func (p Person) greet() {
fmt.Println("Hello, my name is", p.name)
}
func main() {
p := Person{name: "David", age: 40}
p.greet() // মেথডটি কল করা হলো
}
🔹 আউটপুট:
Hello, my name is David
👉 এখানে greet মেথডটি Person স্ট্রাক্টের জন্য ডিফাইন করা হয়েছে এবং এটি স্ট্রাক্টের ইনস্ট্যান্সের মাধ্যমে কল করা যায়।
5️⃣ পয়েন্টার রিসিভারের সাথে স্ট্রাক্ট মেথড
যদি আপনি কোনও মেথডের মাধ্যমে স্ট্রাক্টের ফিল্ডগুলো মডিফাই করতে চান, তাহলে পয়েন্টার রিসিভার ব্যবহার করতে হবে। নাহলে মেথড কেবল স্ট্রাক্টের কপি নিয়ে কাজ করবে।
🔹 উদাহরণ:
package main
import "fmt"
// স্ট্রাক্ট ডিফাইন করা হলো
type Person struct {
name string
age int
}
// পয়েন্টার রিসিভার সহ মেথড
func (p *Person) updateAge(newAge int) {
p.age = newAge // আসল স্ট্রাক্টের মান মডিফাই করা হচ্ছে
}
func main() {
p := Person{name: "Emma", age: 29}
fmt.Println("আপডেটের আগে:", p.age)
// পয়েন্টার রিসিভার সহ মেথড কল করা হলো
p.updateAge(30)
fmt.Println("আপডেটের পরে:", p.age)
}
🔹 আউটপুট:
আপডেটের আগে: 29
আপডেটের পরে: 30
👉 পয়েন্টার রিসিভার *Person ব্যবহার করে updateAge মেথডটি আসল স্ট্রাক্টের মান মডিফাই করে, কপি নয়।
6️⃣ স্ট্রাক্টে অ্যানোনিমাস ফিল্ড ব্যবহার করা
গো তে আপনি একটি স্ট্রাক্টে অ্যানোনিমাস ফিল্ড (নামহীন ফিল্ড) ব্যবহার করতে পারেন, অর্থাৎ আপনি একটি স্ট্রাক্টের ভিতরে অন্য একটি স্ট্রাক্ট এমবেড করতে পারেন।
🔹 উদাহরণ:
package main
import "fmt"
// একটি স্ট্রাক্ট ডিফাইন করা হলো
type Address struct {
city string
state string
}
// আরেকটি স্ট্রাক্টে অ্যানোনিমাস ফিল্ড ব্যবহার করে ডিফাইন করা হলো
type Person struct {
name string
age int
Address // অ্যানোনিমাস ফিল্ড (এম্বেড করা স্ট্রাক্ট)
}
func main() {
p := Person{
name: "John",
age: 35,
Address: Address{
city: "New York",
state: "NY",
},
}
fmt.Println("নাম:", p.name)
fmt.Println("শহর:", p.city) // এম্বেড করা স্ট্রাক্টের ফিল্ড অ্যাক্সেস করা হচ্ছে
fmt.Println("স্টেট:", p.state) // এম্বেড করা স্ট্রাক্টের ফিল্ড অ্যাক্সেস করা হচ্ছে
}
🔹 আউটপুট:
নাম: John
শহর: New York
স্টেট: NY
👉 এখানে Address স্ট্রাক্টটি Person এর মধ্যে এম্বেড করা হয়েছে, ফলে Address এর ফিল্ডগুলো Person এর মাধ্যমে সরাসরি অ্যাক্সেস করা যায়।
.) অপারেটর ব্যবহার করে আপনি স্ট্রাক্টের ফিল্ডগুলোতে সহজে অ্যাক্সেস এবং মান পরিবর্তন করতে পারেন।
