Working with the File System in TypeScript: A Complete Guide

Introduction to Working with the File System in TypeScript

TypeScript is a strictly typed extension of JavaScript that adds static typing and improves code readability and maintainability. One of the key tasks in developing server-side applications is working with the file system: reading and writing files, creating and deleting directories, and managing data streams. In this article, we will thoroughly examine how to efficiently work with the file system in TypeScript using the built-in fs module from Node.js.

The fs module provides both synchronous and asynchronous methods for interacting with the file system. In TypeScript, we can take advantage of typing to make code more reliable and understandable. We will cover basic operations including reading, writing, checking file existence, working with directories, and error handling.

Basic File Operations

Reading Files

To read file contents in TypeScript, you can use the readFile method (asynchronous) or readFileSync (synchronous). The asynchronous approach is recommended for non-blocking program execution.

import { readFile } from 'fs/promises';

async function readFileExample(filePath: string): Promise<string> {  try {    const data = await readFile(filePath, 'utf-8');    return data;  } catch (error) {    console.error('Error reading file:', error);    throw error;  }}

// UsagereadFileExample('example.txt').then(content => {  console.log('File contents:', content);});

Note the use of fs/promises — this is a promise wrapper that allows using async/await syntax. The return type Promise<string> explicitly indicates that the function returns a string.

Writing to Files

Writing data to a file is done using the writeFile and writeFileSync methods. In TypeScript, it is important to properly handle potential errors, especially if the file is write-protected or the path does not exist.

import { writeFile, mkdir } from 'fs/promises';import { existsSync } from 'fs';

async function writeFileExample(filePath: string, data: string): Promise<void> {  try {    // Check if the directory exists    const dir = filePath.substring(0, filePath.lastIndexOf('/'));    if (dir && !existsSync(dir)) {      await mkdir(dir, { recursive: true });    }    await writeFile(filePath, data, 'utf-8');    console.log('File successfully written');  } catch (error) {    console.error('Error writing file:', error);  }}

// UsagewriteFileExample('data/output.txt', 'Hello, TypeScript!');

In this example, we first check if the directory exists and create it if necessary using mkdir with the recursive: true option. This helps avoid the "ENOENT" error if the parent folder does not exist.

Appending Data to a File

If you need to append data to an existing file, use the appendFile method:

import { appendFile } from 'fs/promises';

async function appendToFile(filePath: string, data: string): Promise<void> {  try {    await appendFile(filePath, '' + data, 'utf-8');    console.log('Data appended');  } catch (error) {    console.error('Error appending:', error);  }}

Working with Directories

Creating and Deleting Directories

To create directories, use mkdir; to delete them, use rmdir or rm (for recursive deletion). In TypeScript, it is convenient to use generics for typing paths.

import { mkdir, rmdir, rm } from 'fs/promises';import { existsSync } from 'fs';

async function createDirectory(di