دستکاری رشته در Go: نحوه به روز رسانی متن

هنگام برنامه نویسی متوجه خواهید شد که زیاد با متن کار می کنید، بنابراین مطمئن شوید که چگونه این کار را آسان و سریع انجام دهید.

دستکاری رشته در توسعه نرم افزار اساسی است. اکثر زبان های برنامه نویسی یک نوع رشته ای را ارائه می دهند. رشته مجموعه ای از کاراکترها است: حروف، اعداد و نمادها.

دستکاری رشته برای برنامه های مختلف، از پردازش متن و تجزیه و تحلیل داده ها تا توسعه وب، مفید است. عملیات رایج دستکاری رشته عبارتند از الحاق، اعتبارسنجی داده ها، استخراج و قالب بندی. Go یک بسته دستکاری رشته به نام “strings” در کتابخانه استاندارد ارائه می دهد.

بسته بندی رشته ها

بسته strings توابع مفید مختلفی را برای دستکاری رشته و سایر عملیات ارائه می دهد. این بسته شامل قابلیت هایی برای عملیات زیر رشته، پیرایش، مقایسه رشته ها، تبدیل رشته، ساخت رشته، تقسیم و غیره است.

شما می توانید بسته رشته ها را با تعیین نام بسته در لیست واردات خود وارد کنید.

import "strings"

جستجوی زیر رشته ها

بسته strings سه تابع برای جستجوی زیر رشته ها ارائه می دهد: تابع Contains، تابع ContainsAny و تابع ContainsRune.

تابع Contains بررسی می کند که آیا رشته مشخص شده حاوی رشته فرعی است یا خیر. تابع ContainsAny بررسی می کند که آیا رشته دارای کاراکترهایی در رشته فرعی است یا نه، و تابع ContainsRune بررسی می کند که آیا رشته حاوی یک Rune (یک کاراکتر یونیکد) است یا خیر.

import (
    "fmt"
    "strings"
)

func main() {
    aString := "Hello, World!"
    substring := "World"
    characters := "aeiou"
    aRune := 'o'

    fmt.Println(strings.Contains(aString, substring)) // Output: true
    fmt.Println(strings.ContainsAny(aString, characters)) // Output: true
    fmt.Println(strings.ContainsRune(aString, aRune)) // Output: true
}

می توانید فهرست یک زیررشته را با توابع Index، IndexAny، IndexByte و IndexFunc بازیابی کنید. تابع Index شاخص یک زیررشته را برمی گرداند، در صورتی که در رشته داده شده دیگری رخ دهد. تابع IndexAny ایندکس اولین نمونه از نقطه کد یونیکد یا -1 را در صورتی که هیچ یک از کاراکترها وجود نداشته باشد، برمی گرداند.

import (
    "fmt"
    "strings"
)

func main() {
    aString := "Hello, world!"
    substring := "world"
    chars := "wrld"
    byteCharacter := byte('o')
    aRune := rune('o')

    fmt.Println(strings.Index(aString, substring)) // Output: 7
    fmt.Println(strings.IndexAny(aString, chars)) // Output: 7
    fmt.Println(strings.IndexByte(aString, byteCharacter)) // Output: 4

    f := func(r rune) bool {
        return r == 'o'
    }
    
    fmt.Println(strings.IndexFunc(aString, f)) // Output: 4
    fmt.Println(strings.IndexRune(aString, aRune)) // Output: 4
}

IndexByte ایندکس اولین نمونه کاراکتر بایت در رشته یا -1 را برمی گرداند. تابع IndexFunc ایندکس را به رشته اولین نقطه یونیکد که یک تابع معین را برآورده می کند، برمی گرداند. در نهایت، تابع IndexRune ایندکس اولین نمونه از نقطه کد یونیکد رون را برمی‌گرداند.

جایگزینی رشته های فرعی در Go

تابع Replace و ReplaceAll به جایگزینی زیر رشته ها کمک می کند. تابع Replace رشته، رشته فرعی اصلی و جایگزینی و چندین جایگزین را می گیرد. تابع ReplaceAll فقط رشته، زیررشته اولیه و جایگزینی را می گیرد.

import (
    "fmt"
    "strings"
)

func main() {
    theString := "This is a test string to be modified."
    fmt.Println(strings.Replace(theString, "is", "was", 1))
    fmt.Println(strings.Replace(theString, "is", "was", -1))
    fmt.Println(strings.ReplaceAll(theString, "is", "was"))
}

توجه داشته باشید که می توانید از Replace و ReplaceAll برای جایگزینی هر رخداد در رشته استفاده کنید.

تقسیم و اتصال رشته ها

