Trabalhando com o sistema de arquivos em TypeScript para iniciantes

Introdução ao trabalho com o sistema de arquivos em TypeScript

Trabalhar com o sistema de arquivos é uma das tarefas principais no desenvolvimento com TypeScript. Independentemente de você estar criando uma aplicação de servidor, um utilitário de processamento de dados ou um servidor web, você certamente precisará ler, escrever e gerenciar arquivos e diretórios. Neste guia, abordaremos os fundamentos do trabalho com o módulo fs (File System) em TypeScript, veremos operações síncronas e assíncronas e aprenderemos a tratar erros.

TypeScript é uma extensão estritamente tipada sobre JavaScript que adiciona tipagem estática. Ao trabalhar com o sistema de arquivos, usaremos o módulo padrão do Node.js fs, mas com os benefícios adicionais do TypeScript: autocompletar, verificação de tipos e legibilidade de código aprimorada.

Configuração do projeto e importação de módulos

Antes de começar, certifique-se de ter o Node.js e o TypeScript instalados. Crie um novo projeto e instale os tipos necessários:

mkdir fs-typescript-tutorialcd fs-typescript-tutorialnpm init -ynpm install typescript @types/node --save-devnpx tsc --init

Para trabalhar com o sistema de arquivos, precisaremos de dois módulos principais:

• fs — para realizar operações com arquivos (leitura, escrita, exclusão, etc.)
• path — para trabalhar convenientemente com caminhos (junção, normalização, obtenção de extensão)

Vamos importá-los em nosso arquivo TypeScript:

import * as fs from 'fs';import * as path from 'path';

// Alternativa — importar apenas as funções necessárias:import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';import { join, resolve } from 'path';

Observe: usamos import * as fs, pois o módulo fs exporta muitas funções. O TypeScript capturará automaticamente os tipos do pacote @types/node instalado.

Leitura e escrita de arquivos

Vamos começar com as operações mais básicas — leitura e escrita de arquivos de texto. No Node.js, existem duas abordagens: síncrona e assíncrona. Para scripts e utilitários simples, métodos síncronos são frequentemente usados, e para servidores de alta carga, os assíncronos, para não bloquear o event loop.

Leitura e escrita síncronas

Os métodos síncronos bloqueiam a execução do programa até a conclusão da operação. Eles são simples de usar e adequados para cenários onde a velocidade não é crítica:

import { readFileSync, writeFileSync } from 'fs';import { join } from 'path';

const filePath = join(__dirname, 'data.txt');

// Escrita no arquivo (cria o arquivo se não existir)writeFileSync(filePath, 'Olá, TypeScript!', 'utf-8');

// Leitura do arquivoconst content: string = readFileSync(filePath, 'utf-8');console.log(content); // Exibirá: Olá, TypeScript!

Observe a tipagem content: string — o TypeScript garante que obteremos uma string. Se o arquivo não existir, uma exceção será lançada, que deve ser tratada com try/catch.

Leitura e escrita assíncronas

Os métodos assíncronos aceitam um callback ou retornam uma Promise (nas versões modernas). Recomenda-se usar versões com Promise com async/await:

import { promises as fsPromises } from 'fs';import { join } from 'path';

const filePath = join(__dirname, 'async-data.txt');

async function handleFile(): Promise<void> {    try {        // Escrita assíncrona        await fsPromises.writeFile(filePath, 'Conteúdo assíncrono', 'utf-8');                // Leitura assíncrona        const data: string = await fsPromises.readFile(filePath, 'utf-8');        console.log(data); // Conteúdo assíncrono    } catch (error) {        console.error('Erro ao trabalhar com o arquivo:', error);    }}

handleFile();

O uso de async/await torna o código semelhante ao sin