Робота з директоріями

import path from 'node:path';

const logsDirectory = path.join(process.cwd(), 'logs');

await fs.mkdir('reports');

await fs.mkdir('data/2026/january', { recursive: true });

const directory = path.join(process.cwd(), 'storage', 'uploads');

await fs.mkdir(directory, { recursive: true });

const entries = await fs.readdir('./storage');

console.log(entries);

[ 'uploads', 'config.json', 'archive' ]

const entries = await fs.readdir('./storage', {
  withFileTypes: true
});

for (const entry of entries) {
  if (entry.isDirectory()) {
    console.log(`Директорія: ${entry.name}`);
  } else if (entry.isFile()) {
    console.log(`Файл: ${entry.name}`);
  }
}

const entries = await fs.readdir('./storage', {
  withFileTypes: true
});

const directories = entries
  .filter((entry) => entry.isDirectory())
  .map((entry) => entry.name);

console.log(directories);

await fs.rename('drafts', 'published');

await fs.rename(
  './temporary/reports',
  './archive/reports'
);

const source = path.join(process.cwd(), 'temporary', 'reports');
const destination = path.join(process.cwd(), 'archive', 'reports');

await fs.rename(source, destination);

const information = await fs.stat('./storage');

console.log(information.isDirectory());
console.log(information.isFile());

async function getPathState(targetPath) {
  try {
    const information = await fs.stat(targetPath);

    return {
      exists: true,
      isDirectory: information.isDirectory(),
      isFile: information.isFile()
    };
  } catch (error) {
    if (error.code === 'ENOENT') {
      return {
        exists: false,
        isDirectory: false,
        isFile: false
      };
    }

    throw error;
  }
}

const state = await getPathState('./storage');

if (!state.exists) {
  console.log('Директорії не існує');
} else if (state.isDirectory) {
  console.log('Шлях вказує на директорію');
} else {
  console.log('Шлях існує, але це не директорія');
}

await fs.rm('./temporary');

await fs.rm('./temporary', {
  recursive: true
});

await fs.rm('./temporary', {
  recursive: true,
  force: true
});

const temporaryDirectory = path.join(process.cwd(), 'temporary');

await fs.rm(temporaryDirectory, {
  recursive: true,
  force: true
});

import * as fs from 'node:fs/promises';
import path from 'node:path';

const workspace = path.join(process.cwd(), 'directory-demo');
const sourceDirectory = path.join(workspace, 'reports', 'drafts');
const renamedDirectory = path.join(workspace, 'reports', 'published');

async function getDirectoryState(targetPath) {
  try {
    const information = await fs.stat(targetPath);

    return {
      exists: true,
      isDirectory: information.isDirectory(),
      isFile: information.isFile()
    };
  } catch (error) {
    if (error.code === 'ENOENT') {
      return {
        exists: false,
        isDirectory: false,
        isFile: false
      };
    }

    throw error;
  }
}

async function main() {
  // Видаляємо залишки попереднього запуску прикладу
  await fs.rm(workspace, {
    recursive: true,
    force: true
  });

  // Створюємо вкладену структуру директорій
  await fs.mkdir(sourceDirectory, {
    recursive: true
  });

  console.log('Створено:', sourceDirectory);

  // Читаємо вміст батьківської директорії
  const reportsDirectory = path.join(workspace, 'reports');
  const entries = await fs.readdir(reportsDirectory, {
    withFileTypes: true
  });

  for (const entry of entries) {
    const type = entry.isDirectory() ? 'директорія' : 'файл';
    console.log(`${entry.name}: ${type}`);
  }

  // Перевіряємо стан директорії
  const beforeRename = await getDirectoryState(sourceDirectory);
  console.log('До перейменування:', beforeRename);

  // Перейменовуємо директорію
  await fs.rename(sourceDirectory, renamedDirectory);
  console.log('Перейменовано на:', renamedDirectory);

  const afterRename = await getDirectoryState(sourceDirectory);
  const renamedState = await getDirectoryState(renamedDirectory);

  console.log('Старий шлях:', afterRename);
  console.log('Новий шлях:', renamedState);

  // Видаляємо всю демонстраційну структуру
  await fs.rm(workspace, {
    recursive: true,
    force: true
  });

  const afterDelete = await getDirectoryState(workspace);
  console.log('Після видалення:', afterDelete);
}

main().catch((error) => {
  console.error('Помилка:', error);
  process.exitCode = 1;
});

{
  "type": "module"
}

try {
  await fs.mkdir('./reports');
  console.log('Директорію створено');
} catch (error) {
  if (error.code === 'EEXIST') {
    console.log('Директорія вже існує');
  } else {
    throw error;
  }
}

await fs.mkdir('./reports', { recursive: true });

try {
  await fs.rm('./temporary', {
    recursive: true
  });
} catch (error) {
  if (error.code !== 'ENOENT') {
    throw error;
  }
}

await fs.rm('./data');

await fs.rm('./data', {
  recursive: true,
  force: true
});

await fs.mkdir('./archive', { recursive: true });
await fs.rename('./reports', './archive/reports');

const directory = path.join(process.cwd(), 'storage');