Як я можу перевірити наявність файлу ?
У документації до модуля fs
є опис методу fs.exists(path, callback)
. Але, як я розумію, він перевіряє наявність лише каталогів. І мені потрібно перевірити файл !
Як це можна зробити?
Як я можу перевірити наявність файлу ?
У документації до модуля fs
є опис методу fs.exists(path, callback)
. Але, як я розумію, він перевіряє наявність лише каталогів. І мені потрібно перевірити файл !
Як це можна зробити?
Відповіді:
Чому б просто не спробувати відкрити файл? fs.open('YourFile', 'a', function (err, fd) { ... })
все одно після хвилинного пошуку спробуйте це:
var path = require('path');
path.exists('foo.txt', function(exists) {
if (exists) {
// do something
}
});
// or
if (path.existsSync('foo.txt')) {
// do something
}
Для Node.js v0.12.x та новіших версій
І те path.exists
й fs.exists
інше було застарілим
* Редагувати:
Змінено: else if(err.code == 'ENOENT')
до: else if(err.code === 'ENOENT')
Лінтер скаржиться, що подвійні рівні не є потрійними рівними.
Використання fs.stat:
fs.stat('foo.txt', function(err, stat) {
if(err == null) {
console.log('File exists');
} else if(err.code === 'ENOENT') {
// file does not exist
fs.writeFile('log.txt', 'Some log\n');
} else {
console.log('Some other error: ', err.code);
}
});
fs.exists
теж працює. У мене виникли проблеми з дозволами на файл.
path.exists
насправді застаріло на користьfs.exists
fs.exists
і fs.existsSync
також є застарілим. Найкращий спосіб перевірити наявність файлів - це fs.stat
, як показано вище.
fs.existsSync
більше не видаляється, хоча fs.exists
все ще є.
Простіший спосіб зробити це синхронно.
if (fs.existsSync('/etc/file')) {
console.log('Found file');
}
Документ API говорить, як existsSync
працює:
Перевірте, чи існує даний шлях, перевіривши файлову систему.
fs.existsSync(path)
тепер застаріло, див. nodejs.org/api/fs.html#fs_fs_existssync_path . Що стосується синхронної реалізації fs.statSync(path)
, див. Мою відповідь.
fs.existsSync
був застарілим, але цього більше немає.
Редагувати:
з вузла, який v10.0.0
ми могли використовуватиfs.promises.access(...)
Приклад коду асинхронізації, який перевіряє наявність файлу:
async function checkFileExists(file) {
return fs.promises.access(file, fs.constants.F_OK)
.then(() => true)
.catch(() => false)
}
Альтернативою stat може бути використання нового fs.access(...)
:
мінімізована функція короткої обіцянки для перевірки:
s => new Promise(r=>fs.access(s, fs.constants.F_OK, e => r(!e)))
Використання зразка:
let checkFileExists = s => new Promise(r=>fs.access(s, fs.constants.F_OK, e => r(!e)))
checkFileExists("Some File Location")
.then(bool => console.log(´file exists: ${bool}´))
розширений обіцяний шлях:
// returns a promise which resolves true if file exists:
function checkFileExists(filepath){
return new Promise((resolve, reject) => {
fs.access(filepath, fs.constants.F_OK, error => {
resolve(!error);
});
});
}
або якщо ви хочете робити це синхронно:
function checkFileExistsSync(filepath){
let flag = true;
try{
fs.accessSync(filepath, fs.constants.F_OK);
}catch(e){
flag = false;
}
return flag;
}
fs.constants.F_OK
і т. Д. Чи можливий також доступ до них, як fs.F_OK
? Дивно. Також лаконічний, що приємно.
fs.promises.access(path, fs.constants.F_OK);
щоб просто зробити Обіцянку, а не створювати Обіцянку.
fs.exists(path, callback)
і fs.existsSync(path)
тепер застаріли, див. https://nodejs.org/api/fs.html#fs_fs_exists_path_callback та https://nodejs.org/api/fs.html#fs_fs_existssync_path .
Для перевірки існування файлу синхронно можна використовувати, тобто. fs.statSync(path)
. fs.Stats
Об'єкт буде повернений , якщо файл існує, см https://nodejs.org/api/fs.html#fs_class_fs_stats , в іншому випадку видається помилка , яка буде спіймана заявою спроби / зловити.
var fs = require('fs'),
path = '/path/to/my/file',
stats;
try {
stats = fs.statSync(path);
console.log("File exists.");
}
catch (e) {
console.log("File does not exist.");
}
fs
походить змінна
fs.existsSync()
більше не застаріло.
Стара версія перед V6: ось документація
const fs = require('fs');
fs.exists('/etc/passwd', (exists) => {
console.log(exists ? 'it\'s there' : 'no passwd!');
});
// or Sync
if (fs.existsSync('/etc/passwd')) {
console.log('it\'s there');
}
ОНОВЛЕННЯ
Нові версії від V6: документація наfs.stat
fs.stat('/etc/passwd', function(err, stat) {
if(err == null) {
//Exist
} else if(err.code == 'ENOENT') {
// NO exist
}
});
fs.exists
і fs.existsSync
застаріли відповідно до посилання, яким ви поділилися.
existsSync
не застаріло відповідно до цього документа, можливо, це було під час його читання.
Сучасний асинхронний / очікувальний спосіб (Вузол 12.8.x)
const fileExists = async path => !!(await fs.promises.stat(path).catch(e => false));
const main = async () => {
console.log(await fileExists('/path/myfile.txt'));
}
main();
Нам потрібно використовувати, fs.stat() or fs.access()
тому що fs.exists(path, callback)
тепер застаріла
Ще один хороший спосіб - fs-extra
@Fox: чудова відповідь! Ось трохи розширення з деякими іншими параметрами. Це те, що я останнім часом використовую як перехід до рішення:
var fs = require('fs');
fs.lstat( targetPath, function (err, inodeStatus) {
if (err) {
// file does not exist-
if (err.code === 'ENOENT' ) {
console.log('No file or directory at',targetPath);
return;
}
// miscellaneous error (e.g. permissions)
console.error(err);
return;
}
// Check if this is a file or directory
var isDirectory = inodeStatus.isDirectory();
// Get file size
//
// NOTE: this won't work recursively for directories-- see:
// http://stackoverflow.com/a/7550430/486547
//
var sizeInBytes = inodeStatus.size;
console.log(
(isDirectory ? 'Folder' : 'File'),
'at',targetPath,
'is',sizeInBytes,'bytes.'
);
}
PS перевіряйте fs-extra, якщо ви його ще не використовуєте - це дуже солодко. https://github.com/jprichardson/node-fs-extra )
Є багато неточних коментарів щодо fs.existsSync()
застарілості; це не.
https://nodejs.org/api/fs.html#fs_fs_existssync_path
Зауважте, що fs.exists () застаріле, але fs.existsSync () - ні.
async/await
версія з версією util.promisify
8:
const fs = require('fs');
const { promisify } = require('util');
const stat = promisify(fs.stat);
describe('async stat', () => {
it('should not throw if file does exist', async () => {
try {
const stats = await stat(path.join('path', 'to', 'existingfile.txt'));
assert.notEqual(stats, null);
} catch (err) {
// shouldn't happen
}
});
});
describe('async stat', () => {
it('should throw if file does not exist', async () => {
try {
const stats = await stat(path.join('path', 'to', 'not', 'existingfile.txt'));
} catch (err) {
assert.notEqual(err, null);
}
});
});
Після невеликого експерименту я знайшов наступний приклад, використовуючи fs.stat
хороший спосіб асинхронно перевірити, чи існує файл. Він також перевіряє, що ваш "файл" є "дійсно є файл" (а не каталог).
Цей метод використовує Обіцянки, припускаючи, що ви працюєте з асинхронною базою кодів:
const fileExists = path => {
return new Promise((resolve, reject) => {
try {
fs.stat(path, (error, file) => {
if (!error && file.isFile()) {
return resolve(true);
}
if (error && error.code === 'ENOENT') {
return resolve(false);
}
});
} catch (err) {
reject(err);
}
});
};
Якщо файлу не існує, обіцянка все ж вирішиться, хоча false
. Якщо файл існує, і він є каталогом, то вирішується true
. Будь-які помилки, які намагаються прочитати файл, reject
означають помилку.
Ну, я зробив це так, як видно на https://nodejs.org/api/fs.html#fs_fs_access_path_mode_callback
fs.access('./settings', fs.constants.F_OK | fs.constants.R_OK | fs.constants.W_OK, function(err){
console.log(err ? 'no access or dir doesnt exist' : 'R/W ok');
if(err && err.code === 'ENOENT'){
fs.mkdir('settings');
}
});
Чи є з цим проблеми?
в старі часи, перш ніж сісти, я завжди перевіряю, чи там крісло, то я сиджу ще, у мене є альтернативний план, як сісти на тренер. Тепер сайт node.js пропонує просто перейти (не потрібно перевіряти), і відповідь виглядає приблизно так:
fs.readFile( '/foo.txt', function( err, data )
{
if(err)
{
if( err.code === 'ENOENT' )
{
console.log( 'File Doesn\'t Exist' );
return;
}
if( err.code === 'EACCES' )
{
console.log( 'No Permission' );
return;
}
console.log( 'Unknown Error' );
return;
}
console.log( data );
} );
код, узятий з http://fredkschott.com/post/2014/03/understanding-error-first-callbacks-in-node-js/ з березня 2014 року, і трохи змінений для відповідного комп'ютера. Він також перевіряє дозвіл - видаляє дозвіл на тестуванняchmod a-r foo.txt
function fileExists(path, cb){
return fs.access(path, fs.constants.F_OK,(er, result)=> cb(!err && result)) //F_OK checks if file is visible, is default does no need to be specified.
}
то документи говорять , що ви повинні використовувати в access()
якості заміни для засуджуютьсяexists()
function fileExists(path, cb){
return new Promise((accept,deny) =>
fs.access(path, fs.constants.F_OK,(er, result)=> cb(!err && result))
);
}
var fs = require('fs-extra')
await fs.pathExists(filepath)
Як бачите набагато простіше. І перевага перед перспективою полягає в тому, що у вас є повний тирінг із цим пакетом (повний інтеліссенс / машинопис)! У більшості випадків ви вже включили цю бібліотеку, оскільки від неї залежать (+ -10 000) інші бібліотеки.
Ви можете використовувати, fs.stat
щоб перевірити, чи цільовим є файл чи каталог, і ви можете fs.access
перевірити, чи можете ви писати / читати / виконувати файл. (не забудьте використати, path.resolve
щоб отримати повний шлях до цілі)
Документація:
Повний приклад (TypeScript)
import * as fs from 'fs';
import * as path from 'path';
const targetPath = path.resolve(process.argv[2]);
function statExists(checkPath): Promise<fs.Stats> {
return new Promise((resolve) => {
fs.stat(checkPath, (err, result) => {
if (err) {
return resolve(undefined);
}
return resolve(result);
});
});
}
function checkAccess(checkPath: string, mode: number = fs.constants.F_OK): Promise<boolean> {
return new Promise((resolve) => {
fs.access(checkPath, mode, (err) => {
resolve(!err);
});
});
}
(async function () {
const result = await statExists(targetPath);
const accessResult = await checkAccess(targetPath, fs.constants.F_OK);
const readResult = await checkAccess(targetPath, fs.constants.R_OK);
const writeResult = await checkAccess(targetPath, fs.constants.W_OK);
const executeResult = await checkAccess(targetPath, fs.constants.X_OK);
const allAccessResult = await checkAccess(targetPath, fs.constants.F_OK | fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
if (result) {
console.group('stat');
console.log('isFile: ', result.isFile());
console.log('isDir: ', result.isDirectory());
console.groupEnd();
}
else {
console.log('file/dir does not exist');
}
console.group('access');
console.log('access:', accessResult);
console.log('read access:', readResult);
console.log('write access:', writeResult);
console.log('execute access:', executeResult);
console.log('all (combined) access:', allAccessResult);
console.groupEnd();
process.exit(0);
}());
Для асинхронної версії! І з версією обіцянки! Ось чистий простий спосіб!
try {
await fsPromise.stat(filePath);
/**
* File exists!
*/
// do something
} catch (err) {
if (err.code = 'ENOENT') {
/**
* File not found
*/
} else {
// Another error!
}
}
Більш практичний фрагмент з мого коду для кращого ілюстрації:
try {
const filePath = path.join(FILES_DIR, fileName);
await fsPromise.stat(filePath);
/**
* File exists!
*/
const readStream = fs.createReadStream(
filePath,
{
autoClose: true,
start: 0
}
);
return {
success: true,
readStream
};
} catch (err) {
/**
* Mapped file doesn't exists
*/
if (err.code = 'ENOENT') {
return {
err: {
msg: 'Mapped file doesn\'t exists',
code: EErrorCode.MappedFileNotFound
}
};
} else {
return {
err: {
msg: 'Mapped file failed to load! File system error',
code: EErrorCode.MappedFileFileSystemError
}
};
}
}
Приклад вище - лише для демонстрації! Я міг би використати подію помилки потоку читання! Ловити будь-які помилки! І пропустіть два дзвінки!
fs.access('file', err => err ? 'does not exist' : 'exists')
, див. Fs.access