Array sort (#603)

Author: okazkayasi

devs/run-tests/24arraymap.ts

@@ -152,6 +152,49 @@ function testArrayAt() {
     assert(str.at(-6) === undefined, "arrayAtUndefined")
 }
 
+function localeCompareHelper(a: string, b: string) {
+    if (a < b) return -1
+    else if (a > b) return 1
+    else return 0
+}
+
+function testArraySort() {
+    msg("testArraySort")
+    const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
+    arr.sort()
+    assert(arr.join() === "1,1,2,3,3,4,5,5,5,6,9", "sort1")
+
+    const numbers = [9, 3, 7, 1, 5]
+    numbers.sort((a, b) => a - b)
+    assert(numbers.join() === "1,3,5,7,9", "sort2")
+
+    const words = ["apple", "banana", "cherry", "date"]
+    words.sort()
+    assert(words.join() === "apple,banana,cherry,date", "sort3")
+
+    const people = [
+        { name: "Alice", age: 30 },
+        { name: "Bob", age: 25 },
+        { name: "Charlie", age: 35 },
+    ]
+    people.sort((a, b) => a.age - b.age)
+    assert(people.map(p => p.name).join() === "Bob,Alice,Charlie", "sort4")
+
+    const mixed = [5, "apple", 2, "banana", 9, "cherry"]
+    mixed.sort((a, b) => {
+        if (typeof a === "string" && typeof b === "string") {
+            return localeCompareHelper(a, b)
+        } else if (typeof a === "string") {
+            return 1 // Strings come after numbers
+        } else if (typeof b === "string") {
+            return -1 // Numbers come before strings
+        } else {
+            return a - b // Compare numbers
+        }
+    })
+    assert(mixed.join() === "2,5,9,apple,banana,cherry", "sort5")
+}
+
 testArraySome()
 testArrayEvery()
 testArrayFill()
@@ -165,3 +208,4 @@ testArrayFindLastIndex()
 testGenerics()
 testArrayIncludes()
 testArrayAt()
+testArraySort()

packages/core/src/array.ts

@@ -169,6 +169,30 @@ Array.prototype.reduce = function (callbackfn: any, initialValue: any) {
     return initialValue
 }
 
+Array.prototype.sort = function <T>(compareFn?: (a: T, b: T) => number) {
+    if (!compareFn) {
+        compareFn = (a: any, b: any) => {
+            a = a + ""
+            b = b + ""
+            if (a < b) return -1
+            else if (a > b) return 1
+            else return 0
+        }
+    }
+
+    for (let i = 1; i < this.length; i++) {
+        const current = this[i]
+        let j = i - 1
+        while (j >= 0 && compareFn(this[j], current) > 0) {
+            this[j + 1] = this[j]
+            j--
+        }
+        this[j + 1] = current
+    }
+
+    return this
+}
+
 Buffer.prototype.set = function (other: Buffer, trgOff?: number) {
     if (!trgOff) trgOff = 0
     this.blitAt(trgOff, other, 0, other.length)

packages/core/src/corelib.d.ts

@@ -215,11 +215,11 @@ interface Array<T> {
     [n: number]: T
     [Symbol.iterator](): IterableIterator<T>
 
-    /** 
+    /**
      * Returns the item located at the specified index.
      * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
      */
-    at(index: number): T | undefined;
+    at(index: number): T | undefined
 
     /**
      * Insert `count` `undefined` elements at `index`.
@@ -286,7 +286,7 @@ interface Array<T> {
      * @param end index to stop filling the array at. If end is negative, it is treated as
      * length+end.
      */
-    fill(value: number, start?: number, end?: number): this;
+    fill(value: number, start?: number, end?: number): this
 
     /**
      * Determines whether the specified callback function returns true for any element of an array.
@@ -346,7 +346,9 @@ interface Array<T> {
      * order, until it finds one where predicate returns true. If such an element is found, findLast
      * immediately returns that element value. Otherwise, findLast returns undefined.
      */
-    findLast(predicate: (value: T, index: number, array: T[]) => unknown): T | undefined;
+    findLast(
+        predicate: (value: T, index: number, array: T[]) => unknown
+    ): T | undefined
 
     /**
      * Returns the index of the last element in the array where predicate is true, and -1
@@ -355,7 +357,9 @@ interface Array<T> {
      * order, until it finds one where predicate returns true. If such an element is found,
      * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
      */
-    findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown): number
+    findLastIndex(
+        predicate: (value: T, index: number, array: T[]) => unknown
+    ): number
 
     /**
      * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -404,15 +408,27 @@ interface Array<T> {
      * @param separator A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
      */
     join(separator?: string): string
+
+    /**
+     * Sorts an array in place using insertion sort -> O(n^2) complexity.
+     * This method mutates the array and returns a reference to the same array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
+     */
+    sort(compareFn?: (a: T, b: T) => number): this
 }
 
 interface ArrayConstructor {
     new (arrayLength?: number): any[]
     new <T>(arrayLength: number): T[]
-    new <T>(...items: T[]): T[];
+    new <T>(...items: T[]): T[]
 
     (arrayLength?: number): any[]
-    <T>(...items: T[]): T[];
+    <T>(...items: T[]): T[]
 
     <T>(arrayLength: number): T[]
     isArray(arg: any): arg is any[]