Electron Desktop App Development · Leçon

Accès au système de fichiers

Apprenez à lire, écrire et manipuler directement les fichiers et les dossiers du système de l’utilisateur à l’aide du module `fs` de Node.js depuis le processus principal.

Leçon 2 sur 311 étapes

Accès au système de fichiers est une leçon Electron Desktop App Development gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Electron Desktop App Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Electron Desktop App Development comprend 3 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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

Réponds-y dans la leçon interactive

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.

Gratuit pour commencer

Apprends JavaScript avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 12
Leçons: 47

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Accès au système de fichiers » est-elle gratuite ?

Oui — le texte complet de « Accès au système de fichiers » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Electron Desktop App Development, passe à CoddyKit PRO. Le cours Electron Desktop App Development comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Accès au système de fichiers » ?

Apprenez à lire, écrire et manipuler directement les fichiers et les dossiers du système de l’utilisateur à l’aide du module `fs` de Node.js depuis le processus principal. Tu pratiques Electron Desktop App Development avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Electron Desktop App Development ?

Aucune expérience préalable n'est requise. Electron Desktop App Development sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Accès au système de fichiers » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Electron Desktop App Development ?

Oui. Chaque leçon Electron Desktop App Development inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Electron Desktop App Development