@tuyo/sort

Powerful, flexible & stable-order Array sorting method.

Install

npm i @tuyo/sort

Usage

Basic usage

import sort from '@tuyo/sort'

const arr = [{name: 'ignore'}, 1, 'z', 11, 'b', '5', '1']
sort(arr)
// arr ===> [1, 11, '1', '5', 'b', 'z', {name: 'ignore'}]

Configuration usage

import sort from '@tuyo/sort'

const arr = [{name: 'ignore'}, 1, 'z', 11, 'b', '5', '1']

// comparison function
sort(arr, (a, b) => b - a)
// arr ===> [{name: 'ignore'}, 'z', 'b', '5', '1', 11, 1]

// Configuration Type Order
sort(arr, (a, b) => b - a, {
    number: 0,
    object: 1,
    string: 2
})
// arr ===> [11, 1, {name: 'ignore'}, 'z', 'b', '5', '1']

// Compare an attribute value
const arr = [
    {name: 'Chris', age: 33},
    {name: 'Allen', age: '20'},
    {name: 'StephenA', age: '26'},
    {name: 'Zoey', age: 29},
    {name: 'StephenB', age: '16'}
]

// If the value is a number or a number-like string, can be directly compared
sort(arr, (a, b) => a.age - b.age)
// arr ===> [
//     {name: 'StephenB', age: '16'},
//     {name: 'Allen', age: '20'},
//     {name: 'StephenA', age: '26'},
//     {name: 'Zoey', age: 29},
//     {name: 'Chris', age: 33},
// ]

// If the value is not a number, or you want to distinguish between numbers and number-like string, need to use the comparison function in the callback to compare.
sort(arr, (a, b, compare) => compare(a.name, b.name, (a, b) => b - a))
// arr ===> [
//     {name: 'Zoey', age: 29},
//     {name: 'StephenB', age: '16'},
//     {name: 'StephenA', age: '26'},
//     {name: 'Chris', age: 33},
//     {name: 'Allen', age: '20'},
// ]

Props

/**
 * @param {array<any>} target.
 * @param {function} comparison default: (a:any, b:any, compare:Function, aType:string, bType:string) => a - b
 * @param {object} orderConfig
 * default: {
 * 'null': 0,
 * 'boolean':1,
 * 'NaN': 2,
 * 'symbol': 3,
 * 'number': 4,
 * 'string': 5,
 * 'date': 6,
 * 'array': 7,
 * 'object': 8,
 * 'set': 9,
 * 'map': 10,
 * }
 * @returns {array} Returns the sorted array and mutates the original array at the same time.
 * 
 */
function sort(target:Array<any>, callback?:((a: any, b: any, compare: Function, atype: string, btype: string) => number), orderConfig?:Object) {
    // ...
}

Rules

• Default Type Order
  • null
  • boolean
  • NaN
  • symbol
  • number
  • string
  • date
  • array
  • object
  • set
  • map
• Boolean: false < true
• Number: -Infinity < -1 < 0 < 1 < Infinity
• String: 'a' < 'b' < 'c' < ... < 'z'
• String: '2022-01-01' < '2022-01-02' < '2022-01-03'
• Date: new Date('2022-02-01') < new Date('2022-02-02')
• Array: will be recursive sort. array.length < array.length. If the length is equal, compare the values of each item in turn.
• Object | set | map: length < length. If the length is equal, compare the keys and values of each item in turn
• undefined always at the end.
• The default type is affected by ascending and descending order, the incoming type order configuration is fixed.