通過Javascript獲取文件的有序列表

Question

我有一個文件夾，其中包含文件：

s1, s2, s3, ... s9, s10, s11, ... s99, s100, s101, s102, s103, ...,

和腳本，將打印這些文件的列表：

filesystem = require('fs');
filesystem.readdirSync('./folder').forEach(function (file) {
    console.log(file);
});

但我得到這樣的無序列表：

s0, s1, s10, s100, s101, s102, s103, ... s11, s110, s111, s112, s12

我知道一個原因，但我想獲得“數字”排序列表，如下所示：

s1, s2, s3, ... s9, s10, s11, ... s99, s100, s101, s102, s103, ...,

Answer 1

您可以使用Array.prototype.sort通過剝離s並將其余部分解析為數字來對數組進行排序：

filesystem = require('fs');
var result = filesystem.readdirSync('./folder').sort(function (a, b) {
    return (+a.substr(1)) - (+b.substr(1));
});

Answer 2

filesystem.readdir('./folder', function(err, files) {
    files.sort(function(file1, file2) {
        var file1Int =  parseInt(file1.replace( /^\D+/g, '')),
            file2Int =  parseInt(file2.replace( /^\D+/g, ''));

        if (file1Int < file2Int) {
            return -1;
        }
        if (file1Int > file2Int) {
           return 1;
        }
        return 0;

    }).forEach(function(file) {
        console.log(file);
    });
});

Answer 3

您可以執行以下操作：

filesystem.readdirSync('./folder', function(err, files) {
    files.sort(function(a, b) {
        a = a.replace(/\w/, ""); //removing 's' or word character
        b = b.replace(/\w/, "");

        return +a - +b;
    }).forEach(function(file) {
        console.log(file);
    });
});

Answer 4

var fs = require('fs'),
  files = fs.readdirSync('.'),
  sorted = files.sort(function (a, b) {
    return Number(a.substr(1)) > Number(b.substr(1));
  });
console.log(sorted);
// eg. [ 's0', 's1', 's10', 's100', 's101' ]

Answer 5

我覺得雖然其中一些答案現在可以使用，但是它們都不適合一般情況，所以我想我會嘗試更通用的方法，這可能對其他隨身閱讀此問題的人有用。

function getSort(caseInsensitive) {
    caseInsensitive = !!caseInsensitive;
    // Splits a string in to string and number fragments, parsing integers along the way.
    function getFragments(string) {
        var strings = string.split(/\d/);
        var numbers = string.split(/\D/);
        if (caseInsensitive === true) {
            strings = strings.map(function(string) {
                return string.toLowerCase();
            });
        }
        // Remove any empty strings (there's likely to be one at the start or at the end).
        var fragments = strings.filter(function(value) {
            return value.length > 0;
        });
        var insertIndex = 0;
        // Insert numbers in the correct place in the fragments array.
        for (var i = 0; i < numbers.length; i++) {
            if (numbers[i].length > 0) {
                fragments.splice(insertIndex, 0, parseInt(numbers[i]));
                // Add one to insert index to account for the element we just added.
                insertIndex++;
            }
            insertIndex++;
        }
        return fragments;
    }

    // Actual comparison function.
    return function(lhs, rhs) {
        var lhsFragments = getFragments(lhs);
        var rhsFragments = getFragments(rhs);

        for (var i = 0; i < lhsFragments.length; i++) {
            // Sort right-hand-side in front of left-hand-side if left-hand-side has more fragments.
            if (i >= rhsFragments.length) {
                return 1;
            }
            if (lhsFragments[i] !== rhsFragments[i]) {
                if (lhsFragments[i] < rhsFragments[i]) {
                    return -1;
                } else {
                    return 1;
                }
            }
        }
        // Sort left-hand-side in front of right-hand-side if right-hand-side has more fragments.
        if (lhsFragments.length < rhsFragments.length) {
            return -1;
        }
        return 0;
    }
}

var caseSensitiveSort = getSort();
var caseInsensitiveSort = getSort(true);
var testArray = [
    'x1',
    'X',
    'r22s1',
    'r2s2',
    's2',
    'r1t1',
    'r2',
    's1t1',
    's1',
    's1t2',
    't',
    's'
];
console.log(testArray.sort(caseSensitiveSort));
console.log(testArray.sort(caseInsensitiveSort));

輸出：

["X", "r1t1", "r2", "r2s2", "r22s1", "s", "s1", "s1t1", "s1t2", "s2", "t", "x1"]
["r1t1", "r2", "r2s2", "r22s1", "s", "s1", "s1t1", "s1t2", "s2", "t", "X", "x1"]

當然，它涉及的更多，但並不過分。 它也應該處理比以前發布的答案更多的情況，特別是它不會忽略比較中的實際字符串內容。 希望它對某人有用。