Correction of word assert spelling mistakes (#269)

:

algorithm/lrucache_test.go

@@ -8,7 +8,7 @@ import (
 
 func TestLRUCache(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestLRUCache")
+	assert := internal.NewAssert(t, "TestLRUCache")
 
 	cache := NewLRUCache[int, int](3)
 
@@ -16,19 +16,19 @@ func TestLRUCache(t *testing.T) {
 	cache.Put(2, 2)
 	cache.Put(3, 3)
 
-	asssert.Equal(3, cache.Len())
+	assert.Equal(3, cache.Len())
 
 	v, ok := cache.Get(1)
-	asssert.Equal(true, ok)
-	asssert.Equal(1, v)
+	assert.Equal(true, ok)
+	assert.Equal(1, v)
 
 	v, ok = cache.Get(2)
-	asssert.Equal(true, ok)
-	asssert.Equal(2, v)
+	assert.Equal(true, ok)
+	assert.Equal(2, v)
 
 	ok = cache.Delete(2)
-	asssert.Equal(true, ok)
+	assert.Equal(true, ok)
 
 	_, ok = cache.Get(2)
-	asssert.Equal(false, ok)
+	assert.Equal(false, ok)
 }

algorithm/search_test.go

@@ -8,34 +8,34 @@ import (
 
 func TestLinearSearch(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestLinearSearch")
+	assert := internal.NewAssert(t, "TestLinearSearch")
 
 	numbers := []int{3, 4, 5, 3, 2, 1}
 	equalFunc := func(a, b int) bool {
 		return a == b
 	}
 
-	asssert.Equal(0, LinearSearch(numbers, 3, equalFunc))
-	asssert.Equal(-1, LinearSearch(numbers, 6, equalFunc))
+	assert.Equal(0, LinearSearch(numbers, 3, equalFunc))
+	assert.Equal(-1, LinearSearch(numbers, 6, equalFunc))
 }
 
 func TestBinarySearch(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestBinarySearch")
+	assert := internal.NewAssert(t, "TestBinarySearch")
 
 	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
 	comparator := &intComparator{}
 
-	asssert.Equal(4, BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	asssert.Equal(-1, BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(4, BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(-1, BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
 }
 
 func TestBinaryIterativeSearch(t *testing.T) {
-	asssert := internal.NewAssert(t, "TestBinaryIterativeSearch")
+	assert := internal.NewAssert(t, "TestBinaryIterativeSearch")
 
 	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
 	comparator := &intComparator{}
 
-	asssert.Equal(4, BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	asssert.Equal(-1, BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(4, BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
+	assert.Equal(-1, BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
 }

algorithm/sort_test.go

@@ -47,7 +47,7 @@ func (c *intComparator) Compare(v1 any, v2 any) int {
 
 func TestBubbleSortForStructSlice(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
+	assert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -62,23 +62,23 @@ func TestBubbleSortForStructSlice(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestBubbleSortForIntSlice(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
+	assert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
 
 	numbers := []int{2, 1, 5, 3, 6, 4}
 	comparator := &intComparator{}
 	BubbleSort(numbers, comparator)
 
-	asssert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
 }
 
 func TestInsertionSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestInsertionSort")
+	assert := internal.NewAssert(t, "TestInsertionSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -93,12 +93,12 @@ func TestInsertionSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestSelectionSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestSelectionSort")
+	assert := internal.NewAssert(t, "TestSelectionSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -113,12 +113,12 @@ func TestSelectionSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestShellSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestShellSort")
+	assert := internal.NewAssert(t, "TestShellSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -133,12 +133,12 @@ func TestShellSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestQuickSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestQuickSort")
+	assert := internal.NewAssert(t, "TestQuickSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -153,12 +153,12 @@ func TestQuickSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestHeapSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestHeapSort")
+	assert := internal.NewAssert(t, "TestHeapSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -173,12 +173,12 @@ func TestHeapSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestMergeSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestMergeSort")
+	assert := internal.NewAssert(t, "TestMergeSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -193,12 +193,12 @@ func TestMergeSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", peoples)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }
 
 func TestCountSort(t *testing.T) {
 	t.Parallel()
-	asssert := internal.NewAssert(t, "TestCountSort")
+	assert := internal.NewAssert(t, "TestCountSort")
 
 	peoples := []people{
 		{Name: "a", Age: 20},
@@ -213,5 +213,5 @@ func TestCountSort(t *testing.T) {
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
 	actual := fmt.Sprintf("%v", sortedPeopleByAge)
 
-	asssert.Equal(expected, actual)
+	assert.Equal(expected, actual)
 }

condition/condition.go

@@ -72,10 +72,17 @@ func Nand[T, U any](a T, b U) bool {
 
 // TernaryOperator checks the value of param `isTrue`, if true return ifValue else return elseValue.
 // Play: https://go.dev/play/p/ElllPZY0guT
-func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U {
+func Ternary[T, U any](isTrue T, ifValue U, elseValue U) U {
 	if Bool(isTrue) {
 		return ifValue
 	} else {
 		return elseValue
 	}
 }
+
+// TernaryOperator checks the value of param `isTrue`, if true return ifValue else return elseValue.
+// Play: https://go.dev/play/p/ElllPZY0guT
+// Deprecated: Use Ternary instead.
+func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U {
+	return Ternary(isTrue, ifValue, elseValue)
+}

condition/condition_example_test.go

@@ -148,13 +148,13 @@ func ExampleNand() {
 	// false
 }
 
-func ExampleTernaryOperator() {
+func ExampleTernary() {
 	conditionTrue := 2 > 1
-	result1 := TernaryOperator(conditionTrue, 0, 1)
+	result1 := Ternary(conditionTrue, 0, 1)
 	fmt.Println(result1)
 
 	conditionFalse := 2 > 3
-	result2 := TernaryOperator(conditionFalse, 0, 1)
+	result2 := Ternary(conditionFalse, 0, 1)
 	fmt.Println(result2)
 
 	// Output:

condition/condition_test.go

@@ -124,13 +124,13 @@ func TestNand(t *testing.T) {
 	assert.Equal(false, Nand(1, 1))
 }
 
-func TestTernaryOperator(t *testing.T) {
+func TestTernary(t *testing.T) {
 	t.Parallel()
 
-	assert := internal.NewAssert(t, "TernaryOperator")
+	assert := internal.NewAssert(t, "TestTernary")
 
 	trueValue := "1"
 	falseValue := "0"
 
-	assert.Equal(trueValue, TernaryOperator(true, trueValue, falseValue))
+	assert.Equal(trueValue, Ternary(true, trueValue, falseValue))
 }

cryptor/rsa_private_example.pem

@@ -1,51 +1,51 @@
 -----BEGIN rsa private key-----
-MIIJJwIBAAKCAgEAsELqn9abxs7ZK81Ipbp5+E/5SrOQycAalnRCES3YPOoAV3Ir
-+99WjEi9Ak4EYS3VrvgISSNiRx1tHDNpBlBqGF+Mww8wAUmrcXsEndbHma/g3zHG
-ueua9GK0l+hQJ/grkatykgD81gam/SPOMPnJSsoQlsTgM47ZHM35adiXqL/gDMZ7
-0lQdB2+03WJXlvfYZWpHsXDqUkveEZbLgZST36ax8ap+Ge2GoLlD1sNapRxMBH1P
-GNdzSdV7ZJmzQ3WmjwDAddLX73YE6vhR5tDAXhrSweNPtIjUhGJsgkW9VTEQWeW9
-cZmFo/jYuvEDgBnZOh1DJe2BHx06Ymr8ZcgsOBYddANsk750II8+qUnBekiJkpo0
-ldCK2VnsLoLM3YCf3Lk7VYuHP6KiCXyh6FzbY1DTRHJRpMJYT8t5xyQis581DbRV
-Pkcse3ig5KsQLe5XXbBBegVrQJpy1b440uZVW2eSpStX5ZAfNVsU0ZPdI4/i6UNM
-Ea6c7tf83S21Q0K6SEZ5PrfBJECRDxFzJWeamwppHY8fdeItVk/cxBJ9XRyOyG9p
-JKMnOMFD++LzGP6uL5FKov7BSplOIMqsJzwh4zkIjAhgbGVQZm17kg1xvF30c2fg
-ijNEoSIuVWJzlQyQ9cmSaSmmi+SPmf/C/IcUDF0nikERs1v58vNESvcZP80CAwEA
-AQKCAgBEN2G+wrw/UUbToPuAyI7z/1+n/Z8HtgWUPSJkq62IxbekIFfNfz5rxKsB
-/VfMlISi1vO9+qfKhiT4SR1YiD7HeBNuWq5lkTF9FfNPcxSE8oDBYO5cfkbWVm02
-bX64OWADXKtWvnMcEi8GwZjHc6ToARQyhbePvLViZIUm5eCsOrZnu1moqU0i16TU
-GX90ui9R8LQWhHDrsNkdTZMtb2dbo5Qyx51OQ5NbGNicgbbPOAhjpGu8XYYNCUZc
-RPAQJ7RynAPgld1km/SDS9/GyPvqb88pouPyJxK4ua7tLDh+hCKj6DpNgPEr6N9Y
-WnbUWSytRS37u9PBSvqRpH5SlgomdgzbTWe4GK2fvIsTcgTKR4CU41YCmjOIZHN9
-NJwN27N3C7ui7XxzuB6tDFu/vCAtsb9//b6PYlLcrOscAJt70GFeUTepeRqt+YOI
-IpvCzVDH0RnNnoscnWUyq/9cEjvkFzFljnU+mmY+OdjoJTCzLaKP0fJwXU5PpgVx
-cgMRgz6ZiRMuHS4bOML9Quk5GGKuPg2rjrIldlFYuA9AOFVFSxzTh7ORObepIuZL
-CBo7NYwEoa7gFGLu+Vl1AXOdfF8M/72G9sEUrf5s19MrsDvWJY5+4qm+NNqys6no
-nASW6I0Vk1nz//OezTIJWXHwRZk+gr9xz1W8tPvek73pOy3TMQKCAQEAx8ntJUqt
-JwFGZuHYGIA5EZ8z+6ETps5ceUhZ6WHB/OQ3TnrXONoHTWza60Lo7RRFcAv6zOWz
-34B3kw/kci8P9I/01g4DxYFUQoUHF7rP/mZfNUj9HG2Vo8spTjrTvTQUSB6Bqhyz
-Yv+8URZ/nh4I/cLQuww7DdxY+1Xi7Tu93WIyADdAV79plm7fIEQxBc1kc4IjWuZ8
-+sIbp+5HwBCqftDtiodhzYZaI+wGbHs5RasF6Uzip5uBIO88c3RQD6FF57rlHIgn
-dG97HQVMhG+Qm8ozsA+b1o0Q4UkI2bjinWtNWnxGEGFp+JFUiIKfNJ4Rc+QoIA0z
-1+isOtXRxl9dzwKCAQEA4dplia8G2E8zCQu1pcRCbDfhWGukPCoxdmGvIgZvShFz
-HxFAVx+0EVu5vZIRUqFFBQVII80a/EFEN9m/X1CnDyjilPuVlBOlSq73EbMOeVUG
-X9L+vlm5krctAsPR2NSBwKUP7P8m4Co+8Ute253+sMATewZdjeluspLL/adO1Ggl
-syy5x3AknNQq9Qi423H8Z96ao6xGDO/H3RogCQ2lKxqF3WwRGmnk7V30beWIHggG
-mJLy+X59uqhOIHeZUuQT5yOtlHBGugWWwJNN251gwMkwkRfGh2vzbJJ+LCTOUeCZ
-nOnlT19jEwZR8jEgfGRqyFcUTcEoKdRwlx6bfuVrowKCAQBnrRDELllmiVHYZ9B0
-/m0fCOe356HECQiR44rNAm7hZiiRMEvpc7MgaaG9Pi6TgNZ7y6utknHiRM9IYJHi
-8ysrdVzPi9xHLNLl5hSFKutuj/9OLn8ytmdV5UKdFwf0AkeYGUSeW2B3ulAmIC+/
-hMSTsvoQZstqaPNAEhS9mSfw71kVJZbdMjZ/2y8sllZ+NVSwYFMqg7tNgVdKsOtI
-7x0azB7IqXKGbfbu9zdqKhPRZGuf4scnxRmgVqWfIDe/tKgLFcB5KuqWkJdpuus3
-OpHnVmm2LpNnJjMhRX4zRa9Lk3hDwYO2Umbkl74vTOGDM5fI9Rghcdh6bYKa0YSX
-lbufAoIBAEjBiiQodhQIr3AijYmxB5TFC5roUifvj6+LGFflqsQ5itRfQlLOq7tL
-yTIAdAQiX5GWef7Oe/r3K3qycqvJ14dSrGtCAJWLHpxIcN8Kx4belQcZeWbokJdq
-2t0hJ+Cp1IKyqca3C1b7RPuGRDCLXRijR6NCEbE9maN9FqnH0+UpB7wIlHBi9+ht
-kMkO3j4TIjRzyW0gehCAzem0GM3Rz3trN+R0g632nwC4W51ra8YA398Wt58X2Hjg
-7woWfRXu01qKa8h9wsr6Me4nhdVRhXGVXkffWN0XMXuwVWTzFmPZ7qJV1sETAV+H
-ka5rlQN9dcjEBI5nwwB2py6HdaATV/ECggEARFhsFFCN7BYotvGsAdf+3qxWvl7y
-VuwcJZFwMj/9m1RdH7d+MojxcVQws6Q8zuWFcpCbnBvtbcAh89+mPyjPGt37nVSU
-BAwkv7ahjDwOygHu5lzVS70ONZGDco3GY31++umKyfLF5Gs2yebhmzAo8pqBvTA6
-05vNfu9e6HE0YsNHUq17v1AgKAW8szA0DLgNWUrn15bH+wtCf07rtKvg1finoatH
-DtL5Il0kUlYZbEJKV7RKaf15t8MEASSK9d+pEq3j+yMnOHkgNE745slkvUoFLQ+J
-GGJE/eE3g2q6naacbvqwjnGzXJZ+36xNqjkdqU1RjcqeJqsLgCiBKkN3Bg==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 -----END rsa private key-----

cryptor/rsa_public_example.pem

@@ -1,14 +1,14 @@
 -----BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAsELqn9abxs7ZK81Ipbp5
-+E/5SrOQycAalnRCES3YPOoAV3Ir+99WjEi9Ak4EYS3VrvgISSNiRx1tHDNpBlBq
-GF+Mww8wAUmrcXsEndbHma/g3zHGueua9GK0l+hQJ/grkatykgD81gam/SPOMPnJ
-SsoQlsTgM47ZHM35adiXqL/gDMZ70lQdB2+03WJXlvfYZWpHsXDqUkveEZbLgZST
-36ax8ap+Ge2GoLlD1sNapRxMBH1PGNdzSdV7ZJmzQ3WmjwDAddLX73YE6vhR5tDA
-XhrSweNPtIjUhGJsgkW9VTEQWeW9cZmFo/jYuvEDgBnZOh1DJe2BHx06Ymr8Zcgs
-OBYddANsk750II8+qUnBekiJkpo0ldCK2VnsLoLM3YCf3Lk7VYuHP6KiCXyh6Fzb
-Y1DTRHJRpMJYT8t5xyQis581DbRVPkcse3ig5KsQLe5XXbBBegVrQJpy1b440uZV
-W2eSpStX5ZAfNVsU0ZPdI4/i6UNMEa6c7tf83S21Q0K6SEZ5PrfBJECRDxFzJWea
-mwppHY8fdeItVk/cxBJ9XRyOyG9pJKMnOMFD++LzGP6uL5FKov7BSplOIMqsJzwh
-4zkIjAhgbGVQZm17kg1xvF30c2fgijNEoSIuVWJzlQyQ9cmSaSmmi+SPmf/C/IcU
-DF0nikERs1v58vNESvcZP80CAwEAAQ==
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA3bRSY5GD7uJB3jvwqa9Z
+ZFpN3uLIGbbPA+yiyf6tJZp3K3rmkVFfEcWqtK1EfHvd9G4rqLYJ9ZcohDZgD/Ww
+mqJtaaWh2/7feMPaitp50bYVilpPhaxULx+MIjQn3XXowYvr4fX7N052t4IC95tA
+anPEEwZRQJOVMtibAxwI/ofUOCpTPtuK3AoErDxS18JPgjQ34yY4Jsch0de53+Sj
+Tk+bJpLUlnY4brm+A23FhwTlE5njrKA+Texrg52KJ8aPhLuVQBcZP1SJsxv2PZru
+uD+0xfLDRrZ7BOTpun+1FBhdlxBefIfBQbBBfy7STw+ignTaO+IRIHhcqKZ+12Na
++4GAusmpSiB3LATy82h0nB0PX3hSOLYmFI61px4l/yM50E4brF1NFtd/BpoozZaj
+gxjJaznuZXFQ1YSG0JjCeszqdzU+6dexGTr+4Lr87NfLekmUX1nZYy/E5lST65lG
+lI4hX1nR5+nVN9ALRYByNz6oJd0IfF4dhoNlGPc1VksskeY8rPZwXITbSifAN7zv
+EiwKreFV3t0BLKsvWRu9GdpWy+d2AmelXkNm+QaH2mPM17euMoNZVyzizrZaJkh/
+aHO/UgY1/y7sXFl4akC9hk9ILONCUn6FVI4BXMXb5kZgwDk5tWE5A159LtC579yG
+cnxyc9Y9NNFOGrqFqPiu6QUCAwEAAQ==
 -----END rsa public key-----

datetime/datetime.go

@@ -443,3 +443,50 @@ func GenerateDatetimesBetween(start, end time.Time, layout string, interval stri
 
 	return result, nil
 }
+
+// Min returns the earliest time among the given times.
+// Play: todo
+func Min(t1 time.Time, times ...time.Time) time.Time {
+	minTime := t1
+
+	for _, t := range times {
+		if t.Before(minTime) {
+			minTime = t
+		}
+	}
+
+	return minTime
+}
+
+// Max returns the latest time among the given times.
+// Play: todo
+func Max(t1 time.Time, times ...time.Time) time.Time {
+	maxTime := t1
+
+	for _, t := range times {
+		if t.After(maxTime) {
+			maxTime = t
+		}
+	}
+
+	return maxTime
+}
+
+// MaxMin returns the latest and earliest time among the given times.
+// Play: todo
+func MaxMin(t1 time.Time, times ...time.Time) (maxTime time.Time, minTime time.Time) {
+	maxTime = t1
+	minTime = t1
+
+	for _, t := range times {
+		if t.Before(minTime) {
+			minTime = t
+		}
+
+		if t.After(maxTime) {
+			maxTime = t
+		}
+	}
+
+	return maxTime, minTime
+}

datetime/datetime_example_test.go

@@ -437,3 +437,32 @@ func ExampleGenerateDatetimesBetween() {
 	// [2024-09-01 00:00:00 2024-09-01 01:00:00 2024-09-01 02:00:00]
 	// <nil>
 }
+
+func ExampleMin() {
+	result := Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(result)
+
+	// Output:
+	// 2024-09-01 00:00:00 +0000 UTC
+}
+
+func ExampleMax() {
+	result := Max(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(result)
+
+	// Output:
+	// 2024-09-02 00:00:00 +0000 UTC
+}
+
+func ExampleMaxMin() {
+	max, min := MaxMin(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 3, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(max)
+	fmt.Println(min)
+
+	// Output:
+	// 2024-09-03 00:00:00 +0000 UTC
+	// 2024-09-01 00:00:00 +0000 UTC
+}

datetime/datetime_test.go

@@ -521,3 +521,60 @@ func TestGenerateDatetimesBetween(t *testing.T) {
 		}
 	})
 }
+
+func TestMin(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMin")
+
+	zeroTime := time.Time{}
+	now := time.Now()
+	oneMinuteAgo := now.Add(-time.Minute)
+	oneMinuteAfter := now.Add(time.Minute)
+
+	assert.Equal(zeroTime, Min(zeroTime, now, oneMinuteAgo, oneMinuteAfter))
+
+	assert.Equal(zeroTime, Min(now, zeroTime))
+
+	assert.Equal(oneMinuteAgo, Min(oneMinuteAgo, now, oneMinuteAfter))
+}
+
+func TestMax(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMax")
+
+	zeroTime := time.Time{}
+	now := time.Now()
+	oneMinuteAgo := now.Add(-time.Minute)
+	oneMinuteAfter := now.Add(time.Minute)
+
+	assert.Equal(oneMinuteAfter, Max(zeroTime, now, oneMinuteAgo, oneMinuteAfter))
+
+	assert.Equal(now, Max(now, zeroTime))
+
+	assert.Equal(oneMinuteAfter, Max(oneMinuteAgo, now, oneMinuteAfter))
+}
+
+func TestMaxMin(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMinMax")
+
+	zeroTime := time.Time{}
+	now := time.Now()
+	oneMinuteAgo := now.Add(-time.Minute)
+	oneMinuteAfter := now.Add(time.Minute)
+
+	max, min := MaxMin(zeroTime, now, oneMinuteAgo, oneMinuteAfter)
+	assert.Equal(zeroTime, min)
+	assert.Equal(oneMinuteAfter, max)
+
+	max, min = MaxMin(now, zeroTime)
+	assert.Equal(zeroTime, min)
+	assert.Equal(now, max)
+
+	max, min = MaxMin(oneMinuteAgo, now, oneMinuteAfter)
+	assert.Equal(oneMinuteAgo, min)
+	assert.Equal(oneMinuteAfter, max)
+}

docs/api/packages/condition.md

@@ -27,7 +27,8 @@ import (
 - [Nor](#Nor)
 - [Xnor](#Xnor)
 - [Nand](#Nand)
-- [TernaryOperator](#TernaryOperator)
+- [Ternary](#Ternary)
+- [TernaryOperator<sup>deprecated</sup>](#TernaryOperator)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -257,9 +258,45 @@ func main() {
 }
 ```
 
+### <span id="Ternary">Ternary</span>
+<p>三元运算符。</p>
+
+<b>函数签名:</b>
+
+```go
+func Ternary[T, U any](isTrue T, ifValue U, elseValue U) U
+```
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+    conditionTrue := 2 > 1
+    result1 := condition.Ternary(conditionTrue, 0, 1)
+
+    conditionFalse := 2 > 3
+    result2 := condition.Ternary(conditionFalse, 0, 1)
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // 1
+}
+```
+
 ### <span id="TernaryOperator">TernaryOperator</span>
 <p>三元运算符</p>
 
+> ⚠️ 本函数已弃用，使用`Ternary`代替。
+
 <b>函数签名:</b>
 
 ```go

docs/api/packages/datetime.md

@@ -67,6 +67,9 @@ import (
 -   [TrackFuncTime](#TrackFuncTime)
 -   [DaysBetween](#DaysBetween)
 -   [GenerateDatetimesBetween](#GenerateDatetimesBetween)
+-   [Min](#Min)
+-   [Max](#Max)
+-   [MaxMin](#MaxMin)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -1570,4 +1573,96 @@ func main() {
     // [2024-09-01 00:00:00 2024-09-01 01:00:00 2024-09-01 02:00:00]
     // <nil>
 }
+```
+
+### <span id="Min">Min</span>
+
+<p>返回最早时间。</p>
+
+<b>函数签名:</b>
+
+```go
+func Min(t1 time.Time, times ...time.Time) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    minTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(minTime)
+
+	// Output:
+	// 2024-09-01 00:00:00 +0000 UTC
+}
+```
+
+### <span id="Max">Max</span>
+
+<p>返回最晚时间。</p>
+
+<b>函数签名:</b>
+
+```go
+func Max(t1 time.Time, times ...time.Time) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    maxTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(maxTime)
+
+	// Output:
+	// 2024-09-02 00:00:00 +0000 UTC
+}
+```
+
+### <span id="MaxMin">MaxMin</span>
+
+<p>返回最早和最晚时间。</p>
+
+<b>函数签名:</b>
+
+```go
+func MaxMin(t1 time.Time, times ...time.Time) (maxTime time.Time, minTime time.Time)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    max, min := datetime.MaxMin(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 3, 0, 0, 0, 0, time.UTC))
+
+	fmt.Println(max)
+	fmt.Println(min)
+
+	// Output:
+	// 2024-09-03 00:00:00 +0000 UTC
+	// 2024-09-01 00:00:00 +0000 UTC
+}
 ```

docs/api/packages/stream.md

@@ -1,6 +1,6 @@
 # Stream
 
-Stream 流，该包仅验证简单 stream 实现，功能有限。
+Stream流，该包仅验证简单stream实现，功能有限。
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -48,6 +48,8 @@ import (
 -   [NoneMatch](#NoneMatch)
 -   [Count](#Count)
 -   [ToSlice](#ToSlice)
+-   [IndexOf](#IndexOf)
+-   [LastIndexOf](#LastIndexOf)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -938,3 +940,69 @@ func main() {
     // [1 2 3]
 }
 ```
+
+### <span id="IndexOf">IndexOf</span>
+
+<p>返回在stream中找到值的第一个匹配项的索引，如果找不到值，则返回-1。</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Stream[T]) IndexOf(target T, equal func(a, b T) bool) int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.FromSlice([]int{1, 2, 3, 2})
+
+    result1 := s.IndexOf(0, func(a, b int) bool { return a == b })
+    result2 := s.IndexOf(2, func(a, b int) bool { return a == b })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // -1
+    // 1
+}
+```
+
+### <span id="LastIndexOf">LastIndexOf</span>
+
+<p>返回在stream中找到值的最后一个匹配项的索引，如果找不到值，则返回-1。</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Stream[T]) LastIndexOf(target T, equal func(a, b T) bool) int
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.FromSlice([]int{1, 2, 3, 2})
+
+    result1 := s.LastIndexOf(0, func(a, b int) bool { return a == b })
+    result2 := s.LastIndexOf(2, func(a, b int) bool { return a == b })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // -1
+    // 3
+}
+```

docs/api/packages/strutil.md

@@ -68,6 +68,7 @@ import (
 -   [Rotate](#Rotate)
 -   [TemplateReplace](#TemplateReplace)
 -   [RegexMatchAllGroups](#RegexMatchAllGroups)
+-   [ExtractContent](#ExtractContent)
 
 
 <div STYLE="page-break-after: always;"></div>
@@ -1728,4 +1729,34 @@ func main() {
     // [john.doe@example.com john.doe example com]
     // [jane.doe@example.com jane.doe example com]
 }
+```
+
+### <span id="ExtractContent">ExtractContent</span>
+
+<p>提取两个标记之间的内容。</p>
+
+<b>函数签名:</b>
+
+```go
+func ExtractContent(s, start, end string) []string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    html := `<span>content1</span>aa<span>content2</span>bb<span>content1</span>`
+
+    result := strutil.ExtractContent(html, "<span>", "</span>")
+
+    fmt.Println(result)
+
+    // Output:
+    // [content1 content2 content1]
+}
 ```

docs/api/packages/xerror.md

@@ -529,8 +529,8 @@ func main() {
         return errors.New("error in try block")
     }).Catch(func(ctx context.Context, err error) {
         calledCatch = true
-		// Error in try block at /path/xxx.go:{line_number} - Cause: error message
-		// fmt.Println(err.Error())
+        // Error in try block at /path/xxx.go:{line_number} - Cause: error message
+        // fmt.Println(err.Error())
     }).Finally(func(ctx context.Context) {
         calledFinally = true
     }).Do()

docs/en/api/packages/condition.md

@@ -27,7 +27,8 @@ import (
 - [Nor](#Nor)
 - [Xnor](#Xnor)
 - [Nand](#Nand)
-- [TernaryOperator](#TernaryOperator)
+- [Ternary](#Ternary)
+- [TernaryOperator<sup>deprecated</sup>](#TernaryOperator)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -269,9 +270,45 @@ func main() {
 
 
 
+### <span id="Ternary">Ternary</span>
+<p>Checks the value of param `isTrue`, if true return ifValue else return elseValue</p>
+
+<b>Signature:</b>
+
+```go
+func Ternary[T, U any](isTrue T, ifValue U, elseValue U) U
+```
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+    conditionTrue := 2 > 1
+    result1 := condition.Ternary(conditionTrue, 0, 1)
+
+    conditionFalse := 2 > 3
+    result2 := condition.Ternary(conditionFalse, 0, 1)
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // 1
+}
+```
+
 ### <span id="TernaryOperator">TernaryOperator</span>
 <p>Checks the value of param `isTrue`, if true return ifValue else return elseValue</p>
 
+> ⚠️ This function is deprecated. use `Ternary` instead.
+
 <b>Signature:</b>
 
 ```go
@@ -307,4 +344,3 @@ func main() {
 
 
 
-

docs/en/api/packages/datetime.md

@@ -68,6 +68,9 @@ import (
 -   [TrackFuncTime](#TrackFuncTime)
 -   [DaysBetween](#DaysBetween)
 -   [GenerateDatetimesBetween](#GenerateDatetimesBetween)
+-   [Min](#Min)
+-   [Max](#Max)
+-   [MaxMin](#MaxMin)
 
 
 <div STYLE="page-break-after: always;"></div>
@@ -1571,4 +1574,96 @@ func main() {
     // [2024-09-01 00:00:00 2024-09-01 01:00:00 2024-09-01 02:00:00]
     // <nil>
 }
+```
+
+### <span id="Min">Min</span>
+
+<p>Returns the earliest time among the given times.</p>
+
+<b>Signature:</b>
+
+```go
+func Min(t1 time.Time, times ...time.Time) time.Time
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    minTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+    fmt.Println(minTime)
+
+    // Output:
+    // 2024-09-01 00:00:00 +0000 UTC
+}
+```
+
+### <span id="Max">Max</span>
+
+<p>Returns the latest time among the given times.</p>
+
+<b>Signature:</b>
+
+```go
+func Max(t1 time.Time, times ...time.Time) time.Time
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    maxTime := datetime.Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
+
+    fmt.Println(maxTime)
+
+    // Output:
+    // 2024-09-02 00:00:00 +0000 UTC
+}
+```
+
+### <span id="MaxMin">MaxMin</span>
+
+<p>Returns the latest and earliest time among the given times.</p>
+
+<b>Signature:</b>
+
+```go
+func MaxMin(t1 time.Time, times ...time.Time) (maxTime time.Time, minTime time.Time)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    max, min := datetime.MaxMin(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 3, 0, 0, 0, 0, time.UTC))
+
+    fmt.Println(max)
+    fmt.Println(min)
+
+    // Output:
+    // 2024-09-03 00:00:00 +0000 UTC
+    // 2024-09-01 00:00:00 +0000 UTC
+}
 ```

docs/en/api/packages/stream.md

@@ -939,3 +939,69 @@ func main() {
     // [1 2 3]
 }
 ```
+
+### <span id="IndexOf">IndexOf</span>
+
+<p>Returns the index of the first occurrence of the specified element in this stream, or -1 if this stream does not contain the element.</p>
+
+<b>Signature:</b>
+
+```go
+func (s Stream[T]) IndexOf(target T, equal func(a, b T) bool) int
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.FromSlice([]int{1, 2, 3, 2})
+
+    result1 := s.IndexOf(0, func(a, b int) bool { return a == b })
+    result2 := s.IndexOf(2, func(a, b int) bool { return a == b })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // -1
+    // 1
+}
+```
+
+### <span id="LastIndexOf">LastIndexOf</span>
+
+<p>Returns the index of the last occurrence of the specified element in this stream, or -1 if this stream does not contain the element.</p>
+
+<b>Signature:</b>
+
+```go
+func (s Stream[T]) LastIndexOf(target T, equal func(a, b T) bool) int
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/stream"
+)
+
+func main() {
+    s := stream.FromSlice([]int{1, 2, 3, 2})
+
+    result1 := s.LastIndexOf(0, func(a, b int) bool { return a == b })
+    result2 := s.LastIndexOf(2, func(a, b int) bool { return a == b })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // -1
+    // 3
+}
+```

docs/en/api/packages/strutil.md

@@ -68,6 +68,8 @@ import (
 -   [Rotate](#Rotate)
 -   [TemplateReplace](#TemplateReplace)
 -   [RegexMatchAllGroups](#RegexMatchAllGroups)
+-   [ExtractContent](#RegexMatchAllGroups)
+
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -1708,7 +1710,7 @@ func main() {
 func RegexMatchAllGroups(pattern, str string) [][]string
 ```
 
-<b>example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/JZiu0RXpgN-)</span></b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/JZiu0RXpgN-)</span></b>
 
 ```go
 import (
@@ -1729,4 +1731,34 @@ func main() {
     // [john.doe@example.com john.doe example com]
     // [jane.doe@example.com jane.doe example com]
 }
+```
+
+### <span id="ExtractContent">ExtractContent</span>
+
+<p>Extracts the content between the start and end strings in the source string.</p>
+
+<b>Signature:</b>
+
+```go
+func ExtractContent(s, start, end string) []string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    html := `<span>content1</span>aa<span>content2</span>bb<span>content1</span>`
+
+    result := strutil.ExtractContent(html, "<span>", "</span>")
+
+    fmt.Println(result)
+
+    // Output:
+    // [content1 content2 content1]
+}
 ```

docs/en/api/packages/xerror.md

@@ -528,7 +528,7 @@ func main() {
     }).Catch(func(ctx context.Context, err error) {
         calledCatch = true
         // Error in try block at /path/xxx.go:{line_number} - Cause: error message
-		// fmt.Println(err.Error())
+        // fmt.Println(err.Error())
     }).Finally(func(ctx context.Context) {
         calledFinally = true
     }).Do()

random/random.go

@@ -273,6 +273,9 @@ func nearestPowerOfTwo(cap int) int {
 
 // random generate a random string based on given string range.
 func random(s string, length int) string {
+	// 确保随机数生成器的种子是动态的
+	rand.Seed(time.Now().UnixNano())
+
 	// 仿照strings.Builder
 	// 创建一个长度为 length 的字节切片
 	bytes := make([]byte, length)

stream/stream.go

@@ -393,6 +393,26 @@ func (s Stream[T]) Min(less func(a, b T) bool) (T, bool) {
 	return min, true
 }
 
+// IndexOf returns the index of the first occurrence of the specified element in this stream, or -1 if this stream does not contain the element.
+func (s Stream[T]) IndexOf(target T, equal func(a, b T) bool) int {
+	for i, v := range s.source {
+		if equal(v, target) {
+			return i
+		}
+	}
+	return -1
+}
+
+// LastIndexOf returns the index of the last occurrence of the specified element in this stream, or -1 if this stream does not contain the element.
+func (s Stream[T]) LastIndexOf(target T, equal func(a, b T) bool) int {
+	for i := len(s.source) - 1; i >= 0; i-- {
+		if equal(s.source[i], target) {
+			return i
+		}
+	}
+	return -1
+}
+
 // ToSlice return the elements in the stream.
 // Play: https://go.dev/play/p/jI6_iZZuVFE
 func (s Stream[T]) ToSlice() []T {

stream/stream_example_test.go

@@ -384,3 +384,31 @@ func ExampleStream_Count() {
 	// 3
 	// 0
 }
+
+func ExampleStream_IndexOf() {
+	s := FromSlice([]int{1, 2, 3, 2})
+
+	result1 := s.IndexOf(0, func(a, b int) bool { return a == b })
+	result2 := s.IndexOf(2, func(a, b int) bool { return a == b })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// -1
+	// 1
+}
+
+func ExampleStream_LastIndexOf() {
+	s := FromSlice([]int{1, 2, 3, 2})
+
+	result1 := s.LastIndexOf(0, func(a, b int) bool { return a == b })
+	result2 := s.LastIndexOf(2, func(a, b int) bool { return a == b })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// -1
+	// 3
+}

stream/stream_test.go

@@ -381,3 +381,22 @@ func TestStream_Min(t *testing.T) {
 	assert.Equal(1, max)
 	assert.Equal(true, ok)
 }
+
+func TestStream_IndexOf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestStream_IndexOf")
+
+	s := FromSlice([]int{4, 2, 1, 3, 4})
+
+	assert.Equal(-1, s.IndexOf(0, func(a, b int) bool { return a == b }))
+	assert.Equal(0, s.IndexOf(4, func(a, b int) bool { return a == b }))
+	assert.Equal(3, s.IndexOf(3, func(a, b int) bool { return a == b }))
+}
+
+func TestStream_LastIndexOf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestStream_LastIndexOf")
+
+	s := FromSlice([]int{4, 2, 1, 3, 2})
+
+	assert.Equal(-1, s.LastIndexOf(0, func(a, b int) bool { return a == b }))
+	assert.Equal(4, s.LastIndexOf(2, func(a, b int) bool { return a == b }))
+}

strutil/string.go

@@ -735,3 +735,24 @@ func RegexMatchAllGroups(pattern, str string) [][]string {
 	matches := re.FindAllStringSubmatch(str, -1)
 	return matches
 }
+
+// ExtractContent extracts the content between the start and end strings in the source string.
+// Play: todo
+func ExtractContent(s, start, end string) []string {
+	result := []string{}
+
+	for {
+		if _, after, ok := strings.Cut(s, start); ok {
+			if before, _, ok := strings.Cut(after, end); ok {
+				result = append(result, before)
+				s = after
+			} else {
+				break
+			}
+		} else {
+			break
+		}
+	}
+
+	return result
+}

strutil/string_example_test.go

@@ -753,3 +753,15 @@ func ExampleRegexMatchAllGroups() {
 	// [john.doe@example.com john.doe example com]
 	// [jane.doe@example.com jane.doe example com]
 }
+
+func ExampleExtractContent() {
+	html := `<span>content1</span>aa<span>content2</span>bb<span>content1</span>`
+
+	result := ExtractContent(html, "<span>", "</span>")
+
+	fmt.Println(result)
+
+	// Output:
+	// [content1 content2 content1]
+
+}

strutil/string_test.go

@@ -853,3 +853,87 @@ func TestRegexMatchAllGroups(t *testing.T) {
 		assert.Equal(tt.expected, result)
 	}
 }
+
+func TestExtractContent(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestExtractContent")
+
+	tests := []struct {
+		name     string
+		input    string
+		start    string
+		end      string
+		expected []string
+	}{
+		{
+			name:     "Extract content between <tag> and </tag>",
+			input:    "This is <tag>content1</tag> and <tag>content2</tag> and <tag>content3</tag>",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{"content1", "content2", "content3"},
+		},
+		{
+			name:     "No tags in the string",
+			input:    "This string has no tags",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{},
+		},
+		{
+			name:     "Single tag pair",
+			input:    "<tag>onlyContent</tag>",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{"onlyContent"},
+		},
+		{
+			name:     "Tags without end tag",
+			input:    "This <tag>content without end tag",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{},
+		},
+		{
+			name:     "Tags with nested content",
+			input:    "<tag>content <nested>inner</nested> end</tag>",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{"content <nested>inner</nested> end"},
+		},
+		{
+			name:     "Edge case with empty string",
+			input:    "",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{},
+		},
+		{
+			name:     "Edge case with no start tag",
+			input:    "content without start tag",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{},
+		},
+		{
+			name:     "Edge case with no end tag",
+			input:    "<tag>content without end tag",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{},
+		},
+		{
+			name:     "Multiple consecutive tags",
+			input:    "<tag>content1</tag><tag>content2</tag><tag>content3</tag>",
+			start:    "<tag>",
+			end:      "</tag>",
+			expected: []string{"content1", "content2", "content3"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ExtractContent(tt.input, tt.start, tt.end)
+			assert.Equal(tt.expected, result)
+		})
+	}
+}