رشته ها در زبان گو ؛ با نحوه ایجاد و مدیریت رشته ها در GO آشنا شوید

رشته‌ها در زبان گو از نوع داده‌های بسیار مهم هستند که کاربرد زیادی هم دارند. شما این قابلیت‌ها را در سایر زبان‌های برنامه‌نویسی نیز مشاهده خواهید کرد که با نام Strings شناخته می‌شوند. با استفاده از رشته در زبان GO می‌توان دیتایی مانند “Hello World” را ذخیره‌سازی کرد و روی آن تحلیل‌های مختلف را انجام داد؛ همچنین، درصورت نیاز، امکان برگرداندن کل رشته یا بخشی از آن با متدهای Strings فراهم خواهد بود. اگر تاکنون با این قابلیت Golang کار نکرده‌اید، اصلا نگران نباشید. در این آموزش آسان‌ترین راه ورود به این مبحث را در اختیارتان قرار خواهیم داد.

زبان برنامه نویسی go را با جدیدترین متد و آسان بیاموزید!

 

معرفی رشته‌ها در زبان گو 

یک رشته شامل طیف به هم پیوسته‌ای از داده‌ها است که این داده‌ها می‌توانند کاراکترها باشند. برای مثال، ABC یک رشته است که از به هم پیوستن کاراکترهای سه‌گانه A، B و C به وجود آمده است. در زبان‌های برنامه‌نویسی مدرن، این دیتا به صورت یک رشته یا همان String ذخیره‌سازی خواهد شد و با استفاده از آن می‌توان قابلیت‌های متعددی را در اختیار داشت؛ برای مثال، شما پس از ایجاد یک رشته می‌توانید طول آن را محاسبه کنید، اولین کاراکتر را حذف کنید یا حتی به انتهای رشته دیتای مورد نظر را اضافه کنید. 

قبل از کار با رشته ها در زبان گو بهتر است ابزارهای مورد نیاز و ضروری را روی ویندوز نصب کنیم. در این بخش، یک زمان ۵ دقیقه‌ای نیاز دارید تا بتوانید پشتیبان زبان گو و ادیتور VSCode را برای اجرای تکه کدهای Golang روی ویندوز نصب کنید:

نصب ابزارهای مورد نیاز زبان گو

گولنگ روش ساده‌ای را برای اجرای کدها روی ویندوز پیشنهاد می‌دهد. دو مرحله کلی نیاز است تا چند ابزار مهم و ضروری روی سیستم شما نصب شود. با مراجعه به مقاله نصب گو می‌توانید مراحل نصب ابزارهای مورد نیاز را طی کنید. پس از نصب این ابزارها می‌توانید بخش‌های بعدی را مطالعه کنید.

تعریف و ویژگی‌های بنیادی رشته‌ها در زبان گو

در زبان برنامه‌نویسی Go، رشته‌ها یکی از داده‌های پرکاربرد هستند. این رشته‌ها به صورت دنباله‌ای از بایت‌ها تعریف می‌شوند و کدگذاری در آن‌ها به صورت بهینه شده است.  رشته‌ها در زبان گو دارای ویژگی‌های مختلفی هستند که در ادامه مطلب با آن‌ها آشنا خواهیم شد:

قابلیت Immutable در رشته‌ها 

رشته‌ها در زبان گو به صورت غیرقابل تغییر هستند و این به آن معنی است که پس از ایجاد یک رشته نمی‌توان محتوا را تغییر داد. برای تغییر دیتا نیاز است تا از رشته‌های جدید استفاده کنیم. 

دنباله‌ای از بایت‌ها

رشته‌ها در گو به صورت دنباله‌ای از بایت‌ها ذخیره‌سازی خواهند شد. می‌توان به هر بایت با استفاده از ایندکس آن دسترسی پیدا کرد و به راحتی اطلاعات را از آن فراخوانی کرد. 

ترکیب رشته‌ها در زبان گو

امکان ترکیب رشته‌ها نیز در زبان گو فراهم است و این کار را می‌توان با استفاده از عملگرهای اختصاصی به انجام رساند. این کار سریع و آسان است که در ادامه مطلب در مورد این قابلیت بیشتر خواهیم خواند. 

پیمایش رشته‌ها

پیمایش بین دیتاهای یک رشته آسان است و این قابلیت نیز در رشته‌ها فراهم شده است؛ تنها کافی است تا از حلقه for به همراه کیورد range استفاده کنید. 

