Javascript数组：将当前项向后移动

使用JavaScript，我有一个文件路径数组，我正在循环和检查这些路径。如果当前项目是一个文件夹，我想把它放到行的后面，然后转到下一个项目。最终的结果是文件在前面，文件夹在最后一个文件之后

我知道这应该很容易，但我已经为此奋斗了两天。我尝试了以下代码的各种版本，但没有成功。对于这个项目，如果文件名中没有句点，我假设它是一个文件夹

function sortArray(array) {

    console.log('Original array: ' + array);
    var z = array.length;
    console.log('Array length is ' + z);

    for(i = 0; i < z-1; i++)
    { 
        var n = array.indexOf(array[i]);


        if (array[i].indexOf('.') === -1)
        {
            console.log('Item is folder');
            var fldr = array.splice(n, 1);
            array.push(fldr);
        }
    }

    console.log('Sorted array: ' + array);
}

函数排序（数组）{
log（'原始数组：'+数组）；
var z=数组长度；
log（'数组长度为'+z'）；
对于（i=0；i

简单的回答是，通过调用

splice

然后调用

push

，您将元素添加回阵列的末端（尾部），而实际上您希望使用

unshift

将其移动到前端（头部）

但你也可以采取其他更简单的方法。例如，您可以使用带有自定义比较函数的

sort

对数组进行排序：

array.sort(function(x, y) {
  var xFolder = x.indexOf('.') == -1 ? 1 : 0;
  var yFolder = y.indexOf('.') == -1 ? 1 : 0;
  return yFolder - xFolder;
});

array.sort(function(filePathOne, filePathTwo) {
    var oneIsFile = FilePathOne.indexOf('.') == -1 ? 1 : 0;
    var twoIsFile = FilePathTwo.indexOf('.') == -1 ? 1 : 0;
    return twoIsFile - oneIsFile;      // File comes before folder
});

这将快速排序数组，将所有文件夹（基于“无句点表示它是文件夹”标准）放在第一位

另一种选择是返回一个新数组，而不是修改当前数组。这将很容易实现：

function putFoldersFirst(entries) {
  var folders = [],
      files = [];

  for (var i = 0; i < entries.length; ++i) {
    if (entries[i].indexOf('.') == -1) {
      folders.push(entries[i]);
    } else {
      files.push(entries[i]);
    }
  }

  return folders.concat(files);
}

函数putFoldersFirst（条目）{
var folders=[]，
文件=[]；
对于（变量i=0；i

---

与往常一样，有不止一种方法。

简单的回答是，通过调用

splice

，然后调用

push

，您将元素添加回阵列的末端（尾部），而实际上您希望使用

unshift

将其移动到前端（头部）

但你也可以采取其他更简单的方法。例如，您可以使用带有自定义比较函数的

sort

对数组进行排序：

array.sort(function(x, y) {
  var xFolder = x.indexOf('.') == -1 ? 1 : 0;
  var yFolder = y.indexOf('.') == -1 ? 1 : 0;
  return yFolder - xFolder;
});

array.sort(function(filePathOne, filePathTwo) {
    var oneIsFile = FilePathOne.indexOf('.') == -1 ? 1 : 0;
    var twoIsFile = FilePathTwo.indexOf('.') == -1 ? 1 : 0;
    return twoIsFile - oneIsFile;      // File comes before folder
});

这将快速排序数组，将所有文件夹（基于“无句点表示它是文件夹”标准）放在第一位

另一种选择是返回一个新数组，而不是修改当前数组。这将很容易实现：

function putFoldersFirst(entries) {
  var folders = [],
      files = [];

  for (var i = 0; i < entries.length; ++i) {
    if (entries[i].indexOf('.') == -1) {
      folders.push(entries[i]);
    } else {
      files.push(entries[i]);
    }
  }

  return folders.concat(files);
}

函数putFoldersFirst（条目）{
var folders=[]，
文件=[]；
对于（变量i=0；i

---

一如既往，有多种方法。

您应该使用不同的数组进行循环和修改。这是过去很多次让我绊倒的事情。一旦您移动了某些内容，循环的索引或迭代器就不能保证再指向正确的项

只需创建一个temparray，在迭代原始数组的同时，检查temparray中的正确位置，并从原始数组中复制值，完成后，返回排序后的数组

---

当然，也就是说，如果您确实希望手动执行此操作，而不是像上面建议的那样使用内置排序

应该使用不同的数组进行循环和修改。这是过去很多次让我绊倒的事情。一旦您移动了某些内容，循环的索引或迭代器就不能保证再指向正确的项

只需创建一个temparray，在迭代原始数组的同时，检查temparray中的正确位置，并从原始数组中复制值，完成后，返回排序后的数组

---

当然，也就是说，如果您确实希望手动执行此操作，而不是像上面建议的那样使用内置排序

或者，您可以使用筛选出具有

”的项。

和不具有

的项，并将它们连接起来：

var items = [ 'a', 'b.c', 'adf', 'd.d', 'a.a' ];

var sortedItems = items.filter( function( item ) {
    return item.indexOf( '.' ) !== -1;
  } ).concat( items.filter( function( item ) {
    return item.indexOf( '.' ) === -1;
  } )
);

// you get: ["b.c", "d.d", "a.a", "a", "adf"]

或者，您可以使用筛选出具有“
”的项。
和不具有“
”的项，并将它们连接起来：

var items = [ 'a', 'b.c', 'adf', 'd.d', 'a.a' ];

var sortedItems = items.filter( function( item ) {
    return item.indexOf( '.' ) !== -1;
  } ).concat( items.filter( function( item ) {
    return item.indexOf( '.' ) === -1;
  } )
);

// you get: ["b.c", "d.d", "a.a", "a", "adf"]

有很多方法可以做到这一点，但这里有一种方法是使用
Array.prototype.sort

var filesAndFolders = ['file1.txt', 'folder2', 'folder1', 'file2.txt'];

function sortFilesAndFolders(arr) {
    return arr.sort(function (a, b) {
        var aIsFolder = isFolder(a),
            bIsFolder = isFolder(b);

        return aIsFolder !== bIsFolder? 
            sortByType(aIsFolder) : 
            sortByName(a, b);
    });

    function sortByType(aIsFolder) { return aIsFolder? 1 : -1; }
    function sortByName(a, b) { return a < b? -1 : +(a > b); }
    function isFolder(item) { return item.indexOf('.') === -1; }
}

sortFilesAndFolders(filesAndFolders);
//["file1.txt", "file2.txt", "folder1", "folder2"]

var filesAndFolders=['file1.txt'，'folder2'，'folder1'，'file2.txt']；
功能排序文件和文件夹（arr）{
返回arr.sort（函数（a，b）{
var aIsFolder=isFolder（a），
bIsFolder=isFolder（b）；
返回aIsFolder！==bIsFolder？
sortByType（文件夹）：
sortByName（a，b）；
});
函数sortByType（aIsFolder）{返回aIsFolder？1:-1；}
函数sortByName（a，b）{返回ab）；}
函数isFolder（item）{返回item.indexOf（'.'）===-1；}
}
排序文件和文件夹（文件和文件夹）；
//[“file1.txt”、“file2.txt”、“folder1”、“folder2”]
有很多方法可以做到这一点，但这里有一种方法是使用
Array.prototype.sort

var filesAndFolders = ['file1.txt', 'folder2', 'folder1', 'file2.txt'];

function sortFilesAndFolders(arr) {
    return arr.sort(function (a, b) {
        var aIsFolder = isFolder(a),
            bIsFolder = isFolder(b);

        return aIsFolder !== bIsFolder? 
            sortByType(aIsFolder) : 
            sortByName(a, b);
    });

    function sortByType(aIsFolder) { return aIsFolder? 1 : -1; }
    function sortByName(a, b) { return a < b? -1 : +(a > b); }
    function isFolder(item) { return item.indexOf('.') === -1; }
}

sortFilesAndFolders(filesAndFolders);
//["file1.txt", "file2.txt", "folder1", "folder2"]

var filesAndFolders=['file1.txt'，'folder2'，'folder1'，'file2.txt']；
功能排序文件和文件夹（arr）{
返回arr.sort（函数（a，b）{
var aIsFolder=isFolder（a），
bIsFolder=isFolder（b）；
返回aIsFolder！==bIsFolder？
sortByType（文件夹）：
sortByName（a，b）；
});
函数sortByType（aIsFolder）{返回aIsFolder？1:-1；}
函数sortByName（a，b）{返回ab）；}
函数isFolder（item）{返回item.indexOf（'.'）===-1；}
}
排序文件和文件夹（文件和文件夹）；
//[“file1.txt”、“file2.txt”、“folder1”、“folder2”]
如果文件和文件夹的原始顺序很重要