Memanipulasi String dalam Bahasa Go

• Membandingkan String

str1 := "A string"

str2 := "A " + "string"

if (str1 == str2) {

   fmt.Printf("’%s’ and ’%s’ are equal\n", str1,str2)

}

if (&str1 == &str2) {

   fmt.Printf("’%s’ and ’%s’ are identical\n",str1, str2)

}

str2 += " with a suffix"

if (str1 < str2) {

   fmt.Printf("’%s’ comes before ’%s’\n", str1,str2)

}

       Go string adalah jenis High-Level, dan memiliki konsep kesetaraan built in. Sebagian besar bug dalam kode C berhubungan dengan penanganan string, dan penyempurnaan ini adalah salah satu tugas penting ketika merancang Go. Hal ini jelas ketika membandingkan string dalam dua bahasa. Dalam C, string hanya sebuah pointer ke beberapa byte di suatu tempat di memori. Di Go, itu adalah jenis data yang nyata, dibangun di atas abstraksi tingkat rendah yang sama, tetapi memberikan lebih friendly interface-manusia. Bila menggunakan operator perbandingan yang normal di Go, akan mendapatkan hasil yang masuk akal mengingat isi semantik string. Jika dua string memiliki isi karakter yang sama, mereka dianggap sama. Kurang dan lebih besar daripada operator akan mengembalikan pemesanan berdasarkan pemesanan leksikal mereka. Sayangnya, hal ini menyoroti salah satu daerah di Go yang saat ini sangat lemah. String memerintahkan berdasarkan Unicode yang nilai-nilai karakter konstituen mereka. dalam beberapa lokal, ini benar, tetapi pada orang lain itu tidak. Misalnya, pemesanan antara E dan É sangat tergantung pada lokal. Dalam beberapa, mereka harus bersama-sama, tetapi lokal lain, karakter beraksen datang setelah semua karakter non-beraksen. Go saat ini tidak memberikan berarti lokal-sadar menyortir string. Dalam C++, bisa menggunakan operator overloading untuk mendefinisikan tipe string baru yang didukung lokal-sadar penyortiran. Kurangnya operator overloading di Go membuat ini mungkin.

• Pengolahan String Satu Karakter Sekaligus

func main() {

str := "Étoilé"

// Don’t do this!

for i := 0 ; i<len(str) ; i++ {

   fmt.Printf("%c", str[i])

}

fmt.Printf("\n")

// Do this instead

for _, c := range str {

   fmt.Printf("%c", c)

}

fmt.Printf("\n")

}

Outputnya adalah:

Ãtoilé

Étoilé

      Cara naif iterasi karakter dalam string akan menggunakan loop pengindeksan masing-masing karakter. Ini berjalan tetapi mengiterasi atas setiap byte, tidak setiap karakter. UTF-8 adalah cara pengkodean karakter Unicode. Ada beberapa pengkodean yang berbeda untuk  Unicode, dengan UTF-8 dan UTF-16 menjadi dua yang paling umum. Kedua hal ini adalah multibyte pengkodean karakter, yang berarti bahwa satu karakter dapat diwakili oleh lebih dari satu byte. Bahkan, mereka sama-sama variabel dan panjang pengkodean dengan baik. 8 dan 16 di nama mereka mengacu pada jumlah bit dalam pengkodean terkecil. Karakter dikodekan dalam UTF-8 adalah suatu tempat antara satu dan empat byte panjang, tergantung pada karakter. 128 karakter ASCII semua byte tunggal, sedangkan karakter lain yang lebih panjang. Iterate atas string menggunakan indeks byte, maka kode dapat bekerja. Hanya satu dari karakter dalam bagian sejauh ini memiliki encoding multibyte dalam UTF-8. Jika bahasa Inggris adalah bahasa asli, maka itu sangat mudah untuk menguji kode yang berurusan dengan string untuk input data yang terlihat representatif, dan kemudian memiliki waktu istirahat pertama pada orang lain yang menggunakannya.

• Processing a Partial String One Character at a Time

package
main
import "fmt"
import "unicode/utf8"
func main(){
str :="Étoilé"
rune:=make([]byte,0,4)
for i:=0;i<len(str);i++{
     rune=append(rune,str[i])
     if (utf8.FullRune(rune)){
          char,_:=utf8.DecodeRune(rune)
          fmt.Printf("%c",char)
          rune=rune[0:0]
     }
}
fmt.Printf("\n")
}
        Apabila memiliki string lengkap dalam memori, mudah untuk mengiterasi hal tersebut, tetapi apa yang terjadi ketika menerima teks dari jaringan, atau membaca dari disk? Dalam kedua kasus, biasanya akan berakhir dengan buffer byte penuh dalam UTF-8 format.
