0Pricing
Electron Desktop App Development · Aula

Acesso ao Sistema de Arquivos

Aprenda a ler, gravar e manipular arquivos e diretórios diretamente no sistema do usuário usando o módulo `fs` do Node.js a partir do processo principal.

Acesso ao Sistema de Arquivos é uma aula grátis de Electron Desktop App Development no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Electron Desktop App Development, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Electron Desktop App Development inclui 3 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Accessing Local Files

Electron apps can do more than web pages. They can interact directly with the user's computer, including its file system!

This lesson explores how to read, write, and manage files and directories using Node.js's fs module.

Node.js `fs` Module Explained

The fs (File System) module is a core Node.js feature. It provides methods to interact with the file system.

  • Reading Files: Get content from existing files.
  • Writing Files: Create new files or update existing ones.
  • Managing Directories: Create, delete, or list folders.

It's your gateway to persistent local data.

`fs` & The Main Process

For security, you should primarily use the fs module in Electron's main process.

The main process has full Node.js access, while renderer processes (your web pages) are typically sandboxed. This prevents malicious web content from directly accessing user files.

If a renderer needs file access, it should request it securely from the main process via IPC.

Reading Files (`readFileSync`)

The simplest way to read a file is synchronously using fs.readFileSync(). This means your code will pause until the file is read.

Specify the file path and encoding (e.g., 'utf8') to get the content as a string.

const fs = require('fs');
const path = require('path');

// Create a temporary file for demonstration
const tempFilePath = path.join(__dirname, 'hello.txt');
fs.writeFileSync(tempFilePath, 'Hello CoddyKit!', 'utf8');

try {
  const content = fs.readFileSync(tempFilePath, 'utf8');
  console.log('Read content:', content);
} catch (error) {
  console.error('Failed to read file:', error.message);
}

// Clean up the temporary file
fs.unlinkSync(tempFilePath);

Writing Files (`writeFileSync`)

To write content to a file, use fs.writeFileSync(). If the file doesn't exist, it will be created. If it does, its content will be overwritten.

Always handle potential errors with try...catch blocks.

const fs = require('fs');
const path = require('path');

const outputFilePath = path.join(__dirname, 'output.txt');
const dataToWrite = 'This is some new content for the file.';

try {
  fs.writeFileSync(outputFilePath, dataToWrite, 'utf8');
  console.log('File written successfully to', outputFilePath);
} catch (error) {
  console.error('Failed to write file:', error.message);
}

// Clean up the temporary file
fs.unlinkSync(outputFilePath);

Appending Data (`appendFileSync`)

If you want to add content to the end of an existing file without overwriting it, use fs.appendFileSync().

This is useful for logging or adding new entries to a list.

const fs = require('fs');
const path = require('path');

const logFilePath = path.join(__dirname, 'app.log');

// Ensure the file exists (or create it)
fs.writeFileSync(logFilePath, 'Initial log entry.\n', 'utf8');

const newLogEntry = 'Another event happened now.\n';
try {
  fs.appendFileSync(logFilePath, newLogEntry, 'utf8');
  console.log('Appended to log file.');
  console.log('Current log content:\n', fs.readFileSync(logFilePath, 'utf8'));
} catch (error) {
  console.error('Failed to append to file:', error.message);
}

// Clean up the temporary file
fs.unlinkSync(logFilePath);

Asynchronous `fs` Methods

Synchronous operations can block your application's main thread, making your UI unresponsive. For better performance, especially with larger files, use asynchronous methods.

fs.readFile() and fs.writeFile() use callbacks or Promises (with fs/promises module) to handle completion.

const fs = require('fs/promises'); // Using promise-based fs
const path = require('path');

const asyncFilePath = path.join(__dirname, 'async_data.txt');
const data = 'Data for async file.';

async function runAsyncOperations() {
  try {
    await fs.writeFile(asyncFilePath, data, 'utf8');
    console.log('Async file written.');

    const content = await fs.readFile(asyncFilePath, 'utf8');
    console.log('Async file read:', content);
  } catch (error) {
    console.error('Async operation failed:', error.message);
  } finally {
    // Clean up
    if (await fs.stat(asyncFilePath).then(() => true).catch(() => false)) {
      await fs.unlink(asyncFilePath);
    }
  }
}

