go语言怎么比较字符串

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 }

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 < b.N; i++ { 		str.Equal2("go", "Go") 	} } func BenchmarkStrCompare(b *testing.B) { 	for i := 0; i < b.N; i++ { 		str.Compare("go", "Go") 	} } func BenchmarkStrCompare2(b *testing.B) { 	for i := 0; i < b.N; i++ { 		str.Compare2("go", "Go") 	} } func BenchmarkStrEqualFold(b *testing.B) { 	for i := 0; i < b.N; i++ { 		str.EqualFold("go", "Go") 	} }

package strings  // Compare returns an integer comparing two strings lexicographically. // The result will be 0 if a==b, -1 if a < b, and +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 < b { 		return -1 	} 	return +1 }

// 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 }