امکان تعریف رشته‌های چند خطی

تعریف رشته‌هایی که به صورت چند خطی هستند نیز در Golang فراهم است و این کار را می‌توان با استفاده از بک‌تیک یا همان “ انجام داد. 

قابلیت مقایسه بین رشته‌ها

امکان مقایسه بین رشته‌ها نیز در این زبان وجود دارد و این کار را می‌توان با استفاده از عملگرهای == یا != به انجام رساند. با استفاده از این عملگرها، خروجی مقایسه به صورت درست و نادرست خواهد بود. 

روش‌های ایجاد رشته‌ها در زبان گو

در زبان گو رشته ها با استفاده از روش‌های مختلفی ایجاد می‌شوند و می‌توان آن‌ها را با راه‌های متفاوتی مدیریت کرد. در این بخش با مهم‌ترین روش‌ها برای ایجاد و به کار بردن رشته ها در گو آشنا می‌شویم:

ایجاد رشته به صورت مستقیم

 شاید ساده‌ترین روش برای ایجاد رشته در زبان گو استفاده از روش مستقیم باشد؛ به صورت زیر می‌توانید یک رشته ساده به صورت ده کاراکتری تعریف کنید:

 

package main
import "fmt"
func main() {
    str := "Hello, Go!"
    fmt.Println(str) // خروجی: Hello, Go!
}

 

می‌توانید روی کلید Play کلیک کنید تا خروجی زیر را در ترمینال در اختیار داشته باشید:

 

 

ایجاد رشته‌های چند خطی 

با استفاده از روش بک‌تیک می‌توان رشته‌هایی را به صورت چند خطی در گو ایجاد کرد. روش چاپ این رشته‌ها نیز دقیقا مشابه رشته‌های ساده خواهد بود:

 

package main
import "fmt"
func main() {
    str := `Hello,
        ,
        Go!`
    fmt.Println(str)
}

 

خروجی این کد در ترمینال به صورت زیر خواهد بود:

 

 

ترکیب رشته‌ها

با استفاده از ترکیب ۲ رشته نیز می‌توان یک رشته جدید ایجاد کرد. در این حال، امکان استفاده از علائم خاص کاراکتری مانند ویرگول یا … نیز وجود دارد:

 

package main
import "fmt"
func main() {
    str1 := "Hello"
    str2 := "World"
    combined := str1 + ", " + str2 + "!"
    fmt.Println(combined) // خروجی: Hello, World!
}

 

خروجی در این حالت به صورت زیر در ترمینال VSCode چاپ خواهد شد:

 

 

روش‌های مدیریت رشته‌ها در زبان گو

روش‌های مختلفی نیز وجود دارد که از آن می‌توانید برای مدیریت رشته‌ها در گو استفاده کنید. برای مثال، عملگر + برای جمع رشته‌ها به کار می‌رود. یا حتی شما می‌توانید رشته‌های مختلف را با هم مقایسه کنید و روی دیتاهای آن عملیات پیمایش را نیز انجام دهید. در این بخش با چند مثال کاربردی آشنا می‌شویم که از آن می‌توانید برای مدیریت رشته‌ها در زبان Go استفاده کنید:

پیمایش روی رشته‌ها

برای پیمایش روی کاراکترهای رشته‌های زبان Go می‌توان از حلقه for به همراه range استفاده کرد. این روش به شما اجازه می‌دهد تا به کاراکترهای UNICODE دسترسی داشته باشید:

 

package main
import "fmt"
func main() {
    str := "Hello! Go"
    for i, char := range str {
        fmt.Printf("Index: %d, Character: %c\n", i, char)
    }
}

 

به این صورت، می‌توان کاراکترها را به صورت تک‌تک در خروجی به چاپ رساند:

 

 

مقایسه رشته‌ها

امکان مقایسه بین رشته‌ها در زبان Go نیز وجود دارد. این کار را می‌توان با استفاده از عملگرهای == یا =! به انجام رساند. با استفاده از کد زیر می‌توان بررسی کرد که آیا رشته str1 با رشته str2 برابر است یا خیر؛ همچنین، می‌توان در خط بعدی بررسی کرد که آیا str2 از نظر کلمه‌ای از str1 بزرگتر است یا خیر:

 

package main
import "fmt"
func main() {
    str1 := "abc"
    str2 := "bcd"
    fmt.Println(str1 == str2) // خروجی: false
    fmt.Println(str1 < str2)  // خروجی: true (مقایسه کلمه‌ای)
}

 

