strings

strings paketi UTF-8 kodlu string'leri işlemek için basit fonksiyonlar implement eder, kısacası dize işlemleri için araç paketidir.

Resmi dokümantasyon: strings package - strings - Go Packages

TIP

Go doğal olarak UTF8 karakterleri destekler, tüm dize işlemleri UTF8 temelinde yapılır.

İçe Aktarma

import (
   "strings"
)

Aşağıda yaygın olarak kullanılan fonksiyonlar örneklerle açıklanacaktır.

String Kopyalama

func Clone(s string) string

Kopyaya yeni bir bellek tahsis eder, eğer boş string geçirilirse bellek tahsis edilmez ve boş string döndürülür.

func TestClone(t *testing.T) {
   ori := "hello 世界"
   copys := strings.Clone(ori)
   fmt.Println(ori, copys)
   fmt.Println(&ori, &copys)
}

=== RUN   TestClone
hello 世界 hello 世界
0xc00005e5d0 0xc00005e5e0
--- PASS: TestClone (0.00s)
PASS

String Karşılaştırma

func Compare(a, b string) int

a ile b'yi sözlük sırasına göre karşılaştırır, eğer a>b ise 1, a<b ise -1, a=b ise 0 döndürür.

func TestCompare(t *testing.T) {
  fmt.Println(strings.Compare("abc", "abe"))
  fmt.Println(strings.Compare("abcd", "abe"))
  fmt.Println(strings.Compare("abijk", "abe"))
  fmt.Println(strings.Compare("abe", "abe"))
}

=== RUN   TestCompare
-1
-1
1
0
--- PASS: TestCompare (0.00s)
PASS

String İçerme

func Contains(s, substr string) bool

Bir s string'inin substr alt string'ini içerip içermediğini kontrol eder

func TestContains(t *testing.T) {
  fmt.Println(strings.Contains("abcdefg", "a"))
  fmt.Println(strings.Contains("abcdefg", "abc"))
  fmt.Println(strings.Contains("abcdefg", "ba"))
}

=== RUN   TestContains
true
true
false
--- PASS: TestContains (0.00s)
PASS

func ContainsAny(s, chars string) bool

chars string'indeki herhangi bir karakterin unicode kodunun s string'inde olup olmadığını kontrol eder, çevirisi s'in chars içindeki herhangi bir string'i içerip içermediğidir

func TestContainsAny(t *testing.T) {
  fmt.Println(strings.ContainsAny("abcedfg", "bac"))
  fmt.Println(strings.ContainsAny("abcedfg", "gfdecba"))
}

=== RUN   TestContainsAny
true
--- PASS: TestContainsAny (0.00s)
PASS

func ContainsRune(s string, r rune) bool

s string'inin r karakterini içerip içermediğini kontrol eder

func TestContainsRune(t *testing.T) {
   fmt.Println(strings.ContainsRune("abcedf", 'a'))
   fmt.Println(strings.ContainsRune("abcedf", 'b'))
   fmt.Println(strings.ContainsRune("你好世界", '你'))
}

=== RUN   TestContainsRune
true
true
true
--- PASS: TestContainsRune (0.00s)
PASS

Alt String Görünme Sayısı

func Count(s, substr string) int

substr alt string'inin s string'i içinde kaç kez göründüğünü döndürür

func TestCount(t *testing.T) {
  fmt.Println(strings.Count("3.1415926", "1"))
  fmt.Println(strings.Count("there is a girl", "e"))
  fmt.Println(strings.Count("there is a girl", ""))
}

=== RUN   TestCount
2
2
16
--- PASS: TestCount (0.00s)
PASS

Belirtilen Alt String'i Silme

func Cut(s, sep string) (before, after string, found bool)

s içinde ilk görünen sep alt string'ini siler ve silindikten sonraki sonucu döndürür

• before - Silinen alt string'in önündeki string
• after - Silinen alt string'in arkasındaki string
• found - Alt string bulunup bulunmadığı

