Bagaimana untuk membandingkan rentetan dalam bahasa go

Kaedah perbandingan: 1. Gunakan operator "==" secara langsung untuk membandingkan, sintaksnya ialah "str1 == str2", kaedah ini sensitif huruf besar-besaran. 2. Gunakan fungsi Compare() pada pakej rentetan untuk membandingkan, dengan sintaks "strings.Compare(a,b)"; b, dan "-1" bermaksud a adalah kurang daripada b. 3. Gunakan perbandingan EqualFold() bagi pakej rentetan, sintaksnya ialah "strings.EqualFold(a,b)".

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Kaedah perbandingan rentetan bahasa Go Terdapat tiga kaedah perbandingan rentetan dalam bahasa go:

== Perbandingan langsung, kes sensitif strings.Compare(a,b) Nilai pulangan bagi fungsi ini ialah int, 0 bermakna dua nombor adalah sama, 1 bermaksud a>b, -1 bermaksud a strings.EqualFold(a,b) Mengembalikan secara langsung sama ada ia sama, bukan sensitif huruf besar. Contohnya adalah seperti berikut: // 1-Gunakan perbandingan tanda sama - bezakan mesej besar

func Equal(s1, s2 string) bool { return s1 == s2 }

// 2-使用 compare 比较——区分大小写 func Compare(s1, s2 string) bool { return strings.Compare(s1, s2) == 0 // }

//3-EqualFold 比较——不区分大小写. case-fold 即大小写同一处理 func EqualFold(s1, s2 string) bool { return strings.EqualFold(s1, s2) }

// 使用等号比较——忽略大小写 func Equal2(s1, s2 string) bool { return strings.ToLower(s1) == strings.ToLower(s2) }

// 使用 compare 比较——不区分大小写 func Compare2(s1, s2 string) bool { return strings.Compare(strings.ToLower(s1), strings.ToLower(s2)) == 0 }

func StringCompareTest() { fmt.Println("== 区分大小写", Equal("go", "Go")) //false fmt.Println("== 忽略大小写",Equal2("go", "Go")) //true fmt.Println("compare 区分大小写",Compare("go", "Go")) //false fmt.Println("compare 忽略大小写",Compare2("go", "Go")) //true fmt.Println("EqualFold 忽略大小写",EqualFold("go", "Go")) // true } Perbandingan Prestasi Kod berikut menggunakan Penanda Aras untuk melakukan perbandingan prestasi mudah Struktur direktori projek ujian ialah:

Kod terperinci:

package test

import ( "../str" "testing" )

func BenchmarkStrEqual(b *testing.B) { for i := 0; i < b.N; i++ { str.Equal("go", "Go") } } func BenchmarkStrEqual2(b *testing.B) { for i := 0; i Keputusan ujian adalah seperti berikut:

Seperti yang dapat dilihat dari gambar di atas, yang paling berkesan ialah ==

Analisis ringkas kod sumber 1.Bandingkan package strings

// Compare returns an integer comparing two strings lexicographically. // The result will be 0 if a==b, -1 if a b. // // Compare is included only for symmetry with package bytes. // It is usually clearer and always faster to use the built-in // string comparison operators ==, , and so on. func Compare(a, b string) int { // NOTE(rsc): This function does NOT call the runtime cmpstring function, // because we do not want to provide any performance justification for // using strings.Compare. Basically no one should use strings.Compare. // As the comment above says, it is here only for symmetry with package bytes. // If performance is important, the compiler should be changed to recognize // the pattern so that all code doing three-way comparisons, not just code // using strings.Compare, can benefit. if a == b { return 0 } if a Seperti yang ditunjukkan di atas, kami mendapati perkara yang sama berlaku di dalam Bandingkan dipanggil, dan ulasan fungsi juga mengatakan bahawa fungsi ini hanya untuk simetri dengan bait pakej. Dan adalah disyorkan bahawa kita menggunakan == dan == , > secara langsung.

2. rentetan.EqualFold // EqualFold reports whether s and t, interpreted as UTF-8 strings, // are equal under Unicode case-folding, which is a more general // form of case-insensitivity. func EqualFold(s, t string) bool { for s != "" && t != "" { // Extract first rune from each string. var sr, tr rune if s[0] < utf8.RuneSelf { sr, s = rune(s[0]), s[1:] } else { r, size := utf8.DecodeRuneInString(s) sr, s = r, s[size:] } if t[0] < utf8.RuneSelf { tr, t = rune(t[0]), t[1:] } else { r, size := utf8.DecodeRuneInString(t) tr, t = r, t[size:] }

// If they match, keep going; if not, return false.

// Easy case. if tr == sr { continue }

// Make sr < tr to simplify what follows. if tr < sr { tr, sr = sr, tr } // Fast check for ASCII. if tr < utf8.RuneSelf { // ASCII only, sr/tr must be upper/lower case if 'A' <= sr && sr <= 'Z' && tr == sr+'a'-'A' { continue } return false }

// General case. SimpleFold(x) returns the next equivalent rune > x // or wraps around to smaller values. r := unicode.SimpleFold(sr) for r != sr && r < tr { r = unicode.SimpleFold(r) } if r == tr { continue } return false }

// One string is empty. Are both? return s == t } Fungsi ini menjalankan satu siri operasi untuk menukar dua rentetan menjadi Rentetan dibandingkan , mengabaikan kes apabila membandingkan. utf-8

Ringkasan Melalui ringkasan dan analisis mudah di atas, kami mendapati bahawa perbandingan rentetan harus dilakukan secara langsung menggunakan ==, >, [Cadangan berkaitan: Pergi tutorial video , Pengajaran pengaturcaraan ]

Bagaimana untuk membandingkan rentetan dalam bahasa go

Artikel berkaitan