Dengan data ASCII, hal ini tidak akan menjadi masalah. Satu byte berarti satu karakter. Dengan UTF-8, satu byte mungkin karakter, atau mungkin byte pertama dalam karakter multibyte. Paket unicode / utf8 menyediakan beberapa manfaat fungsi untuk menyediakan dua apart. Contoh ini dari bagian awal menggunakan string statis, tetapi kode yang sama akan bekerja pada aliran byte yang diperoleh dari berbagai sumber. Ini mengumpulkan byte ke dalam buffer pendek sampai mereka
mewakili karakter lengkap, dan kemudian menerjemahkan mereka.Ini cukup rumit. Ini menunjukkan beberapa fasilitas manipulasi string di Go yang lebih rumit, tetapi dalam kode nyata akan jauh lebih mungkin untuk menggunakan sesuatu di sepanjang baris dari contoh partialStringIterate2.go.

func main() {
str := "Étoilé"
bytes := str[0:7]
str2 := string(bytes)
for i, c := range str2 {
     if (0xFFFD == c) {
          str2 = str2[i:]
          break
     } else {
          fmt.Printf("%c", c)
     }
}
fmt.Printf("\n")
}
        Ini menggunakan iterasi string normal, tetapi pemeriksaan nilai 0xFFFD untuk mewakili Rune tidak valid. Jika menemukan satu, maka menyimpan string parsial dan kemudian lolos dari loop. Untuk efisiensi, bisa melewatkan cek ini untuk sebagian besar string, dan hanya melakukan itu di beberapa byte terakhir. Jika menemukan Rune tidak valid di suatu tempat sebelum akhir string, itu berarti bahwa data masukan adalah contoh invalid. Ini mulai dengan mengiris string dalam urutan tengah multibyte, di tengah-tengah é membuntuti di Etoile. Hal ini sangat mudah dilakukan oleh error . Secara umum, harus menghindari string mengiris langsung. Paket utf8 berisi Iris () fungsi, yang irisan string pada saat run indeks, bukan pada indeks byte.

• Splitting and Trimming Strings

import "strings"

import "fmt"

func main() {

str := "\tThis is a string \n"

str = strings.Trim(str, " \t\n\r")

words := strings.Split(str, " ")

for _, word := range words {

    fmt.Printf("%s\n", word)

}

}

Paket string berisi beberapa fungsi yang membantu untuk memanipulasi data string . Ini termasuk pemecahan dan pencarian string. Salah satu kegiatan yang sangat umum adalah pemangkasan spasi dari ujung string. Baik contoh trimStrings.go dan splitString.go menunjukkan cara untuk melakukan ini. Yang pertama secara eksplisit menyatakan karakter untuk mengobati sebagai ruang: ruang, tab, carriage return, dan line feed. Yang kedua adalah lebih menarik. Ia menggunakan isspace () fungsi dari paket unicode. Fungsi ini mengidentifikasi apakah karakter Unicode digolongkan sebagai spasi. Dapat menggunakan mekanisme yang sama dengan fungsi lain untuk memangkas jenis leading dan trailing data. Paket unicode menyediakan beberapa fungsi lainnya yang dapat digunakan di sini, tetapi juga dapat menentukan sendiri, untuk menentukan satu set algoritma. Jika pernah menggunakan strtok () atau strsep () di C, maka akan memudahkan string membelah di Go. Fungsi Split () dari Paket string membagi string berdasarkan pemisah yang disediakan. Penggunaan untuk membagi string menjadi kata-kata, dipisahkan dengan spasi. Hasilnya adalah sepotong string, sehingga dapat dengan mudah beralih di atas hanya akan setiap slice lain. Memisahkan string pada indeks karakter tertentu adalah sedikit lebih susah. Contoh splitString.go menunjukkan apa yang terjadi ketika mendapatkan salah ini. Hal ini menunjukkan dua cara membelah setengah string .

package main

import "strings"

import "unicode"

import "exp/utf8string"

import "fmt"

func main() {

str := "\tthe important rôles of utf8 text\n"

str = strings.TrimFunc(str, unicode.IsSpace)

// The wrong way

fmt.Printf("%s\n", str[0:len(str)/2])

// The right way

u8 := utf8string.NewString(str)

FirstHalf := u8.Slice(0, u8.RuneCount()/2)

fmt.Printf("%s\n", FirstHalf)

}

outputnya :

the important r?

the important rô

• Menggakan String

str := "A string"

bytes := make([]byte, len(str))

copy(bytes, str)

strCopy := string(bytes)

       String di Go berubah, sehingga tidak perlu untuk menyalinnya. Fungsi Copy () builtin ini memungkinkan untuk menyalin string ke byte slice preallocated, mengembalikan jumlah byte yang disalin. Setelah punya data string dalam sepotong, dapat memodifikasi dengan cara apapun yang diinginkan. Kemudian dapat membuat string baru dari irisan dengan string standar () konversi. Juga dapat menggunakan append () untuk menambahkan string ke sepotong bytes. Catatan bahwa ketika melakukan hal ini data string akan disalin dua kali, sekali ke slice dan sekali untuk membuat string baru. Hal ini cukup efisien, sehingga harus dihindari kecuali untuk string pendek.