در ترمینال VSCode خروجی را به صورت زیر دریافت می‌کنید:

 

 

تبدیل عدد به رشته

امکان تبدیل اعداد int به string هم در این زبان امکان‌ پذیر است. در بسیاری از مواقع مانند ذخیره‌سازی دیتا در دیتابیس، این قابلیت نیاز خواهد بود:

 

package main
import (
    "fmt"
    "strconv"
)
func main() {
    num := 123
    str := strconv.Itoa(num)
    fmt.Println("Converted number to string:", str) // خروجی: Converted number to string: 123
    fmt.Printf("%T\n", num)
    fmt.Printf("%T\n", str)
}

 

همانطور که مشاهده می‌کنید، عدد int به رشته string تبدیل شده است:

 

 

روش‌های متداول رشته‌ها در زبان گو

زبان برنامه‌نویسی گو متد و روش‌های مختلفی را برای کار با رشته‌ها فراهم می‌کند. این متدها داخل پکیج strings قرار دارند که به راحتی می‌توان آن را به برنامه اضافه کرده و استفاده از آن را شروع کرد. 

متد Contains در رشته‌ها 

این متد بررسی می‌کند که آیا یک زیر رشته داخل رشته اصلی وجود دارد یا خیر. روش استفاده از این قابلیت در زبان گو به صورت زیر خواهد بود:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "Hello, Go!"
    result := strings.Contains(str, "Go")
    fmt.Println(result) // خروجی: true
}

 

با کلیک کردن روی کلید Play در VSCode می‌توانید خروجی را به صورت زیر در این زبان در اختیار داشته باشید:

 

 

متد Count در رشته‌ها

با استفاده از متد Count امکان شمارش تکرارهای یک کاراکتر خاص یا یک زیر رشته وجود دارد. روش استفاده آسان است و تنها کافی است تا از strings.Count به صورت زیر استفاده کنید:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "banana"
    result := strings.Count(str, "a")
    fmt.Println(result) // خروجی: ۳
}

 

خروجی ۳ به صورت زیر در ترمینال در اختیار شما قرار دارد:

 

 

متد HasPrefix

متد HasPrefix یک متد بسیار کاربردی در مورد رشته ها در زبان گو است. با استفاده از این متد می‌توان تعیین کرد که آیا رشته اصلی با زیر رشته مورد نظر شروع می‌شود یا خیر. 

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "Golang"
    result := strings.HasPrefix(str, "Go")
    fmt.Println(result) // خروجی: true
}

 

با اجرای این کد روی رشته مورد نظر خروجی زیر را در اختیار دارید:

 

 

متد HasSuffix

متد HasSuffix نیز مشابه متد قبلی عمل می‌کند؛ اما تفاوت آن بررسی پسوند رشته مطابق با یک زیر رشته است. به صورت زیر می‌توانید از این متد استفاده کنید. کد زیر بررسی می‌کند که آیا رشته str با lang تمام شده است یا خیر:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "Golang"
    result := strings.HasSuffix(str, "lang")
    fmt.Println(result) // خروجی: true
}

 

در صورت اجرای این کد روی سیستم خود، باید خروجی را به صورت زیر دریافت کنید:

 

 

متد Index 

متد ایندکس یکی از بهترین متدها برای رشته‌ها در زبان گو است که با استفاده از آن می‌توان ایندکس رخداد یک زیر رشته را مشخص کرد. به صورت زیر می‌توانید از این متد استفاده کنید:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "Hello, Go!"
    result := strings.Index(str, "Go")
    fmt.Println(result) // خروجی: ۷
}

 

با اجرای این کد خروجی به صورت زیر در ترمینال چاپ خواهد شد:

 

 

متد Join

در صورتیکه نیاز به اتصال لیستی از رشته‌ها به همدیگر را داشته باشید، متد Join یک مزیت کاربردی در این زبان است؛ البته، می‌توانید از یک جدا کننده هم حین اتصال رشته‌ها استفاده کنید:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    words := []string{"Hello", "World", "Go"}
    result := strings.Join(words, "-")
    fmt.Println(result) // خروجی: Hello-World-Go
}

 

به صورت زیر می‌توانید رشته‌ها را به همدیگر متصل کنید:

 

 

متد Repeat 

متد Repeat قدرت تکرار یک رشته به تعداد مشخصی را دارد. روش کار با این قابلیت رشته ها در زبان گو به صورت زیر است:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    result := strings.Repeat("Go", 3)
    fmt.Println(result) // خروجی: GoGoGo
}

 