func TestCut(t *testing.T) {
  show := func(s, sep string) {
    before, after, found := strings.Cut(s, sep)
    fmt.Printf("Cut(%q, %q) = %q, %q, %v\n", s, sep, before, after, found)
  }
  show("Hello world", " ")
  show("Hello world", "world")
  show("Hello world", "Hello")
  show("Hello world", "Hello world")
}

=== RUN   TestCut
Cut("Hello world", " ") = "Hello", "world", true
Cut("Hello world", "world") = "Hello ", "", true
Cut("Hello world", "Hello") = "", " world", true
Cut("Hello world", "Hello world") = "", "", true
--- PASS: TestCut (0.00s)
PASS

Büyük/Küçük Harf Duyarsız Eşitlik

func EqualFold(s, t string) bool

s ve t string'lerinin büyük/küçük harf duyarsız karşılaştırmada eşit olup olmadığını döndürür

func TestEqualFold(t *testing.T) {
   fmt.Println(strings.EqualFold("你好", "你好"))
   fmt.Println(strings.EqualFold("Hello", "Hello"))
   fmt.Println(strings.EqualFold("Hello", "hELLO"))
}

=== RUN   TestEqualFold
true
true
true
--- PASS: TestEqualFold (0.00s)
PASS

String Bölme

func Fields(s string) []string

func FieldsFunc(s string, f func(rune) bool) []string

İlki boşluklara göre string'i böler, ikincisi f fonksiyonunun dönüş değerine göre string'i böler.

func TestField(t *testing.T) {
   fmt.Printf("%q\n", strings.Fields(" a b c d e f g "))
   fmt.Printf("%q\n", strings.FieldsFunc("a,b,c,d,e,f,g", func(r rune) bool {
      return r == ','
   }))
}

=== RUN   TestField
["a" "b" "c" "d" "e" "f" "g"]
["a" "b" "c" "d" "e" "f" "g"]
--- PASS: TestField (0.00s)
PASS

Önek ve Sonek Arama

func HasPrefix(s, prefix string) bool

func HasSuffix(s, suffix string) bool

İlki önek arar, ikincisi sonek arar, ilgilenenler burada kaynak kod implementasyonuna bakabilir, oldukça akıllıcadır.

func TestPreSuffix(t *testing.T) {
   str := "abbc cbba"
   fmt.Println(strings.HasPrefix(str, "abb"))
   fmt.Println(strings.HasSuffix(str, "bba"))
}

=== RUN   TestPreSuffix
true
true
--- PASS: TestPreSuffix (0.00s)
PASS

Alt String'in Konumu

İlk görünen alt string'in indeksini döndürür

func Index(s, substr string) int

İlk görünen alt string'in indeksini döndürür

func IndexAny(s, chars string) int

İlk görünen alt string'in indeksini döndürür

func IndexRune(s string, r rune) int

Örnek

func TestIndex(t *testing.T) {
   fmt.Println(strings.Index("abcdefg", "bc"))
   fmt.Println(strings.IndexAny("abcdefg", "cb"))
   fmt.Println(strings.IndexRune("abcdefg", 'g'))
}

=== RUN   TestIndex
1
1
6
--- PASS: TestIndex (0.00s)
PASS

Son görünen alt string'in indeksini döndürür

func LastIndex(s, substr string) int

Son görünen alt string'in herhangi bir karakterinin indeksini döndürür

func LastIndexAny(s, chars string) int

Örnek

func TestLastIndex(t *testing.T) {
  fmt.Println(strings.LastIndex("abcdefga", "a"))
  fmt.Println(strings.LastIndexAny("abcdefghisa", "ba"))
}

String Dolaşım ve Değiştirme

Map, string s'nin bir kopyasını döndürür ve string s'nin tüm karakterlerini mapping fonksiyonuna göre değiştirir. Eğer mapping negatif değer döndürürse, o karakter string'den silinir, değiştirilmez

func Map(mapping func(rune) rune, s string) string

Örnek

