Refactor string split functions

Author: tiendc

README.md

@@ -130,7 +130,7 @@ go get github.com/tiendc/gofn
 **String**
   - [RuneLength](#runelength)
   - [RandString / RandStringEx](#randstring--randstringex)
-  - [StringSplitEx](#stringsplitex)
+  - [StringSplit / StringSplitN](#stringsplit--stringsplitn)
   - [StringJoin / StringJoinEx / StringJoinBy](#stringjoin--stringjoinex--stringjoinby)
   - [StringLexJoin / StringLexJoinEx](#stringlexjoin--stringlexjoinex)
   - [StringWrap / StringUnwrap](#stringwrap--stringunwrap)
@@ -1064,13 +1064,14 @@ RandString(10)                         // Generates a string of 10 characters fr
 RandStringEx(10, []rune("0123456789")) // Generates a string of 10 characters from the specified ones
 ```
 
-#### StringSplitEx
+#### StringSplit / StringSplitN
 
 Splits a string with handling quotes by ignoring any separator within the quotes.
 
 ```go
-StringSplitEx("ab cd \"12 34\"", " ", "\"") // "[]string{"ab", "cd", "\"12 34\""}
-StringSplitEx("ab cd {12 34}", " ", "{ }")  // "[]string{"ab", "cd", "{12 34}"}
+StringSplit("ab cd \"12 34\"", " ", "\"")     // "[]string{"ab", "cd", "\"12 34\""}
+StringSplit("ab cd {12 34}", " ", "{ }")      // "[]string{"ab", "cd", "{12 34}"}
+StringSplitN("ab cd {12 34}", " ", "{ }", 2)  // "[]string{"ab", "cd {12 34}"}
 ```
 
 #### StringJoin / StringJoinEx / StringJoinBy

string.go

@@ -223,13 +223,20 @@ func StringToLower1stLetter(s string) string {
 	return string(runes)
 }
 
-// StringSplitEx splits a string with handling quotes.
+// StringSplit splits a string with handling quotes.
 // `quote` param can be a single char (`"`, `'`...) if opening and closing tokens are the same,
 // or a space-delimited string (`{ }`, `[ ]`, `{{ }}`...) if the tokens are different.
-func StringSplitEx(s string, sep, quote string) (res []string) {
+func StringSplit(s string, sep, quote string) (res []string) {
+	return StringSplitN(s, sep, quote, -1)
+}
+
+// StringSplitN splits a string with handling quotes.
+// `quote` param can be a single char (`"`, `'`...) if opening and closing tokens are the same,
+// or a space-delimited string (`{ }`, `[ ]`, `{{ }}`...) if the tokens are different.
+func StringSplitN(s string, sep, quote string, n int) (res []string) {
 	quoteParts := strings.Split(quote, " ")
-	if s == "" || sep == "" || quote == "" || len(quoteParts) > 2 {
-		return strings.Split(s, sep)
+	if s == "" || sep == "" || quote == "" || len(quoteParts) > 2 || n == 0 || n == 1 {
+		return strings.SplitN(s, sep, n)
 	}
 
 	runes, sepRunes := []rune(s), []rune(sep)
@@ -254,6 +261,10 @@ func StringSplitEx(s string, sep, quote string) (res []string) {
 		}
 		if j, match := stringSubMatch(runes, i, sepRunes); match {
 			res = append(res, string(currPart))
+			if n > 0 && len(res) == n-1 {
+				res = append(res, string(runes[j:]))
+				return res
+			}
 			currPart = make([]rune, 0, 10) //nolint:mnd
 			i = j
 			continue

string_test.go

@@ -204,28 +204,58 @@ func Test_StringToLower1stLetter(t *testing.T) {
 	assert.Equal(t, "ối", StringToLower1stLetter("Ối"))
 }
 
-func Test_StringSplitEx(t *testing.T) {
-	assert.Equal(t, []string{""}, StringSplitEx("", " ", "\""))
-	assert.Equal(t, []string{"", ""}, StringSplitEx(" ", " ", "\""))
-	assert.Equal(t, []string{"", "", ""}, StringSplitEx(",,", ",", "`"))
+func Test_StringSplit(t *testing.T) {
+	// NOTE: most cases are tested by Test_StringSplitN
+	assert.Equal(t, []string{""}, StringSplit("", " ", "\""))
+	assert.Equal(t, []string{"", ""}, StringSplit(" ", " ", "\""))
+	assert.Equal(t, []string{"", "", ""}, StringSplit(",,", ",", "`"))
 
-	assert.Equal(t, []string{"abc"}, StringSplitEx("abc", " ", "\""))
+	assert.Equal(t, []string{"abc"}, StringSplit("abc", " ", "\""))
 	assert.Equal(t, []string{"", "ab", "", "cd", "12", "", "", "34", ""},
-		StringSplitEx(" ab  cd 12   34 ", " ", "\""))
+		StringSplit(" ab  cd 12   34 ", " ", "\""))
 	assert.Equal(t, []string{"ab", "xy", "\"12 34 \"56"},
-		StringSplitEx("ab xy \"12 34 \"56", " ", "\""))
+		StringSplit("ab xy \"12 34 \"56", " ", "\""))
 	assert.Equal(t, []string{"ab", "xy", "''12", "34", "'56", ""},
-		StringSplitEx("ab xy ''12 34 '56 ", " ", "'"))
+		StringSplit("ab xy ''12 34 '56 ", " ", "'"))
+}
+
+func Test_StringSplitN(t *testing.T) {
+	assert.Equal(t, []string{""}, StringSplitN("", " ", "\"", -1))
+	assert.Equal(t, []string{"", ""}, StringSplitN(" ", " ", "\"", -1))
+	assert.Equal(t, []string{"", "", ""}, StringSplitN(",,", ",", "`", -1))
+
+	assert.Equal(t, []string{"abc"}, StringSplitN("abc", " ", "\"", -1))
+	assert.Equal(t, []string{"", "ab", "", "cd", "12", "", "", "34", ""},
+		StringSplitN(" ab  cd 12   34 ", " ", "\"", -1))
+	assert.Equal(t, []string{"ab", "xy", "\"12 34 \"56"},
+		StringSplitN("ab xy \"12 34 \"56", " ", "\"", -1))
+	assert.Equal(t, []string{"ab", "xy", "''12", "34", "'56", ""},
+		StringSplitN("ab xy ''12 34 '56 ", " ", "'", -1))
 
 	assert.Equal(t, []string{"", "ab", "", "cd", "[12  34][ 56 ]", ""},
-		StringSplitEx(" ab  cd [12  34][ 56 ] ", " ", "[ ]"))
+		StringSplitN(" ab  cd [12  34][ 56 ] ", " ", "[ ]", -1))
 	assert.Equal(t, []string{"", "ab", "", "cd", "[12  34]", "[ 56 ]", ""},
-		StringSplitEx(" ab  cd [12  34] [ 56 ] ", " ", "[ ]"))
+		StringSplitN(" ab  cd [12  34] [ 56 ] ", " ", "[ ]", -1))
 	assert.Equal(t, []string{"", "ab", "", "cd", "[[12  34]", "56", ""},
-		StringSplitEx(" ab  cd [[12  34] 56 ", " ", "[ ]"))
+		StringSplitN(" ab  cd [[12  34] 56 ", " ", "[ ]", -1))
 	assert.Equal(t, []string{"", "ab", "", "cd", "[[[12  34]", "56", ""},
-		StringSplitEx(" ab  cd [[[12  34] 56 ", " ", "[ ]"))
+		StringSplitN(" ab  cd [[[12  34] 56 ", " ", "[ ]", -1))
 
 	assert.Equal(t, []string{"", "ab", "", "cd", "{{12  34}}", "{56", "78}", ""},
-		StringSplitEx(" ab  cd {{12  34}} {56 78} ", " ", "{{ }}"))
+		StringSplitN(" ab  cd {{12  34}} {56 78} ", " ", "{{ }}", -1))
+
+	// When n is not -1
+	assert.Equal(t, []string(nil), StringSplitN("", " ", "\"", 0))
+	assert.Equal(t, []string(nil), StringSplitN("abc", " ", "\"", 0))
+	assert.Equal(t, []string{""}, StringSplitN("", " ", "\"", 1))
+	assert.Equal(t, []string{"abc"}, StringSplitN("abc", " ", "\"", 1))
+
+	assert.Equal(t, []string{"", "ab  cd [12  34][ 56 ] "},
+		StringSplitN(" ab  cd [12  34][ 56 ] ", " ", "[ ]", 2))
+	assert.Equal(t, []string{"ab", " cd [12  34][ 56 ] "},
+		StringSplitN("ab  cd [12  34][ 56 ] ", " ", "[ ]", 2))
+	assert.Equal(t, []string{"ab", "", "cd [12  34][ 56 ] "},
+		StringSplitN("ab  cd [12  34][ 56 ] ", " ", "[ ]", 3))
+	assert.Equal(t, []string{"ab", "cd", "[12  34][ 56 ]", ""},
+		StringSplitN("ab cd [12  34][ 56 ] ", " ", "[ ]", 4))
 }