Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

sort-any

Package Overview
Dependencies
Maintainers
1
Versions
42
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

sort-any

Sorts any JavaScript array in a predictable way (deep equal arrays are always sorted in the same order)

  • 4.0.6
  • latest
  • Source
  • npm
  • Socket score

Version published
Weekly downloads
418K
decreased by-15.67%
Maintainers
1
Weekly downloads
 
Created
Source

sort-any

MIT License Build Status

NPM status

JS library which always sorts arrays in a predictable way. Moreover in contrary to Array.prototype.sort, it does not modify the argument.

Array.prototype.sort:

[[[11]],[[2]],2,{foo:{foo:2}},1,4,2,{foo:{foo:1}},32,[3,4],[1,2],{foo:1},{foo:0},{foo:{}}].sort()
/*
It gives:
[ 1,
  [ 1, 2 ],
  [ [ 11 ] ],
  2,
  2,
  [ [ 2 ] ],
  [ 3, 4 ],
  32,
  4,
  { foo: { foo: 2 } },
  { foo: {} },
  { foo: 1 },
  { foo: 0 },
  { foo: { foo: 1 } } ]
*/

The same array in a different order:

[[[11]],[[2]],2,1,4,2,{foo:{foo:1}},32,[3,4],[1,2],{foo:0},{foo:1},{foo:{}},{foo:{foo:2}}].sort()
/*
It gives:
[ 1,
  [ 1, 2 ],
  [ [ 11 ] ],
  2,
  2,
  [ [ 2 ] ],
  [ 3, 4 ],
  32,
  4,
  { foo: { foo: 1 } },
  { foo: 0 },
  { foo: 1 },
  { foo: {} },
  { foo: { foo: 2 } } ]
*/

So the results of Array.prototype.sort are strange (eg. numbers are sorted in the alphabetical order) and moreover if we change the array order (eg. for object items), the result has order changed as well.

So I have implemented this library to work like that:

const sort = require('sort-any');
sort([[[11]],[[2]],2,{foo:{foo:2}},1,4,2,{foo:{foo:1}},32,[3,4],[1,2],{foo:1},{foo:0},{foo:{}}])
/*
It returns:
[ 1,
  2,
  2,
  4,
  32,
  [ [ 2 ] ],
  [ [ 11 ] ],
  [ 1, 2 ],
  [ 3, 4 ],
  { foo: 0 },
  { foo: 1 },
  { foo: {} },
  { foo: { foo: 1 } },
  { foo: { foo: 2 } } ]
*/

And when we change the order, the result remains the same.

const sort = require('sort-any');
sort([[[11]],[[2]],2,1,4,2,{foo:{foo:1}},32,[3,4],[1,2],{foo:0},{foo:1},{foo:{}},{foo:{foo:2}}])
/*
It returns:
[ 1,
  2,
  2,
  4,
  32,
  [ [ 2 ] ],
  [ [ 11 ] ],
  [ 1, 2 ],
  [ 3, 4 ],
  { foo: 0 },
  { foo: 1 },
  { foo: {} },
  { foo: { foo: 1 } },
  { foo: { foo: 2 } } ]
*/

Rules for sorting:

  • the most important is the type (from the smallest to the largest):
    • undefined
    • null
    • boolean
    • NaN
    • number (all the numbers except of NaN)
    • string
    • symbol
    • date
    • set
    • array
    • map
    • object (all the objects except of arrays, dates and null)
  • false is less than true
  • numbers are sorted with the standard numeric order
  • -Infinity is less than any other number
  • Infinity is more than any other number
  • strings are sorted in the alphabetical order
  • symbols are sorted in the alphabetical order according to their description
  • dates are sorted in the chronological order
  • rules of arrays sorting:
    • the most important is the length (always a shorter array is less than a longer array)
    • if the length is the same, we sort (recursively using this algorithm) both arrays and we compare the smallest item from both arrays
    • if the smallest item is the same, we compare the second smallest item, and so on
    • if the arrays include the same values, we compare the elements at 0 index
    • if the elements at 0 index are the same, we compare the elements at 1 index, 2 index, and so on
    • if all the elements are equal, the arrays are equal
  • rules of objects sorting:
    • the most important is the number of the keys (always an object with less keys is less than an object with more keys)
    • if the number of keys is the same, we sort (recursively using this algorithm) the keys (which can be either strings or symbols) and we compare the smallest keys from both objects
    • if the smallest key is the same, we compare the second smallest key, and so on
    • if all the keys are the same, we compare the values at the smallest key
    • if the values at the smallest key are the same, we compare sequentially next values taking each time a bigger key unless the values differ
    • if all the values are the same, we compare the keys at 0 index (Object.keys(object)[0])
    • if the keys at 0 index are the same, we compare the keys at 1 index, 2 index, and so on
    • if all the keys are the same, the objects are equal
  • rules of sets sorting:
    • the set is converted to an array and the array sorting rules apply
  • rules of maps sorting:
    • the map is converted to an object (with the correspondent keys and values) and the object sorting rules apply

Keywords

FAQs

Package last updated on 07 Apr 2024

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc