doc: add drop and sort related function doc

README.md

@@ -832,9 +832,15 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>DeleteAt</big>** : delete the element of slice from specific start index to end index - 1.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DeleteAt)]
     [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
--   **<big>Drop</big>** : creates a slice with `n` elements dropped from the beginning when n > 0, or `n` elements dropped from the ending when n < 0.
+-   **<big>Drop</big>** : drop n elements from the start of a slice.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Drop)]
     [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
+-   **<big>DropRight</big>** : drop n elements from the end of a slice.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DropRight)]
+-   **<big>DropWhile</big>** : drop n elements from the start of a slice while predicate function returns true.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DropWhile)]
+-   **<big>DropRightWhile</big>** : drop n elements from the end of a slice while predicate function returns true.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DropRightWhile)]
 -   **<big>Equal</big>** : checks if two slices are equal: the same length and all elements' order and value are equal.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Equal)]
     [[play](https://go.dev/play/p/WcRQJ37ifPa)]
@@ -910,6 +916,14 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Shuffle</big>** : shuffle the slice.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Shuffle)]
     [[play](https://go.dev/play/p/YHvhnWGU3Ge)]
+-   **<big>IsAscending</big>** : Checks if a slice is ascending order.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsAscending)]
+-   **<big>IsDescending</big>** : Checks if a slice is descending order.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsDescending)]
+-   **<big>IsSorted</big>** : Checks if a slice is sorted (ascending or descending).
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsSorted)]
+-   **<big>IsSortedByKey</big>** : Checks if a slice is sorted by iteratee function.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IsSortedByKey)]
 -   **<big>Sort</big>** : sorts a slice of any ordered type(number or string).
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Sort)]
     [[play](https://go.dev/play/p/V9AVjzf_4Fk)]

README_zh-CN.md

@@ -839,9 +839,15 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>DeleteAt</big>** : 删除切片中指定开始索引到结束索引的元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DeleteAt)]
     [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
--   **<big>Drop</big>** : 创建一个切片，当n > 0时从开头删除n个元素，或者当n < 0时从结尾删除n个元素。
+-   **<big>Drop</big>** : 从切片头部删除n个元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Drop)]
     [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
+-   **<big>DropRight</big>** : 从切片尾部删除n个元素。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DropRight)]
+-   **<big>DropWhile</big>** : 从切片的头部删除n个元素，这个n个元素满足predicate函数返回true。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DropWhile)]
+-   **<big>DropRightWhile</big>** : 从切片的尾部删除n个元素，这个n个元素满足predicate函数返回true。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DropRightWhile)]
 -   **<big>Equal</big>** : 检查两个切片是否相等，相等条件：切片长度相同，元素顺序和值都相同。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Equal)]
     [[play](https://go.dev/play/p/WcRQJ37ifPa)]
@@ -917,6 +923,14 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Shuffle</big>** : 随机打乱切片中的元素顺序。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Shuffle)]
     [[play](https://go.dev/play/p/YHvhnWGU3Ge)]
+-   **<big>IsAscending</big>** : 检查切片元素是否按升序排列。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsAscending)]
+-   **<big>IsDescending</big>** : 检查切片元素是否按降序排列。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsDescending)]
+-   **<big>IsSorted</big>** : 检查切片元素是否是有序的（升序或降序）。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsSorted)]
+-   **<big>IsSortedByKey</big>** : 通过iteratee函数，检查切片元素是否是有序的。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IsSortedByKey)]
 -   **<big>Sort</big>** : 对任何有序类型（数字或字符串）的切片进行排序，使用快速排序算法。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Sort)]
     [[play](https://go.dev/play/p/V9AVjzf_4Fk)]

docs/slice.md

@@ -35,6 +35,9 @@ import (
 -   [DifferenceWith](#DifferenceWith)
 -   [DeleteAt](#DeleteAt)
 -   [Drop](#Drop)
+-   [DropRight](#DropRight)
+-   [DropWhile](#DropWhile)
+-   [DropRightWhile](#DropRightWhile)
 -   [Equal](#Equal)
 -   [EqualWith](#EqualWith)
 -   [Every](#Every)
@@ -60,6 +63,10 @@ import (
 -   [ReplaceAll](#ReplaceAll)
 -   [Repeat](#Repeat)
 -   [Shuffle](#Shuffle)
+-   [IsAscending](#IsAscending)
+-   [IsDescending](#IsDescending)
+-   [IsSorted](#IsSorted)
+-   [IsSortedByKey](#IsSortedByKey)
 -   [Sort](#Sort)
 -   [SortBy](#SortBy)
 -   [SortByField<sup>deprecated</sup>](#SortByField)
@@ -487,7 +494,7 @@ func main() {
 
 ### <span id="Drop">Drop</span>
 
-<p>Creates a slice with `n` elements dropped from the beginning when n > 0, or `n` elements dropped from the ending when n < 0.</p>
+<p>Drop n elements from the start of a slice.</p>
 
 <b>Signature:</b>
 
@@ -505,20 +512,139 @@ import (
 
 func main() {
     result1 := slice.Drop([]string{"a", "b", "c"}, 0)
-    result2 := slice.Drop([]string{"a", "b", "c"}, 1)
-    result3 := slice.Drop([]string{"a", "b", "c"}, -1)
-    result4 := slice.Drop([]string{"a", "b", "c"}, 4)
+	result2 := slice.Drop([]string{"a", "b", "c"}, 1)
+	result3 := slice.Drop([]string{"a", "b", "c"}, -1)
+	result4 := slice.Drop([]string{"a", "b", "c"}, 4)
 
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
 
-    // Output:
-    // [a b c]
-    // [b c]
-    // [a b]
-    // []
+	// Output:
+	// [a b c]
+	// [b c]
+	// [a b c]
+	// []
+}
+```
+
+### <span id="DropRight">DropRight</span>
+
+<p>Drop n elements from the end of a slice.</p>
+
+<b>Signature:</b>
+
+```go
+func DropRight[T any](slice []T, n int) []T
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.DropRight([]string{"a", "b", "c"}, 0)
+	result2 := slice.DropRight([]string{"a", "b", "c"}, 1)
+	result3 := slice.DropRight([]string{"a", "b", "c"}, -1)
+	result4 := slice.DropRight([]string{"a", "b", "c"}, 4)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [a b c]
+	// [a b]
+	// [a b c]
+	// []
+}
+```
+
+### <span id="DropWhile">DropWhile</span>
+
+<p>Drop n elements from the start of a slice while predicate function returns true.</p>
+
+<b>Signature:</b>
+
+```go
+func DropWhile[T any](slice []T, predicate func(item T) bool) []T
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.DropWhile(numbers, func(n int) bool {
+		return n != 2
+	})
+	result2 := slice.DropWhile(numbers, func(n int) bool {
+		return true
+	})
+	result3 := slice.DropWhile(numbers, func(n int) bool {
+		return n == 0
+	})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// [2 3 4 5]
+	// []
+	// [1 2 3 4 5]
+}
+```
+
+### <span id="DropRightWhile">DropRightWhile</span>
+
+<p>Drop n elements from the end of a slice while predicate function returns true.</p>
+
+<b>Signature:</b>
+
+```go
+func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    numbers := []int{1, 2, 3, 4, 5}
+
+	result1 := slice.DropRightWhile(numbers, func(n int) bool {
+		return n != 2
+	})
+	result2 := slice.DropRightWhile(numbers, func(n int) bool {
+		return true
+	})
+	result3 := slice.DropRightWhile(numbers, func(n int) bool {
+		return n == 0
+	})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// [1 2]
+	// []
+	// [1 2 3 4 5]
 }
 ```
 
@@ -1348,6 +1474,148 @@ func main() {
 }
 ```
 
+### <span id="IsAscending">IsAscending</span>
+
+<p>Checks if a slice is ascending order.</p>
+
+<b>Signature:</b>
+
+```go
+func IsAscending[T constraints.Ordered](slice []T) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsAscending([]int{1, 2, 3, 4, 5})
+	result2 := slice.IsAscending([]int{5, 4, 3, 2, 1})
+	result3 := slice.IsAscending([]int{2, 1, 3, 4, 5})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// false
+	// false
+}
+```
+
+### <span id="IsDescending">IsDescending</span>
+
+<p>Checks if a slice is descending order.</p>
+
+<b>Signature:</b>
+
+```go
+func IsDescending[T constraints.Ordered](slice []T) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsDescending([]int{5, 4, 3, 2, 1})
+	result2 := slice.IsDescending([]int{1, 2, 3, 4, 5})
+	result3 := slice.IsDescending([]int{2, 1, 3, 4, 5})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// false
+	// false
+}
+```
+
+### <span id="IsSorted">IsSorted</span>
+
+<p>Checks if a slice is sorted (ascending or descending).</p>
+
+<b>Signature:</b>
+
+```go
+func IsSorted[T constraints.Ordered](slice []T) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsSorted([]int{5, 4, 3, 2, 1})
+	result2 := slice.IsSorted([]int{1, 2, 3, 4, 5})
+	result3 := slice.IsSorted([]int{2, 1, 3, 4, 5})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// true
+	// false
+}
+```
+
+### <span id="IsSortedByKey">IsSortedByKey</span>
+
+<p>Checks if a slice is sorted by iteratee function.</p>
+
+<b>Signature:</b>
+
+```go
+func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
+		return len(s)
+	})
+	result2 := slice.IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
+		return len(s)
+	})
+	result3 := slice.IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
+		return len(s)
+	})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// true
+	// false
+}
+```
+
 ### <span id="Sort">Sort</span>
 
 <p>Sorts a slice of any ordered type(number or string), use quick sort algrithm. Default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`. Ordered type: number(all ints uints floats) or string.

docs/slice_zh-CN.md

@@ -35,6 +35,9 @@ import (
 -   [DifferenceWith](#DifferenceWith)
 -   [DeleteAt](#DeleteAt)
 -   [Drop](#Drop)
+-   [DropRight](#DropRight)
+-   [DropWhile](#DropWhile)
+-   [DropRightWhile](#DropRightWhile)
 -   [Every](#Every)
 -   [Equal](#Equal)
 -   [EqualWith](#EqualWith)
@@ -60,6 +63,10 @@ import (
 -   [ReplaceAll](#ReplaceAll)
 -   [Repeat](#Repeat)
 -   [Shuffle](#Shuffle)
+-   [IsAscending](#IsAscending)
+-   [IsDescending](#IsDescending)
+-   [IsSorted](#IsSorted)
+-   [IsSortedByKey](#IsSortedByKey)
 -   [Sort](#Sort)
 -   [SortBy](#SortBy)
 -   [SortByField<sup>deprecated</sup>](#SortByField)
@@ -486,9 +493,10 @@ func main() {
 }
 ```
 
+
 ### <span id="Drop">Drop</span>
 
-<p>创建一个切片，当n > 0时从开头删除n个元素，或者当n < 0时从结尾删除n个元素</p>
+<p>从切片的头部删除n个元素。</p>
 
 <b>函数签名:</b>
 
@@ -506,20 +514,139 @@ import (
 
 func main() {
     result1 := slice.Drop([]string{"a", "b", "c"}, 0)
-    result2 := slice.Drop([]string{"a", "b", "c"}, 1)
-    result3 := slice.Drop([]string{"a", "b", "c"}, -1)
-    result4 := slice.Drop([]string{"a", "b", "c"}, 4)
+	result2 := slice.Drop([]string{"a", "b", "c"}, 1)
+	result3 := slice.Drop([]string{"a", "b", "c"}, -1)
+	result4 := slice.Drop([]string{"a", "b", "c"}, 4)
 
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
 
-    // Output:
-    // [a b c]
-    // [b c]
-    // [a b]
-    // []
+	// Output:
+	// [a b c]
+	// [b c]
+	// [a b c]
+	// []
+}
+```
+
+### <span id="DropRight">DropRight</span>
+
+<p>从切片的尾部删除n个元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func DropRight[T any](slice []T, n int) []T
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.DropRight([]string{"a", "b", "c"}, 0)
+	result2 := slice.DropRight([]string{"a", "b", "c"}, 1)
+	result3 := slice.DropRight([]string{"a", "b", "c"}, -1)
+	result4 := slice.DropRight([]string{"a", "b", "c"}, 4)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// [a b c]
+	// [a b]
+	// [a b c]
+	// []
+}
+```
+
+### <span id="DropWhile">DropWhile</span>
+
+<p>从切片的头部删除n个元素，这个n个元素满足predicate函数返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func DropWhile[T any](slice []T, predicate func(item T) bool) []T
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.DropWhile(numbers, func(n int) bool {
+		return n != 2
+	})
+	result2 := slice.DropWhile(numbers, func(n int) bool {
+		return true
+	})
+	result3 := slice.DropWhile(numbers, func(n int) bool {
+		return n == 0
+	})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// [2 3 4 5]
+	// []
+	// [1 2 3 4 5]
+}
+```
+
+### <span id="DropRightWhile">DropRightWhile</span>
+
+<p>从切片的尾部删除n个元素，这个n个元素满足predicate函数返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    numbers := []int{1, 2, 3, 4, 5}
+
+	result1 := slice.DropRightWhile(numbers, func(n int) bool {
+		return n != 2
+	})
+	result2 := slice.DropRightWhile(numbers, func(n int) bool {
+		return true
+	})
+	result3 := slice.DropRightWhile(numbers, func(n int) bool {
+		return n == 0
+	})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// [1 2]
+	// []
+	// [1 2 3 4 5]
 }
 ```
 
@@ -1349,6 +1476,148 @@ func main() {
 }
 ```
 
+### <span id="IsAscending">IsAscending</span>
+
+<p>检查切片元素是否按升序排列。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsAscending[T constraints.Ordered](slice []T) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsAscending([]int{1, 2, 3, 4, 5})
+	result2 := slice.IsAscending([]int{5, 4, 3, 2, 1})
+	result3 := slice.IsAscending([]int{2, 1, 3, 4, 5})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// false
+	// false
+}
+```
+
+### <span id="IsDescending">IsDescending</span>
+
+<p>检查切片元素是否按降序排列。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsDescending[T constraints.Ordered](slice []T) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsDescending([]int{5, 4, 3, 2, 1})
+	result2 := slice.IsDescending([]int{1, 2, 3, 4, 5})
+	result3 := slice.IsDescending([]int{2, 1, 3, 4, 5})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// false
+	// false
+}
+```
+
+### <span id="IsSorted">IsSorted</span>
+
+<p>检查切片元素是否是有序的（升序或降序）。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsSorted[T constraints.Ordered](slice []T) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsSorted([]int{5, 4, 3, 2, 1})
+	result2 := slice.IsSorted([]int{1, 2, 3, 4, 5})
+	result3 := slice.IsSorted([]int{2, 1, 3, 4, 5})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// true
+	// false
+}
+```
+
+### <span id="IsSortedByKey">IsSortedByKey</span>
+
+<p>通过iteratee函数，检查切片元素是否是有序的。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result1 := slice.IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
+		return len(s)
+	})
+	result2 := slice.IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
+		return len(s)
+	})
+	result3 := slice.IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
+		return len(s)
+	})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// true
+	// false
+}
+```
+
 ### <span id="Sort">Sort</span>
 
 <p>对任何有序类型（数字或字符串）的切片进行排序，使用快速排序算法。 默认排序顺序为升序 (asc)，如果需要降序，请将参数 `sortOrder` 设置为 `desc`。 Ordered类型：数字（所有整数浮点数）或字符串。</p>

slice/slice.go

@@ -860,6 +860,34 @@ func IsSorted[T constraints.Ordered](slice []T) bool {
 	return IsAscending(slice) || IsDescending(slice)
 }
 
+// IsSortedByKey checks if a slice is sorted by iteratee function.
+// Play: todo
+func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool {
+	size := len(slice)
+
+	isAscending := func(data []T) bool {
+		for i := 0; i < size-1; i++ {
+			if iteratee(data[i]) > iteratee(data[i+1]) {
+				return false
+			}
+		}
+
+		return true
+	}
+
+	isDescending := func(data []T) bool {
+		for i := 0; i < size-1; i++ {
+			if iteratee(data[i]) < iteratee(data[i+1]) {
+				return false
+			}
+		}
+
+		return true
+	}
+
+	return isAscending(slice) || isDescending(slice)
+}
+
 // Sort sorts a slice of any ordered type(number or string), use quick sort algrithm.
 // default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`.
 // Play: https://go.dev/play/p/V9AVjzf_4Fk

slice/slice_example_test.go

@@ -733,6 +733,27 @@ func ExampleIsSorted() {
 	// false
 }
 
+func ExampleIsSortedByKey() {
+	result1 := IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
+		return len(s)
+	})
+	result2 := IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
+		return len(s)
+	})
+	result3 := IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
+		return len(s)
+	})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// true
+	// false
+}
+
 func ExampleSort() {
 	nums := []int{1, 4, 3, 2, 5}
 

slice/slice_test.go

@@ -627,6 +627,22 @@ func TestIsSorted(t *testing.T) {
 	assert.Equal(false, IsSorted([]int{2, 1, 3, 4, 5}))
 }
 
+func TestIsSortedByKey(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsSortedByKey")
+
+	assert.Equal(true, IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
+		return len(s)
+	}))
+
+	assert.Equal(true, IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
+		return len(s)
+	}))
+
+	assert.Equal(false, IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
+		return len(s)
+	}))
+}
+
 func TestSort(t *testing.T) {
 	assert := internal.NewAssert(t, "TestSort")