Arrays 如何创建文件夹结构的嵌套对象表示

所以我需要得到一个平面数组和一个表示文件夹结构的嵌套对象。但是，它确实需要过滤掉某些文件夹中没有某些文件（

FILE.txt

），然后一起忽略这些文件

考虑以下文件：

.
├── folder0                # not this folder
│   ├── FILE.txt           # <- here  
│   ├── some.other
│   └── more.files
├── stuff                  # not this folder
│   ├── some.other
│   └── more.files
└── folder1
    ├── FILE.txt           # <- here
    ├── subfolder1
    │   ├── FILE.txt       # <- here
    │   ├── some.other
    │   └── more.files
    ├── subfolder2
    │   └── FILE.txt       # <- here
    └── subfolder3
        ├── FILE.txt       # <- here
        ├── subsubfolder1
        │   ├── FILE.txt   # <- here
        │   ├── some.other
        │   └── more.files
        └── subsubfolder2
            └── FILE.txt   # <- here

和表示文件夹嵌套的嵌套对象：

{
  'folder0': 'folder0',
  'folder1': {
    'subfolder1': 'subfolder1',
    'subfolder2': 'subfolder2',
    'subfolder3': {
      'subsubfolder1': 'subsubfolder1',
      'subsubfolder2': 'subsubfolder2'
    }
  }
}

现在我得到了第一个。非常简单的系统递归遍历：

const GetContent = ( folder, content = []) => {
  if( Fs.existsSync( folder ) ) {
    Fs.readdirSync( folder )
      .map(
        file => {
          if( Fs.statSync( Path.join( folder, file ) ).isDirectory() ) {
            const result = GetContent( Path.join( folder, file ), content );
            content = [ ...result ];
          }
          else {
            if( file === `${ SETTINGS.get().folder.index }.yml` ) {
              content.push( folder );
            }
          }
        }
      );

    return content;
  }
};

此代码将为我提供平面阵列，一切正常

问题:

• 但是，它如何到达我的嵌套对象？我想防止两次访问文件系统
• 这应该作为一个额外的功能来完成，还是在与上面相同的内部来防止另一个循环

我试过的 我已经尝试了太长的时间，以使它在相同的功能不知何故。 然后我想也许我只是把平面阵列转换成一个嵌套的对象，但是我今天头疼。但是下面的坏测试根本做不到。我想今天我的头被堵住了。有人帮忙吗

const ToDepth = ( items, result, iterator = 0 ) => {

  iterator ++;
  result[ items[ 0 ] ] = {};

  if( items.length > 1 ) {
    result[ items[ 0 ] ] = ToDepth( items.slice( 1 ), result[ items[ 0 ] ], iterator );
  }
  else {
    if( Object.keys( result[ items[ 0 ] ] ).length === 0 ) {
      result[ items[ 0 ] ] = items[ 0 ];
    }
  }

  return result;
}


const ToNested = ( element ) => {
  let result = {};

  element.map( ( item ) => {
    result = ToDepth( item.split('/'), result );
  });

  return result;
};

ToNested( flatArray );

---

以下是我对代码的看法：

const flat=[
“folder0”，
“folder1”，
“文件夹1/子文件夹1”，
“文件夹1/子文件夹2”，
“文件夹1/子文件夹3”，
“文件夹1/子文件夹3/子文件夹1”，
“文件夹1/子文件夹3/子文件夹2”
];
常量嵌套={}；
常量添加=（源、目标）=>{
常量元素=source.split（“/”）；
常量元素=elements.shift（）；
目标[元素]=目标[元素]| |元素；
if（元素长度）{
目标[元素]=目标[元素]的类型==“对象”？目标[元素]：{}；
添加（elements.join（“/”），目标[元素]；
}
};
flat.forEach（item=>add（item，嵌套））；
console.log（嵌套）以下是我对代码的看法：


const flat=[
“folder0”，
“folder1”，
“文件夹1/子文件夹1”，
“文件夹1/子文件夹2”，
“文件夹1/子文件夹3”，
“文件夹1/子文件夹3/子文件夹1”，
“文件夹1/子文件夹3/子文件夹2”
];
常量嵌套={}；
常量添加=（源、目标）=>{
常量元素=source.split（“/”）；
常量元素=elements.shift（）；
目标[元素]=目标[元素]| |元素；
if（元素长度）{
目标[元素]=目标[元素]的类型==“对象”？目标[元素]：{}；
添加（elements.join（“/”），目标[元素]；
}
};
flat.forEach（item=>add（item，嵌套））；
console.log（嵌套）谢谢。看起来不错，我一分钟后上班就可以测试了。所以你认为它应该是一个额外的函数，一个额外的循环？因为我已经在文件夹中进行了迭代，所以我希望它具有相同的外观，但我可能会使它变得比需要的更复杂。我不知道它是否应该是一个额外的函数。我只是提供一种解决这个问题的有效方法。你可能会找到一个更好的方法：）谢谢你。看起来不错，我一分钟后上班就可以测试了。所以你认为它应该是一个额外的函数，一个额外的循环？因为我已经在文件夹中进行了迭代，所以我希望它具有相同的外观，但我可能会使它变得比需要的更复杂。我不知道它是否应该是一个额外的函数。我只是提供一种解决这个问题的有效方法。您最终可能会找到更好的方法：）
const ToDepth = ( items, result, iterator = 0 ) => {

  iterator ++;
  result[ items[ 0 ] ] = {};

  if( items.length > 1 ) {
    result[ items[ 0 ] ] = ToDepth( items.slice( 1 ), result[ items[ 0 ] ], iterator );
  }
  else {
    if( Object.keys( result[ items[ 0 ] ] ).length === 0 ) {
      result[ items[ 0 ] ] = items[ 0 ];
    }
  }

  return result;
}


const ToNested = ( element ) => {
  let result = {};

  element.map( ( item ) => {
    result = ToDepth( item.split('/'), result );
  });

  return result;
};

ToNested( flatArray );