perf(util/CompareNumInStr): use byte slice to reduce operation latency

Author: marjune163

src/serverHandler/responseData.go

@@ -199,7 +199,7 @@ func sortSubItems(subItems []os.FileInfo) {
 				return prevIsDir
 			}
 
-			return util.CompareNumInStr(prevItem.Name(), nextItem.Name())
+			return util.CompareNumInStr([]byte(prevItem.Name()), []byte(nextItem.Name()))
 		},
 	)
 }

src/util/compareNumInStr.go

@@ -2,7 +2,7 @@ package util
 
 import "bytes"
 
-func findCommonPrefix(prev, next string) int {
+func findCommonPrefix(prev, next []byte) int {
 	prevLen := len(prev)
 	nextLen := len(next)
 
@@ -22,19 +22,20 @@ func findCommonPrefix(prev, next string) int {
 	return maxLen
 }
 
-func extractPrefixDigits(input string) (output string) {
-	buffer := bytes.NewBuffer(make([]byte, 0, 8))
-	for i, length := 0, len(input); i < length; i++ {
-		b := input[i]
+func extractPrefixDigits(input []byte) []byte {
+	buf := input[0:0]
+
+	var prefixLen, length int
+	for prefixLen, length = 0, len(input); prefixLen < length; prefixLen++ {
+		b := input[prefixLen]
 		if b < '0' || b > '9' {
 			break
 		}
-		buffer.WriteByte(b)
 	}
-	return buffer.String()
+	return buf[:prefixLen]
 }
 
-func CompareNumInStr(prev, next string) bool {
+func CompareNumInStr(prev, next []byte) bool {
 	if len(prev) == 0 {
 		return true
 	} else if len(next) == 0 {
@@ -62,13 +63,14 @@ func CompareNumInStr(prev, next string) bool {
 		return prevDigitsLen < nextDigitsLen
 	}
 
-	if prevDigitsLen == 0 {
-		return prev < next
+	if prevDigitsLen == 0 { // prevDigitsLen and nextDigitsLen is 0
+		return bytes.Compare(prev, next) < 0
 	}
 
-	if prevDigits == nextDigits {
-		return CompareNumInStr(prev[prevDigitsLen:], next[nextDigitsLen:])
+	compareResult := bytes.Compare(prevDigits, nextDigits)
+	if compareResult != 0 {
+		return compareResult < 0
 	} else {
-		return prevDigits < nextDigits
+		return CompareNumInStr(prev[prevDigitsLen:], next[nextDigitsLen:])
 	}
 }

src/util/compareNumInStr_test.go

@@ -7,31 +7,38 @@ func TestCompareNumInStr(t *testing.T) {
 
 	prev = "2"
 	next = "3"
-	if CompareNumInStr(prev, next) != true {
+	if CompareNumInStr([]byte(prev), []byte(next)) != true {
 		t.Error(prev, next)
 	}
 
 	prev = "2"
 	next = "20"
-	if CompareNumInStr(prev, next) != true {
+	if CompareNumInStr([]byte(prev), []byte(next)) != true {
 		t.Error(prev, next)
 	}
 
 	prev = "1.1"
 	next = "1.10"
-	if CompareNumInStr(prev, next) != true {
+	if CompareNumInStr([]byte(prev), []byte(next)) != true {
 		t.Error(prev, next)
 	}
 
 	prev = "1.2"
 	next = "1.10"
-	if CompareNumInStr(prev, next) != true {
+	if CompareNumInStr([]byte(prev), []byte(next)) != true {
 		t.Error(prev, next)
 	}
 
 	prev = "1.3.2"
 	next = "1.3.10"
-	if CompareNumInStr(prev, next) != true {
+	if CompareNumInStr([]byte(prev), []byte(next)) != true {
 		t.Error(prev, next)
 	}
 }
+
+func TestExtractPrefixDigits(t *testing.T) {
+	result := string(extractPrefixDigits([]byte("123.haha")))
+	if result != "123" {
+		t.Error(result)
+	}
+}