runAsyncOperations();

Creating & Listing Directories

The fs module also lets you manage directories (folders).

  • fs.mkdirSync(path, { recursive: true }): Creates a directory. recursive: true creates parent directories if needed.
  • fs.readdirSync(path): Reads the contents of a directory, returning an array of file/directory names.
  • fs.rmSync(path, { recursive: true, force: true }): Removes a directory (and its contents).
const fs = require('fs');
const path = require('path');

const dirPath = path.join(__dirname, 'my_app_data');
const subDirPath = path.join(dirPath, 'logs');

try {
  // Create directories
  fs.mkdirSync(subDirPath, { recursive: true });
  console.log('Directory created:', subDirPath);

  // Write a file inside
  fs.writeFileSync(path.join(dirPath, 'config.json'), '{ "version": "1.0" }');
  fs.writeFileSync(path.join(subDirPath, 'error.log'), 'Error 1\nError 2');

  // List contents of dirPath
  const contents = fs.readdirSync(dirPath);
  console.log('Contents of', dirPath, ':', contents);

} catch (error) {
  console.error('Directory operation failed:', error.message);
} finally {
  // Clean up
  if (fs.existsSync(dirPath)) {
    fs.rmSync(dirPath, { recursive: true, force: true });
    console.log('Cleaned up directory:', dirPath);
  }
}

Paths with the `path` Module

File paths differ between operating systems (e.g., /home/user/file.txt on Linux vs. C:\Users\user\file.txt on Windows).

Use Node.js's built-in path module to construct and normalize paths reliably across platforms.

  • path.join(...segments): Joins path segments.
  • path.resolve(...segments): Resolves a sequence of paths or path segments into an absolute path.
const path = require('path');

const userDir = 'CoddyKitApp';
const dataFile = 'settings.json';

// Correct way to join paths
const fullPath = path.join(userDir, 'data', dataFile);
console.log('Joined path:', fullPath);

// Get absolute path (relative to current working directory)
const absolutePath = path.resolve(userDir, 'data', dataFile);
console.log('Absolute path:', absolutePath);

// Get directory name
console.log('Dir name:', path.dirname(fullPath));

// Get base name (file name with extension)
console.log('Base name:', path.basename(fullPath));

File System Challenge

Consider the following Node.js code snippet:

const fs = require('fs');
const path = require('path');
const filePath = path.join(__dirname, 'test_file.txt');

fs.writeFileSync(filePath, 'First line.\n', 'utf8');
fs.appendFileSync(filePath, 'Second line.\n', 'utf8');
const content = fs.readFileSync(filePath, 'utf8');

console.log(content);
fs.unlinkSync(filePath); // Clean up

File System Access Recap

You've learned how to interact with the file system in Electron!

  • The fs module is key for file operations.
  • Perform file operations primarily in the main process for security.
  • Distinguish between synchronous (blocking) and asynchronous (non-blocking) methods.
  • Use the path module for cross-platform path management.

This knowledge allows your Electron apps to store and retrieve data directly on the user's machine.

Perguntas Frequentes

A aula “Acesso ao Sistema de Arquivos” é grátis?

Sim — o texto completo de “Acesso ao Sistema de Arquivos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Electron Desktop App Development, atualize para CoddyKit PRO. O curso de Electron Desktop App Development inclui 3 aulas no total.

O que vou aprender em “Acesso ao Sistema de Arquivos”?

Aprenda a ler, gravar e manipular arquivos e diretórios diretamente no sistema do usuário usando o módulo `fs` do Node.js a partir do processo principal. Você pratica Electron Desktop App Development com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Electron Desktop App Development?

Nenhuma experiência prévia é necessária. Electron Desktop App Development no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Acesso ao Sistema de Arquivos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Electron Desktop App Development?

Sim. Cada aula de Electron Desktop App Development inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Armazenamento Local e IndexedDB
  2. Acesso ao Sistema de Arquivos
  3. Bancos de Dados Incorporados com SQLite
← Voltar para Electron Desktop App Development