با کلیک کردن روی گزینه Play در VSCode خروجی را به صورت زیر مشاهده می‌کنید:

 

 

متد Replace 

متد Replace برای جایگزین کردن بعضی از رخدادها در رشته به کار می‌رود. برای این متد لازم است تا تعداد جایگزینی‌ها را هم انتخاب کنید. برای مثال، با انتخاب تعداد ۲، دو بار جایگزین شدن اتفاق می‌افتد. در صورت انتخاب عدد -۱ برای این بخش، کل رخدادها در رشته با یک زیر رشته انتخابی جایگزین می‌شوند: در مثال زیر، Golang قرار است به تعداد دو بار با Go جایگزین شود:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "Hello, Go, Go, Go!"
    result := strings.Replace(str, "Go", "Golang", 2)
    fmt.Println(result) // خروجی: Hello, Golang, Golang, Go!
}

 

خروجی در ترمینال برای این کد به صورت زیر است:

 

 

به صورت مشابه، امکان جایگزین کردن کل رخدادها با استفاده از n=-1 وجود دارد:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "Hello, Go, Go, Go!"
    result := strings.Replace(str, "Go", "Golang", -1)
    fmt.Println(result) // خروجی: Hello, Golang, Golang, Go!
}

 

به‌اینصورت، تمامی رخدادها باید با عبارت جدید جایگزین شوند:

 

 

متد Split 

یک متد بسیار کاربردی برای رشته ها در زبان گو وجود دارد که مطمئنا در زمان توسعه کدها به آن نیاز خواهید داشت. این متد Split نام دارد که قدرت تقسیم کردن یک رشته به لیستی از رشته‌ها را دارد. در این متد می‌توان یک جداکننده نیز تعریف کرد که شاید ویرگول یا علامت – باشد. در مثال زیر یک رشته در اختیار داریم که با استفاده از جداکننده ویرگول می‌توان تک‌تک کاراکترها را جدا کرد:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "a,b,c,d"
    result := strings.Split(str, ",")
    fmt.Println(result) // خروجی: [a b c d]
    fmt.Printf("%T\n", str)
    fmt.Printf("%T\n", result)
}

می‌توانید این کد را اجرا کنید تا خروجی را به صورت زیر دریافت کنید:

 

 

متد ToLower 

متد ToLower یکی از بهترین قابلیت‌ها برای رشته ها در زبان گو است. این قابلیت کمک می‌کند تا بتوان کاراکترهای یک رشته را به حروف کوچک تبدیل کرد:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "HELLO, GO!"
    result := strings.ToLower(str)
    fmt.Println(result) // خروجی: hello, go!
}

 

خروجی این کد به صورت زیر است:

 

 

به صورت مشابه، می‌توان از متد ToUpper نیز استفاده کرد. عملکرد این متد دقیقا برعکس ToLower است:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "hello, go!"
    result := strings.ToUpper(str)
    fmt.Println(result) // خروجی: HELLO, GO!
}

 

در صورت اجرای صحیح این کد، خروجی به صورت زیر است:

 

 

متد TrimSpace

برای رشته ها در زبان گو یک متد بسیار جالب دیگر هم وجود دارد. با استفاده از قابلیت TrimSpace می‌توان فاصله‌های خالی از ابتدا تا انتهای رشته را حذف کرد:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "   Hello, Go!   "
    result := strings.TrimSpace(str)
    fmt.Println(result) // خروجی: Hello, Go!
}

 

این کد فاصله‌های اضافی را حذف خواهد کرد تا به خروجی زیر برسیم:

 

 

متد Trim

در بسیاری از مواقع نیاز است تا کاراکترهای اضافی را از رشته‌ها حذف کنیم. دراین‌صورت، می‌توان از ویژگی Trim استفاده کرد که کاربرد آن به صورت زیر است:

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "!!!Hello, Go!!!"
    result := strings.Trim(str, "!")
    fmt.Println(result) // خروجی: Hello, Go
}

 

خروجی زیر با اجرای این کد در ترمینال چاپ خواهد شد:

 

 

متد Fields 

در صورتی که نیاز به تقسیم‌بندی رشته‌ها به لیستی از رشته‌ها احساس شود، می‌توان از Fields استفاده کرد. البته، دقت داشته باشید که این متد مبنای تقسیم را فضای خالی بین عبارات در نظر خواهد گرفت.

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "Go is awesome"
    result := strings.Fields(str)
    fmt.Println(result) // خروجی: [Go is awesome]
}

 

