Spaces, symbols and non-printable characters are only considered for splitting the string into its parts but not for sorting. For instance foo-bar-42 is broken in three substrings foo, bar and 42 and after that the dashes are ignored.

Hi, you don't show your desired output, but as the doc for Sort::Key::Natural says:

Note, that the sorting is case sensitive. To do a case insensitive sort you have to convert the keys explicitly

Use natkeysort() instead:

use Sort::Key::Natural qw( natkeysort );
my @list = qw(P007b_Yum P007_Yum P007B_YUM P007_YUM P007b_yum P007_yum
+);
say for natkeysort { lc $_ } @list;
[download]

$ perl 1202470.pl
P007b_Yum
P007B_YUM
P007b_yum
P007_Yum
P007_YUM
P007_yum
[download]

Hope this helps!

Thanks! I was using that exact thing but my problem is that I actually want P007 first, then P007b, which is what I would expect from natural sorting (this is how Windows sorts filenames). Once I use natkeysort and force it to lowercase, it sorts backwards from what I expect. I don't understand why they would be different. This also gets the same switch of behavior:

   use feature qw( say );
   use Sort::Key::Natural qw( natkeysort );
   say for natkeysort {$_} qw(     P007B_YUM P007_YUM  );
   say qw(---);
   say for natkeysort {$_} qw(     P007b_Yum P007_Yum  );
   say qw(---);
   say for natkeysort {$_} qw(     P007b_yum P007_yum  );
[download]

That gets the same switch of order.

P007B_YUM
P007_YUM
---
P007_Yum
P007b_Yum
---
P007b_yum
P007_yum
[download]

Hm yeap, I see what you mean.

P007b_Yum
P007B_YUM
P007b_yum
P007_Yum
P007_YUM
P007_yum
[download]

I would have expected:

P007_yum
P007_Yum
P007_YUM
P007b_yum
P007b_Yum
P007B_YUM
[download]

Well, hopefully salva will come along soon and explain the mystery.


The way forward always starts with a minimal test.

G'day cr8josh,

It's unclear what you want because you haven't shown that.

Piecing together what's in your OP and "Re^2: Sort::Key::Natural sorting discrepancy", it seems you want a case-insensitive sort with underscores sorting before letters. In ASCII, uppercase letters (65-90) come before an underscore (95) which comes before lowercase letters (97-122). If that is indeed what you want, you can do it like this:

$ perl -E '
    my @x = (
        [qw{P007b_Yum P007_Yum}],
        [qw{P007B_YUM P007_YUM}],
        [qw{P007b_yum P007_yum}]
    ); 
    for (@x) { 
        say $_->[0] for sort { $a->[1] cmp $b->[1] } 
        map { [ $_, lc $_ ] } @$_; 
        say "-" x 3; 
    }
'
P007_Yum
P007b_Yum
---
P007_YUM
P007B_YUM
---
P007_yum
P007b_yum
---
[download]

If I understand well what you want, this might be your solution:

use strict;
use warnings;
use feature 'say';

my @list = qw(P007b_Yum P007_Yum P007B_YUM P007_YUM P007b_yum P007_yum
+);

my @sorted = sort { lc $a cmp lc $b } sort { $b cmp $a } @list;
say for @sorted;
[download]

$ perl sort_lc.pl
P007_yum
P007_Yum
P007_YUM
P007b_yum
P007b_Yum
P007B_YUM
[download]

If this is still not the order you want, please let us know what you expect.

If you want alphanumeric groups to remain unbroken, you will have to change the sorting-key generation algorithm.

This probably does what you want (untested):

use Sort::Key qw(keysort);

sub mknkey {
    my $n = shift;
    $n =~ s/^0+//;
    my $len = length $n;
    my $nines = int ($len / 9);
    my $rest = $len - 9 * $nines;
    ('9' x $nines) . $rest . $n;
}

sub mknatkey {
    my $nat = @_ ? shift : $_;
    $nat =~ s/(\d+)/mknkey($1)/ge;
    $nat;
}

my @sorted = keysort { mknatkey($_) } @data;
[download]

Hi salva,

Thanks for clarifying. Now that I know from your follow-up what the truth is, I can discern it in the docs. However, I humbly submit that the doc could be clearer.

I misread the existing doc and concluded (encouraged in the wrong conclusion by the OP's code) that the string was split only on the underscores etc. (i.e.: 'boundaries' == 'underscores, etc.'). That's mostly my fault, for only seeing what I thought I was looking for, but here's a suggestion: place next to each other the descriptions of the two ways in which the string could be split, and highlight that alpha words and numbers are different, not a group:

"Under natural sorting, strings are split at word and number boundaries, and the resulting ... "

Possibly better as:

"Under natural sorting, strings are split at boundaries between words and numbers and at non-alphanumeric characters (see below), and the resulting ..."

Let me know if a patch / PR would be helpful, if you think this would be an improvement.

Thanks for all you do for Perl!



The way forward always starts with a minimal test.

Following your advice, I have changed the description on the development version of the module.

Many many thanks to all who chimed in. Apologies my goal was not clear! My high level goal is to reproduce Windows Explorer's file sorting. The only solution that worked for me consistently was calling Win32::API which I preferred not to do...

Salva, you nailed it, I needed alphanumeric groups to sort unbroken, and your solution works perfectly. Thank you!