When you need to check if a file exists in Node.js, the fs module is your go-to tool. However, there’s a subtlety here that trips up a lot of developers: fs.exists used to be the simplest way, but it’s now deprecated because it has race conditions and other quirks.
Instead, the recommended approach is to use fs.access, which tests a user’s permissions for a file or directory. At its core, fs.access tries to read the file’s metadata and will throw an error if the file doesn’t exist or you don’t have the necessary permissions.
Here’s a quick example of how you can check if a file exists with fs.access:
const fs = require('fs');
fs.access('/path/to/file.txt', fs.constants.F_OK, (err) => {
if (err) {
console.log('File does not exist');
} else {
console.log('File exists');
}
});
The fs.constants.F_OK flag checks just for the existence of the file, without worrying about read or write permissions. If you want to check if it’s readable or writable, you can combine flags like fs.constants.R_OK or fs.constants.W_OK.
This method is much safer than relying on fs.existsSync or the deprecated fs.exists because it handles permissions and existence checks atomically, reducing the chance of a race condition between your check and a subsequent file operation.
If you want a synchronous version, you can use fs.accessSync, but beware: synchronous operations block the event loop, so avoid them in performance-critical or server environments.
try {
fs.accessSync('/path/to/file.txt', fs.constants.F_OK);
console.log('File exists');
} catch (err) {
console.log('File does not exist');
}
One common mistake is to assume that checking for file existence first and then opening or reading the file guarantees safety. That’s a classic time-of-check-to-time-of-use (TOCTOU) problem. The file might be deleted or changed between your existence check and the actual file operation. So, the best practice is usually to just attempt the operation directly and handle errors gracefully.
But sometimes, for logging, conditional logic, or UI feedback, you really just need that quick existence check. In those cases, fs.access remains the most robust and idiomatic approach in modern Node.js.
Portable Bluetooth Speaker Beach Essentials: Powerful Crystal Clear Sound/Dynamic Light/IPX5 Waterproof/All Day Playtime/Wireless BT 5.3/TWS Paring, Dad Gifts, Outdoor|Travel|Camping|Pool Accessories
$19.99 (as of June 2, 2026 22:39 GMT +00:00 - More infoProduct prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on [relevant Amazon Site(s), as applicable] at the time of purchase will apply to the purchase of this product.)Handling asynchronous file checks effectively
Working with asynchronous file checks means embracing callbacks, promises, or async/await patterns to keep your code clean and non-blocking. Since fs.access uses callbacks by default, you might want to wrap it in a Promise to integrate smoothly with modern JavaScript.
const fs = require('fs').promises;
async function fileExists(path) {
try {
await fs.access(path, fs.constants.F_OK);
return true;
} catch {
return false;
}
}
(async () => {
const exists = await fileExists('/path/to/file.txt');
console.log(exists ? 'File exists' : 'File does not exist');
})();
Using the fs.promises API simplifies asynchronous code dramatically by avoiding callback hell. It also plays nicely with async/await, which improves readability and error handling.
If you prefer to stick with callbacks, you can modularize your existence check into a reusable function to avoid duplicating logic:
const fs = require('fs');
function checkFileExists(path, callback) {
fs.access(path, fs.constants.F_OK, (err) => {
callback(!err);
});
}
checkFileExists('/path/to/file.txt', (exists) => {
console.log(exists ? 'Found the file!' : 'No file found.');
});
Keep in mind that these asynchronous checks do not guarantee the file’s state when you perform follow-up operations. Always be prepared to handle errors in the actual file operations themselves.
Another pattern to consider is debouncing or caching file existence checks if you’re querying the same file repeatedly in a short time span. This can improve performance by reducing unnecessary disk I/O:
const fs = require('fs').promises;
const cache = new Map();
async function cachedFileExists(path) {
if (cache.has(path)) {
return cache.get(path);
}
try {
await fs.access(path, fs.constants.F_OK);
cache.set(path, true);
return true;
} catch {
cache.set(path, false);
return false;
}
}
By caching results, you avoid hammering the filesystem with redundant checks, which can be especially useful in server environments or scripts that repeatedly verify the same files.