این کد رشته مورد نظر را با استفاده از فواصل بین عبارات به یک لیست تبدیل می‌کند:

 

 

رشته‌ها و عملکردهای کتابخانه‌ای در گو

برای رشته ها در زبان گو یک کتابخانه قدرتمند و بهینه ارائه شده است که با نام strings معروف است. اگر در بخش‌های قبل دقت کرده باشید، این کتابخانه را در ابتدای کد اضافه کرده‌ایم تا در ادامه کار از آن استفاده کنیم.  بسیاری از متدها و ویژگی‌ها برای رشته های زبان گو در این کتابخانه فراهم شده است. 

عملکرد بهینه و نکات کلیدی در کار با رشته‌ها در زبان گو

برای رسیدن به بیشترین بهینه‌سازی در ایجاد رشته ها در زبان گو و مدیریت آن‌ها، نکاتی وجود دارد. با دقت در این نکات می‌توان به صورت بهتری حافظه را مدیریت کرد و در صورت نیاز به تحلیل دیتاها، زمان تحلیل‌ها را نیز کاهش داد. 

استفاده از قابلیت Builder 

متد Builder برای کنار زدن یک مشکل بزرگ در این زبان عرضه شد و هدف از آن استفاده از بافر برای تغییر رشته‌ها است. در این زبان رشته‌ها قابل تغییر نیستند و در صورت نیاز به تغییر دادن آن‌ها نیاز به ایجاد یک رشته جدید است. در صورتی که حجم دیتا بالا است، بهترین کار استفاده از Builder برای رسیدن به بازدهی بیشتر در کار است. 

 

package main
import (
    "fmt"
    "strings"
)
func main() {
    var builder strings.Builder
    builder.WriteString("Hello")
    builder.WriteString(", ")
    builder.WriteString("Go")
    result := builder.String()
    fmt.Println(result) // خروجی: Hello, Go
}

 

خروجی در ترمینال به صورت زیر است: 

 

 

استفاده از Buffer 

زمانی که نیاز به عملیات سنگین روی رشته ها در زبان گو احساس می‌شود، امکان استفاده از بافر نیز وجود دارد. این روش حتی از Builder نیز بهینه‌تر است و در زمان و حجم کار صرفه‌جویی بالایی فراهم خواهد کرد. در این مثال، فرض کنید می‌خواهیم یک گزارش شامل ۱۰۰۰۰ خط تولید کنیم که در هر خط یک پیام شامل شماره خط نوشته می‌شود؛ سپس این گزارش را در یک فایل متنی ذخیره خواهیم کرد. بافر این کار را با بهینه‌سازی بالایی انجام می‌دهد:

 

package main
import (
            "bytes"
            "fmt"
            "os"
            "strconv"
)
func main() {
            var buffer bytes.Buffer
            // تولید گزارش بزرگ
            for i := 1; i <= 10000; i++ {
                        line:= "This is line number " + strconv.Itoa(i) + "\n"
                        buffer.WriteString(line)
            }
            // ذخیره گزارش در یک فایل
            file, err := os.Create("report.txt")
            if err != nil {
                        fmt.Println("Error creating file:", err)
                        return
            }
            defer file.Close()
            _, err = buffer.WriteTo(file)
            if err != nil {
                        fmt.Println("Error writing to file:", err)
                        return
            }
            fmt.Println("Report generated and saved to report.txt")
}

 

به صورت زیر خروجی این کد را مشاهده می‌کنید:

 

 

سخن پایانی

استفاده از رشته ها در زبان گو بسیار آسان است. شاید با صرف زمانی حدود یک تا دو هفته بتوانید به تسلط و مهارت خوبی در کار با رشته های زبان گو دست پیدا کنید. مطمئناً، آموزش این قابلیت‌ها در ابتدای کار کیفیت کدنویسی شما را در آینده تضمین خواهد کرد و در آینده می‌توانید از تمامی مزایای رشته ها در گو استفاده کنید. تسلط روی این قابلیت‌ها با تمرین و تکرار به دست خواهد آمد. پس از همین ابتدای کدنویسی در زبان گو سعی کنید با مثال‌ها و تمرین‌های عملی کار خود را جلو ببرید. ما در بخش نظرات همین مقاله، نیک آموز میزبان دیدگاه و تجربه شما هستیم.