Browser: sort issue with files named [number].[number].ext

changed milestone to %3.6.x

added bug label

Where is 2 after 1?!!? Its wrong sort order in folder groups: 1,10,11,...,19,2,20,...!

@Aza I'd like to give it a try. Could you please assign it to me?

Done. You should look at !1481 (merged), especially here: !1481 (diffs)

OK. Thanks for the information.

Hi @Aza , I think the algorithm we used(by padding zero to the start of the string) to compare two strings can not handle this case well. I do some research about how to sort file naturally and found https://blog.miigon.net/posts/how-to-sort-file-names-naturally/。I believe this is a better solution to sort filename. So can we introduce this algorithm to the project?

I just tested this algorithm. It doesn't seem to work in our case.

let a = ['a2', 'a1b10z', 'b1a2', 'a1b10', 'a33', '7', 'a3', 'a22', 'a1b2', 'abbbb', 'a1b1', 'aaaaa', 'a10', 'a1', '10'];
console.log(this.natSort(a).join('\n'))

produces

7
10
a1
a1b1
a1b2
a1b10
a1b10z
a2
a3
a10
a22
a33
aaaaa
abbbb
b1a2

as expected but

let b = ['2.png', '2.5.png','1.5.png', '1.png'];
console.log(this.natSort(b).join('\n'))

produces

1.5.png
1.png
2.5.png
2.png

So it has the same limitations as our algorithm.

@Aza Yes, You are right, this algorithm need some change. Basic idea is to process the array after splitted to find if there is float number need to be combined. For example:

function natSort(arr){
    return arr.map(v=>{ // split string into number/ascii substrings
        let processedName = []
        let str = v
        for(let i=0;i<str.length;i++) {
            let isNum = Number.isInteger(Number(str[i]));
            let j;
            for(j=i+1;j<str.length;j++) {
                if(Number.isInteger(Number(str[j]))!=isNum) {
                    break;
                }
            }
            processedName.push(isNum ? Number(str.slice(i,j)) : str.slice(i,j));
            i=j-1;
        }

        // combine float number if need
        let result = []
        for (let i = 0; i < processedName.length; i ++) { 
          if(processedName[i] == "." 
             && result.length > 0 && Number.isInteger(result[result.length - 1])
             && (i + 1) < processedName.length && Number.isInteger(processedName[i + 1])
            ){ 
            result[result.length - 1] = result[result.length - 1] + "." + processedName[i + 1]
            i = i + 1
          } else { 
            result.push(processedName[i])
          }
        }
       // end of combine float number
       
        return result;

    }).sort((a,b) => {
        let len = Math.min(a.length,b.length);
        for(let i=0;i<len;i++) {
            if(a[i]!=b[i]) {
                let isNumA = typeof a[i] === "number";
                let isNumB = typeof a[i] === 'number';
                if(isNumA && isNumB) {
                    return a[i]-b[i];
                } else if(isNumA) {
                    return -1;
                } else if(isNumB) {
                    return 1;
                } else {
                    return a[i]<b[i] ? -1 : 1 ;
                }
            }
        }
        // in case of one string being a prefix of the other
        return a.length - b.length;
    }).map(v => v.join(''));
}

let b = ['2.png', '2.5.png','1.5.png', '1.png'];
console.log(natSort(b).join(' -> '))

// will output: '1.png -> 1.5.png -> 2.png -> 2.5.png'

This code is just for demo, we could use regex to simplify the procedure in the real project.

But, I don't think this is a perfect solution too. some corner case still fail. take ['2.png', '2.5.png','1.5.png', '1.png', '1.5.5.png'] for example, it will output '1.png -> 1.5.5.png -> 1.5.png -> 2.png -> 2.5.png'.

Actually natural sort is really tricky with too many corner case to consider, even the famous library natsort(https://pypi.org/project/natsort/) will fail with ['2.png', '2.5.png','1.5.png', '1.png', '1.5.5.png'].

My first idea was to keep the current algorithm to be honest. And just allow adding the numeric separators (it can be . or , depending on the language) limited to one (here)

The downside of my method is that it will only dort by prepending numbers but it will cover the most important use case (audio files).

Let's try with this algorithm though and see the results.

I found a really simple way to achieve this using: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.comparisons/natural-order.html

See !1794 (merged)

assigned to @Aza

mentioned in merge request !1794 (merged)

closed with commit 3ad12c3c

closed with merge request !1794 (merged)

Browser: sort issue with files named [number].[number].ext

Description

Expected behavior

Actual behavior

Steps to reproduce

Screenshot / video

Context

App version

Android version

Device model

App mode

Designs

Child items ...

Activity