func TestMap(t *testing.T) {
   fmt.Println(strings.Map(func(r rune) rune {
      return r - 32
   }, "abcdefghijk"))
   fmt.Println(strings.Map(func(r rune) rune {
      return r + 32
   }, "ABCDEFGHIJK"))
   fmt.Println(strings.Map(func(r rune) rune {
      if r < 'F' {
         return -1
      } else {
         return r
      }
   }, "ABCDEFGHIJK"))
}

Çıktı

=== RUN   TestMap
ABCDEFGHIJK
abcdefghijk
FGHIJK
--- PASS: TestMap (0.00s)
PASS

String Tekrarlama

Verilen Count'a göre string'i kopyalar, eğer negatif ise panic oluşur

func Repeat(s string, count int) string

Örnek

func TestRepeat(t *testing.T) {
   fmt.Println(strings.Repeat("a", 10))
   fmt.Println(strings.Repeat("abc", 10))
}

Çıktı

=== RUN   TestRepeat
aaaaaaaaaa
abcabcabcabcabcabcabcabcabcabc
--- PASS: TestRepeat (0.00s)
PASS

String Değiştirme

s kaynak string'dir, old değiştirilecek kısımdır, new old'un yerine geçecek kısımdır, n değiştirme sayısını belirtir, n小于 0 olduğunda değiştirme sayısı sınırsızdır.

func Replace(s, old, new string, n int) string

Örnek

func TestReplace(t *testing.T) {
   fmt.Println(strings.Replace("Hello this is golang", "golang", "c++", 1))
   fmt.Println(strings.Replace("Hello this is golang", "o", "c", -1))
   fmt.Println(strings.Replace("Hello this is golang", "o", "c", 1))
}

Çıktı

=== RUN   TestReplace
Hello this is c++
Hellc this is gclang
Hellc this is golang
--- PASS: TestReplace (0.00s)
PASS

Replace'in kolaylık fonksiyonu, stings.Replace(s,old,new,-1) ile eşdeğerdir

func ReplaceAll(s, old, new string) string

Örnek

func TestReplaceAll(t *testing.T) {
  fmt.Println(strings.ReplaceAll("Hello this is golang", "o", "c++"))
}

Çıktı

=== RUN   TestReplaceAll
Hellc++ this is gc++lang
--- PASS: TestReplaceAll (0.00s)
PASS

String Ayırma

sep alt string'ine göre s string'ini bir string slice'a ayırır

func Split(s, sep string) []string

sep alt string'ine göre s string'ini bir string slice'a ayırır, ayırma sayısı n tarafından belirlenir

func SplitN(s, sep string, n int) []string

sep alt string'ine göre s string'ini sep içeren string elementlerinden oluşan string slice'a ayırır

func SplitAfter(s, sep string) []string

sep alt string'ine göre s string'ini sep içeren string elementlerinden oluşan string slice'a ayırır, ayırma sayısı n tarafından belirlenir

func SplitAfterN(s, sep string, n int) []string

Örnek

func TestSplit(t *testing.T) {
   fmt.Printf("%q\n", strings.Split("this is go language", " "))
   fmt.Printf("%q\n", strings.SplitN("this is go language", " ", 2))
   fmt.Printf("%q\n", strings.SplitAfter("this is go language", " "))
   fmt.Printf("%q\n", strings.SplitAfterN("this is go language", " ", 2))
}

Çıktı

=== RUN   TestSplit
["this" "is" "go" "language"]
["this" "is go language"]
["this " "is " "go " "language"]
["this " "is go language"]
--- PASS: TestSplit (0.00s)
PASS

Büyük/Küçük Harf Dönüştürme

İngilizce string'i küçük harf string'e dönüştürür

func ToLower(s string) string

İlgili dilin unicode.SpecialCase'ine göre, ilgili dilin küçük harf string'ine dönüştürür

func ToLowerSpecial(c unicode.SpecialCase, s string) string

İngilizce string'i büyük harf string'e dönüştürür

func ToUpper(s string) string

İlgili dilin unicode.SpecialCase'ine göre, ilgili dilin büyük harf string'ine dönüştürür

func ToUpperSpecial(c unicode.SpecialCase, s string) string

Örnek