بسته رشته ها شامل توابع Split، SplitAfter، SplitAfterN و SplitN برای تقسیم رشته هایی است که یک برش از رشته ها را برمی گرداند.

روش Split توسط یک جداکننده مشخص تقسیم می شود. مشابه روش Split، متد SplitAfter رشته را تقسیم می کند، اما جداکننده را در نتایج خود شامل می شود.

import (
    "fmt"
    "strings"
)

func main() {
    s := "This is a test string to be split."

    fmt.Println(strings.Split(s, " "))
    fmt.Println(strings.SplitAfter(s, " "))
    fmt.Println(strings.SplitAfterN(s, " ", 3))
    fmt.Println(strings.SplitN(s, " ", 3))
}

متد SplitAfterN مشابه تابع SplitAfter است با این تفاوت که تابع رشته را به حداکثر مشخصی از زیر رشته ها تقسیم می کند. روش SplitN رشته را به حداکثر تعداد مشخصی تقسیم می کند بدون اینکه جداکننده در زیر رشته ها قرار گیرد.

می توانید رشته ها را با تابع Join از بسته رشته ها بپیوندید. تابع Join یک برش و یک جداکننده می گیرد.

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Join([]string{"Hello", "World"}, ":"))
   // Output: "Hello:World"
}

دستکاری مورد رشته

دستکاری قاب رشته برای بسیاری از کارها از جمله کار با مستندات مفید است. می توانید از تابع ToLower برای حروف کوچک، تابع ToUpper برای حروف بزرگ و تابع ToTitle برای حروف عنوان استفاده کنید.

import (
    "fmt"
    "strings"
)

func main() {
    s := "This is a test string."

    fmt.Println(strings.ToLower(s)) // this is a test string.
    fmt.Println(strings.ToUpper(s)) // THIS IS A TEST STRING.
    fmt.Println(strings.ToTitle(s)) // THIS IS A TEST STRING.
}

ساختمان رشته در برو

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

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder

    // Write some strings to the builder
    b.WriteString("This ")
    b.WriteString("is ")
    b.WriteString("a ")
    b.WriteString("test ")
    b.WriteString("string.")

    // Get the length of the builder
    fmt.Println(b.Len())

    // Convert the builder to a string
    str := b.String()
    fmt.Println(str)

    // Reset the builder
    b.Reset()

    // Write some more strings to the builder
    b.WriteString("This ")
    b.WriteString("is ")
    b.WriteString("another ")
    b.WriteString("test ")
    b.WriteString("string.")

    // Get the capacity of the builder
    fmt.Println(b.Cap())

    // Convert the builder to a string again
    str = b.String()
    fmt.Println(str)
}

تابع اصلی نشان می دهد که چگونه می توانید از نوع strings.Builder برای ساخت رشته کارآمد استفاده کنید. متد WriteString از نوع Strings.Builder دنباله رشته ها را به یکدیگر گسترش می دهد و متد Len طول رشته ساخته شده را برمی گرداند.

متد String محتوای سازنده را به یک رشته تبدیل می‌کند و روش Reset سازنده را برای ساخت رشته اضافی بازنشانی می‌کند.

روش Cap ظرفیت سازنده را برمی گرداند. این فضای فعلی است که Go برای رشته اختصاص داده است.

پیرایش رشته در Go

بسته رشته ها همچنین قابلیت هایی را برای برش رشته ها در توابع Trim، TrimLeft، TrimPrefix، TrimRight، TrimSpace و TrimSuffix ارائه می دهد.

import (
    "strings"
    "fmt"
)

func main() {
    // the full string
    s := "Hello, World!"

    // the element for the trim
    prefix := "Hello"
    suffix := "World!"

    // trims a string by specified trim set
    fmt.Println(strings.Trim(s, "!"))

    // trims out by spaces in the beginning and end of the string
    fmt.Println(strings.TrimSpace(s))

    // trims from the left string by specified trim set
    fmt.Println(strings.TrimLeft(s, "Hello"))

    // trims out from the right string by specified trim set
    fmt.Println(strings.TrimRight(s, "World!"))

    // trims out a prefix
    fmt.Println(strings.TrimPrefix(s, prefix))

    // trims out a specific suffix
    fmt.Println(strings.TrimSuffix(s, suffix))
}

عملکرد اصلی نشان می دهد که چگونه می توانید از عملکردها برای پیرایش استفاده کنید. توابع مختلف رشته s را به روش های مختلفی برش می دهند:

می توانید رشته ها را در Go قالب بندی کنید

کتابخانه استاندارد Go همچنین پکیج fmt را برای قالب بندی رشته ارائه می کند. بسته fmt از افعال قالب‌بندی به سبک C برای قالب‌بندی رشته‌ای کارآمد در Go استفاده می‌کند.

منبع مقاله