0Pricing
Electron Desktop App Development · Lesson

File System Access

Learn to read, write, and manipulate files and directories directly on the user's system using Node.js `fs` module from the main process.

File System Access is a free Electron Desktop App Development lesson on CoddyKit — lesson 2 of 3. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Electron Desktop App Development learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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.

Frequently asked questions

Is the “File System Access” lesson free?

Yes — the full text of “File System Access” is free to read here on the web, and the Electron Desktop App Development course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Electron Desktop App Development course, upgrade to CoddyKit PRO.

What will I learn in “File System Access”?

Learn to read, write, and manipulate files and directories directly on the user's system using Node.js `fs` module from the main process. You practise Electron Desktop App Development with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Electron Desktop App Development?

No prior experience is required. Electron Desktop App Development on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 3, so you can start here or from the beginning and move at your own pace.

How long does the “File System Access” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Electron Desktop App Development lesson?

Yes. Every Electron Desktop App Development lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Local Storage & IndexedDB
  2. File System Access
  3. Embedded Databases with SQLite
← Back to Electron Desktop App Development