func TestLowerAndUpper(t *testing.T) {
   fmt.Println(strings.ToLower("My name is jack,Nice to meet you!"))
   fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
   fmt.Println(strings.ToUpper("My name is jack,Nice to meet you!"))
   fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "örnek iş"))
}

Çıktı

=== RUN   TestLowerAndUpper
my name is jack,nice to meet you!
önnek iş
MY NAME IS JACK,NICE TO MEET YOU!
ÖRNEK İŞ
--- PASS: TestLowerAndUpper (0.00s)
PASS

String Düzenleme

String'in iki ucunu düzenler, cutset ile eşleşen alt string'leri siler

func Trim(s, cutset string) string

String'in sol ucunu düzenler, cutset ile eşleşen alt string'leri siler

func TrimLeft(s, cutset string) string

String'in sol önekini düzenler, cutset ile eşleşen alt string'i siler, eşleşmezse string s döndürülür

func TrimPrefix(s, suffix string) string

String'in sağ ucunu düzenler, cutset ile eşleşen alt string'leri siler

func TrimRight(s, cutset string) string

String'in sağ sonekini düzenler, cutset ile eşleşen alt string'i siler, eşleşmezse string s döndürülür

func TrimSuffix(s, suffix string) string

Örnek

func TestTrim(t *testing.T) {
  fmt.Println(strings.Trim("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimLeft("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimRight("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimPrefix("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimSuffix("!!this is a test statement!!", "!!!"))
}

Çıktı

=== RUN   TestTrim
this is a test statement
this is a test statement!!
!!this is a test statement
!!this is a test statement!!
!!this is a test statement!!
--- PASS: TestTrim (0.00s)
PASS

String Builder

String Builder, doğrudan string işlemeye kıyasla daha fazla bellek tasarrufu sağlar.

type Builder struct {
  // İç alanlar dışa açık değildir
}

Örnek

func TestBuilder(t *testing.T) {
   builder := strings.Builder{}
   builder.WriteString("hello")
   builder.WriteString(" world")
   fmt.Println(builder.Len())
   fmt.Println(builder.String())
}

Çıktı

=== RUN   TestBuilder
11
hello world
--- PASS: TestBuilder (0.00s)
PASS

TIP

Builder'ı değer olarak aktarmaya çalışmayın, örneğin strings.Builder'ı fonksiyon parametresi olarak aktardığınızda, program panic yapar

strings: illegal use of non-zero Builder copied by value

İçerisinde aşağıdaki kod bulunur

type Builder struct {
  addr *Builder //Kendi adresi
  buf  []byte
}

func (b *Builder) copyCheck() {
   if b.addr == nil {
      b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
   } else if b.addr != b {
      panic("strings: illegal use of non-zero Builder copied by value")
   }
}

Builder'dan değer kopyalandığında, iç slice'ın işaretçisi de kopyalanır, iki Builder string yazarken aynı slice üzerinde işlem yapar, bu da değer kopyalamaya izin verilmemesinin nedenidir.

String Replacer

Replacer string değiştirmek için kullanılır

func NewReplacer(oldnew ...string) *Replacer

Örnek

func TestReplacer(t *testing.T) {
  r := strings.NewReplacer("<", "<", ">", ">")
  fmt.Println(r.Replace("This is <b>HTML</b>!"))
}

Çıktı

This is <b>HTML</b>!

String Reader

Reader, io.Reader, io.ReaderAt, io.ByteReader, io.ByteScanner, io.RuneReader, io.RuneScanner, io.Seeker ve io.WriterTo arayüzlerini implement eder.

func NewReader(s string) *Reader

Örnek

func TestReader(t *testing.T) {
   reader := strings.NewReader("abcdefghijk")
   buffer := make([]byte, 20, 20)
   read, err := reader.Read(buffer)
   if err != nil {
      log.Panic(err)
   }
   fmt.Println(read)
   fmt.Println(string(buffer))
}

Çıktı

=== RUN   TestReader
11
abcdefghijk
--- PASS: TestReader (0.00s)
PASS