Node js удалить файл
Для работы с файлами в Node.js предназначен модуль fs . Рассмотрим, как с ним работать.
Чтение из файла¶
Допустим, в одной папке с файлом приложения app.js расположен текстовый файл hello.txt с простейшим текстом, например:
Для чтения файла в синхронном варианте применяется функция fs.readFileSync() :
В метод передается путь к файлу относительно файла приложения app.js , а в качестве второго параметра указывается кодировка для получения текстового содержимого файла. На выходе получаем считанный текст.
Для асинхронного чтения файла применяется функция fs.readFile :
Первый и второй параметр функции опять же соответственно путь к файлу и кодировка. А в качестве третьего параметра передается функция обратного вызова, которая выполняется после завершения чтения. Первый параметр этой функции хранит информацию об ошибке при наличии, а второй - собственно считанные данные.
Для чтения файла определим в файле app.js следующий код:
И здесь стоит обратить внимание, что несмотря на то, что функция fs.readFile() вызывается первой, но так как она асинхронная, она не блокирует поток выполнения, поэтому ее результат выводится в самом конце.
Запись файла¶
Для записи файла в синхронном варианте используется функция fs.writeFileSync() , которая в качестве параметра принимает путь к файлу и записываемые данные:
Также для записи файла можно использовать асинхронную функцию fs.writeFile() , которая принимает те же параметры:
В качестве вспомогательного параметра в функцию может передаваться функция обратного вызова, которая выполняется после завершения записи:
Следует отметить, что эти методы полностью перезаписывают файл. Если надо дозаписать файл, то применяются методы fs.appendFile() / fs.appendFileSync() :
Удаление файла¶
Для удаления файла в синхронном варианте используется функция fs.unlinkSync() , которая в качестве параметра принимает путь к удаляемому файлу:
Также для удаления файла можно использовать асинхронную функцию fs.unlink() , которая принимает путь к файлу и функцию, вызываемую при завершении удаления:
You can call fs.unlink(path, callback) for Asynchronous unlink(2) or fs.unlinkSync(path) for Synchronous unlink(2).
Where path is file-path which you want to remove.
For example we want to remove discovery.docx file from c:/book directory. So my file-path is c:/book/discovery.docx . So code for removing that file will be,
If you want to check file before delete whether it exist or not. So, use fs.stat or fs.statSync (Synchronous) instead of fs.exists . Because according to the latest node.js documentation, fs.exists now deprecated.
What if I check it exists, but it's blocked by another process - or, I check it exists, and it's fine, but then another process randomly blocks it before I'm able to delete. How can I block straight after checking? then wouldnt I not be able to delete as its blocked
There's a reason it's deprecated: often times you creates a race condition if you check that a file exists before deleting it. Instead, you should only call fs.unlink , and if the file doesn't exist, you'll have an ENOENT error in the callback. No need to check before trying to unlink.
@ZachB why delete operation fs.unlink perform when file not existed, so my view is that check file before remove.
You shouldn't check if it exists if there are multiple threads or processes that might be using or trying to delete the same file, in which case your check that the file exists will become invalid between the time you check that it exists and the time you try to delete it. Just check for the ENOENT error code in the unlink callback. If that error occurred, the file didn't exist. Look at Searene's answer for example.
I don't think you have to check if file exists or not, fs.unlink will check it for you.
Here is a small snippet of I made for this purpose,
What if the file gets deleted by others after you check with fs.exists and before you remove it with fs.unlink ? It could happen.
You should not check if a file exists before attempting to unlink it. Just call unlink , and if it doesn't exist, handle the ENOENT error. Otherwise you can create a race condition.
2019 and Node 10+ is here. Below the version using sweet async/await way.
Now no need to wrap fs.unlink into Promises nor to use additional packages (like fs-extra ) anymore.
Here is fsPromises.unlink spec from Node docs.
Also please note that fs.promises API marked as experimental in Node 10.x.x (but works totally fine, though), and no longer experimental since 11.14.0 .
2020 Answer
With the release of node v14.14.0 you can now do.
As the accepted answer, use fs.unlink to delete files.
Using fs.stat() to check for the existence of a file before calling fs.open() , fs.readFile() or fs.writeFile() is not recommended. Instead, user code should open/read/write the file directly and handle the error raised if the file is not available.
To check if a file exists without manipulating it afterwards, fs.access() is recommended.
to check files can be deleted or not, Use fs.access instead
This is a good answer, with a Node.js reference. most people will use unlink directly because they know they have rights to delete the file. But fs.access is a good alternative if they need to check before deletion. But I think if they need to check if a file exists without manipulating it afterwards, they should naturally use fs.stat , fs.access has a different purpose in my humble opinion.
the reason why the documentation recommends against checking for existance is because that information can change between your call to fs.stat/fs.access and the actual operation. For example the file could exist when you call fs.access and then be deleted before you call fs.unlink, or the permissions could change between the two calls. Since you have to handle the error codes of fs.unlink in that case anyways there's no point in calling fs.stat or fs.access.
This is not an answer to the question that was being asked, which is specifically about how to remove the file. (As opposed to, how to know whether you have rights to remove it.)
Для работы с файлами в Node.js используется встроенный модуль fs , который выполняет все синхронные и асинхронные операции ввода/вывода применительно к файлам. Чтение и запись файла могут осуществляться одним из двумя способов:
- с использованием Buffer ;
- через создание соответствующего потока.
Чтение файлов и директорий¶
Для чтения файла в асинхронном режиме используется метод Node.js readFile() , который принимает три параметра:
- путь к файлу;
- кодировка;
- callback-функция, вызываемая после получения содержимого файла.
Callback-функции передается два аргумента: ошибка и полученные данные в строковом формате. Если операция прошла успешна, то в качестве ошибки передается null .
Если в readFile() не указать кодировку, то данные файла будут возвращены в формате Buffer .
Поскольку метод выполняется асинхронно, то не происходит блокировки главного процесса Node.js. Но в некоторых случаях может понадобиться синхронное чтение файла, для этого есть метод readFileSync() , но при этом выполнение главного процесса будет заблокировано до тех пор, пока полностью не будет загружено содержимое файла.
Node.js readFileSync() возвращает результат чтения файла и принимает два параметра:
Обработка и перехват ошибок при использовании readFileSync() осуществляется с помощью конструкции try<. >catch() <. >.
Чтобы инициировать ошибку, укажите неправильный путь к файлу.
Методы readFile() и readFileSync() для работы с файлами используют Buffer . Но есть и другой способ считать содержимое файла: создать поток с помощью Node.js fs.createReadStream() . Любой поток в Node.js является экземпляром класса EventEmitter , который позволяет обрабатывать возникающие в потоке события.
Параметры, принимаемые fs.createReadStream() :
- путь к файлу;
- объект со следующими настройками:
- encoding - кодировка (по умолчанию utf8 );
- mode - режим доступа (по умолчанию 0o666 );
- autoClose - если true , то при событиях error и finish поток закроется автоматически (по умолчанию true ).
Вместо объекта настроек можно передать строку, которая будет задавать кодировку.
Использование потока имеет ряд преимуществ перед Buffer :
Для чтения директорий используются методы readdir() и readdirSync() , для асинхронного и синхронного режимов соответственно.
Node.js readdir() работает асинхронно и принимает три аргумента:
- путь к директории;
- кодировку;
- callback-функцию, которая принимает аргументами ошибку и массив файлов директории (при успешном выполнении операции ошибка передается как null ).
Node.js readdirSync() работает синхронно, возвращает массив найденных файлов и принимает два параметра:
Создание и запись файлов и директорий¶
В Node.js файлы могут быть записаны также синхронно и асинхронно. Для асинхронной записи имеется метод writeFile() , принимающий следующие аргументы:
- путь к файлу;
- данные для записи;
- параметры записи:
- кодировка (по умолчанию utf8 );
- права доступа (по умолчанию 0o666 );
- callback-функция, которая вызывается по завершению операции и единственным аргументом принимает ошибку (в случае успешной записи передается null ).
Если нет необходимости указывать параметры записи, то третьим параметром Node.js writeFile() можно сразу передать callback-функцию.
Для синхронной записи Node.js файла используйте writeFileSync() . Метод принимает все те же аргументы, что и writeFile() за исключением callback-функции. В качестве значения возвращает undefined .
Как и в случае с readFileSync() обработка ошибок происходит с помощью try<. >catch() <. >.
Методы writeFile() и writeFileSync() перезаписывают уже имеющуюся в файле информацию новыми данными. Если вам нужно внести новые данные без удаления старых, используйте методы appendFIle() и appendFileAsync() , которые имеют идентичные параметры.
Для записи файла через потока ввода имеется метод fs.createWriteStream() , который возвращает поток ввода и принимает два параметра:
- путь к файлу;
- объект со следующими настройками:
- encoding - кодировка (по умолчанию utf8 );
- mode - режим доступа (по умолчанию 0o666 );
- autoClose - если true , то при событиях error и finish поток закроется автоматически (по умолчанию true ).
Чтобы создать директорию, используйте методы mkdir() и mkdirSync() .
Node.js mkdir() работает асинхронно и принимает в качестве параметров:
- путь к директории;
- объект со следующими настройками:
- recursive - если true , создает директорию и все ее родительские директории согласно указанному пути, если они еще не существуют (по умолчанию false , т. е. все родительские директории уже должны быть созданы, иначе будет сгенерирована ошибка);
- mode - режим доступа, параметр не поддерживается на ОС Windows (по умолчанию 0o777 );
- callback-функцию, которая единственным аргументом принимает ошибку, при успешном создании директории передается null .
Вторым параметром можно сразу передать callback-функцию.
Node.js mkdirSync() создает директорию синхронно и возвращает undefined . Обработка ошибок осуществляется через try<. >catch() <. >. Метод mkdirSync() принимает те же параметры, что и mkdir() , за исключением callback-функции.
Удаление файлов и директорий¶
Чтобы удалить в Node.js файлы используйте методы unlink() и unlinkSync() .
Метод unlink() асинхронный и принимает имя файла, который нужно удалить, и callback-функцию с ошибкой в качестве параметра ( null , если удаление прошло успешно).
Для синхронного удаления файла используйте unlinkSync() , которому единственным аргументом передается имя файла.
Для удаления директорий имеются методы rmdir() и rmdirSync() соответственно. Они полностью идентичны unlink() и unlinkSync() , только вместо имени файла принимают имя директории.
existsSync()¶
Проверка наличия в Node.js файла или директории происходит с помощью метода existsSync() , который принимает путь к файлу или директории и возвращает либо true , либо false . Как вы понимаете, Node.Js existsSync() работает в синхронном режиме.
Раньше был и Node.js exists() , но сейчас он уже официально устарел и не поддерживается.
Сегодня мы поговорим о том, как работать с файловой системой средствами Node.js, рассмотрим базовые операции, выполняемые с файлами. К таким операциям относятся следующие:
- Создание файла
- Чтение файла
- Запись данных в файл
- Удаление файла
- Переименование файла
Модуль fs
В Node.js имеется стандартный модуль, fs (сокращение от File System), дающий разработчику средства для работы с файловой системой. Импортировать его в проект можно так:
Методы этого модуля представлены в синхронной и асинхронной формах. Функции обратного вызова, передаваемые асинхронным методам, принимают в качестве первого параметра объект ошибки, а в качестве второго — данные, возвращённые при успешном выполнении операции. Рассмотрим пример:
Метод .readFile() , о котором мы ещё поговорим, предназначен для чтения файлов. В этом примере у функции обратного вызова есть два параметра — err и data . В первый параметр попадают ошибки, которые могут возникнуть при попытке чтения файла, во втором оказываются данные, полученные после успешного выполнения операции. Обратите внимание на то, что .readFile() — это асинхронный метод модуля fs . Его синхронная версия называется .readFileSync() . Похожий подход используется и для именования других методов модуля.
Создание нового файла
Начнём с примера:
Здесь метод fs.open() используется для создания нового файла. В качестве первого аргумента он принимает имя файла. Его второй аргумент представляет собой флаг, указывающий системе на то, что именно мы хотим сделать с файлом. В данном случае это флаг w (сокращение от writing), который указывает на то, что мы хотим открыть файл для записи. Метод .open() может принимать различные флаги. Вот некоторые из них:
- r : открыть файл для чтения
- r+ : открыть файл для чтения и записи
- rs : открыть файл для чтения в синхронном режиме
- w : открыть файл для записи
- a : открыть файл для записи данных в конец файла
- a+ : открыть файл для чтения и для записи данных в конец файла
Запись данных в файл
Поговорим о том, как дописать что-нибудь в файл:
Здесь мы используем метод .appendFile() для добавления данных в конец существующего файла. В качестве первого аргумента этот метод принимает имя файла, в качестве второго — данные, которые нужно добавить в конец файла. Третий аргумент — это, как обычно, функция обратного вызова.
После того, как код, показанный выше, успешно отработает, содержимое файла будет выглядеть так:
Существует и другой способ записи данных в файл. Он подразумевает использование метода .writeFile() . Этот метод очень похож на .appendFile() , но у него есть одно важное отличие. Дело в том, что с помощью метода .appendFile() мы добавляем в файл новые данные после тех данных, которые в нём уже есть. А при использовании метода .writeFile() содержимое файла заменяется на новое. Испытаем этот метод:
После успешного выполнения операции в файле окажется следующий текст:
Как видно, содержимое файла полностью заменено новым.
Чтение файла
Для чтения файлов модуль fs предоставляет метод .readFile() , пример использования которого мы уже видели. В качестве первого параметра он принимает имя файла, в качестве второго — кодировку. Третий параметр — функция обратного вызова. Попытаемся вывести в консоль содержимое файла testFile.txt с помощью этого метода:
Вот что у нас получится.
Данные файла, выведенные в консоль
Теперь поговорим о переименовании файлов.
Переименование файла
Для переименования файлов используется метод .rename() :
Первый аргумент метода представляет собой имя существующего файла, второй — новое имя этого файла. После успешного вызова этого метода файл testFile.txt превращается в newTestFile.txt .
Удаление файла
Для удаления файлов используется метод .unlink() :
Успешный вызов этого метода приводит к удалению файла newTestFile.txt .
Итоги
В этом материале мы рассмотрели основы работы с файловой системой в среде Node.js. Если вы хотите более глубоко освоить эту тему — взгляните на этот материал из цикла публикаций по Node.js, почитайте документацию по модулю fs и постарайтесь испробовать на практике всё, о чём узнаете.
Сегодня, в девятой части перевода руководства по Node.js, мы поговорим о работе с файлами. В частности, речь пойдёт о модулях fs и path — о файловых дескрипторах, о путях к файлам, о получении информации о файлах, об их чтении и записи, о работе с директориями.
Работа с файловыми дескрипторами в Node.js
Прежде чем вы сможете взаимодействовать с файлами, находящимися в файловой системе вашего сервера, вам необходимо получить дескриптор файла.
Дескриптор можно получить, воспользовавшись для открытия файла асинхронным методом open() из модуля fs :
Обратите внимание на второй параметр, r , использованный при вызове метода fs.open() . Это — флаг, который сообщает системе о том, что файл открывают для чтения. Вот ещё некоторые флаги, которые часто используются при работе с этим и некоторыми другими методами:
- r+ — открыть файл для чтения и для записи.
- w+ — открыть файл для чтения и для записи, установив указатель потока в начало файла. Если файл не существует — он создаётся.
- a — открыть файл для записи, установив указатель потока в конец файла. Если файл не существует — он создаётся.
- a+ — открыть файл для чтения и записи, установив указатель потока в конец файла. Если файл не существует — он создаётся.
После получения дескриптора любым из вышеописанных способов вы можете производить с ним необходимые операции.
Данные о файлах
С каждым файлом связан набор данных о нём, исследовать эти данные можно средствами Node.js. В частности, сделать это можно, используя метод stat() из модуля fs .
Вызывают этот метод, передавая ему путь к файлу, и, после того, как Node.js получит необходимые сведения о файле, он вызовет коллбэк, переданный методу stat() . Вот как это выглядит:
В Node.js имеется возможность синхронного получения сведений о файлах. При таком подходе главный поток блокируется до получения свойств файла:
Информация о файле попадёт в константу stats . Что это за информация? На самом деле, соответствующий объект предоставляет нам большое количество полезных свойств и методов:
- Методы .isFile() и .isDirectory() позволяют, соответственно, узнать, является ли исследуемый файл обычным файлом или директорией.
- Метод .isSymbolicLink() позволяет узнать, является ли файл символической ссылкой.
- Размер файла можно узнать, воспользовавшись свойством .size .
Пути к файлам в Node.js и модуль path
Путь к файлу — это адрес того места в файловой системе, где он расположен.
В Linux и macOS путь может выглядеть так:
В Windows пути выглядят немного иначе:
На различия в форматах записи путей при использовании разных операционных систем следует обращать внимание, учитывая операционную систему, используемую для развёртывания Node.js-сервера.
В Node.js есть стандартный модуль path , предназначенный для работы с путями к файлам. Перед использованием этого модуля в программе его надо подключить:
▍Получение информации о пути к файлу
Если у вас есть путь к файлу, то, используя возможности модуля path , вы можете, в удобном для восприятия и дальнейшей обработки виде, узнать подробности об этом пути. Выглядит это так:
Здесь, в строке notes , хранится путь к файлу. Для разбора пути использованы следующие методы модуля path :
- dirname() — возвращает родительскую директорию файла.
- basename() — возвращает имя файла.
- extname() — возвращает расширение файла.
▍Работа с путями к файлам
Несколько частей пути можно объединить, используя метод path.join() :
Найти абсолютный путь к файлу на основе относительного пути к нему можно с использованием метода path.resolve() :
В данном случае Node.js просто добавляет /flavio.txt к пути, ведущем к текущей рабочей директории. Если при вызове этого метода передать ещё один параметр, представляющий путь к папке, метод использует его в качестве базы для определения абсолютного пути:
Если путь, переданный в качестве первого параметра, начинается с косой черты — это означает, что он представляет собой абсолютный путь.
Вот ещё один полезный метод — path.normalize() . Он позволяет найти реальный путь к файлу, используя путь, в котором содержатся спецификаторы относительного пути вроде точки ( . ), двух точек ( .. ), или двух косых черт:
Методы resolve() и normalize() не проверяют существование директории. Они просто находят путь, основываясь на переданным им данным.
Чтение файлов в Node.js
Самый простой способ чтения файлов в Node.js заключается в использовании метода fs.readFile() с передачей ему пути к файлу и коллбэка, который будет вызван с передачей ему данных файла (или объекта ошибки):
Если надо, можно воспользоваться синхронной версией этого метода — fs.readFileSync() :
По умолчанию при чтении файлов используется кодировка utf8 , но кодировку можно задать и самостоятельно, передав методу соответствующий параметр.
Методы fs.readFile() и fs.readFileSync() считывают в память всё содержимое файла. Это означает, что работа с большими файлами с применением этих методов серьёзно отразится на потреблении памяти вашим приложением и окажет влияние на его производительность. Если с такими файлами нужно работать, лучше всего воспользоваться потоками.
Запись файлов в Node.js
В Node.js легче всего записывать файлы с использованием метода fs.writeFile() :
Есть и синхронная версия того же метода — fs.writeFileSync() :
Эти методы, по умолчанию, заменяют содержимое существующих файлов. Изменить их стандартное поведение можно, воспользовавшись соответствующим флагом:
Тут могут использоваться флаги, которые мы уже перечисляли в разделе, посвящённом дескрипторам. Подробности о флагах можно узнать здесь.
Присоединение данных к файлу
Метод fs.appendFile() (и его синхронную версию — fs.appendFileSync() ) удобно использовать для присоединения данных к концу файла:
Об использовании потоков
Выше мы описывали методы, которые, выполняя запись в файл, пишут в него весь объём переданных им данных, после чего, если используются их синхронные версии, возвращают управление программе, а если применяются асинхронные версии — вызывают коллбэки. Если вас такое состояние дел не устраивает — лучше будет воспользоваться потоками.
Работа с директориями в Node.js
Модуль fs предоставляет в распоряжение разработчика много удобных методов, которые можно использовать для работы с директориями.
▍Проверка существования папки
Для того чтобы проверить, существует ли директория и может ли Node.js получить к ней доступ, учитывая разрешения, можно использовать метод fs.access() .
▍Создание новой папки
Для того чтобы создавать новые папки, можно воспользоваться методами fs.mkdir() и fs.mkdirSync() :
▍Чтение содержимого папки
Для того чтобы прочесть содержимое папки, можно воспользоваться методами fs.readdir() и fs.readdirSync() . В этом примере осуществляется чтение содержимого папки — то есть — сведений о том, какие файлы и поддиректории в ней имеются, и возврат их относительных путей:
Вот так можно получить полный путь к файлу:
Результаты можно отфильтровать для того, чтобы получить только файлы и исключить из вывода директории:
▍Переименование папки
Для переименования папки можно воспользоваться методами fs.rename() и fs.renameSync() . Первый параметр — это текущий путь к папке, второй — новый:
Переименовать папку можно и с помощью синхронного метода fs.renameSync() :
▍Удаление папки
Для того чтобы удалить папку, можно воспользоваться методами fs.rmdir() или fs.rmdirSync() . Надо отметить, что удаление папки, в которой что-то есть, задача несколько более сложная, чем удаление пустой папки. Если вам нужно удалять такие папки, воспользуйтесь пакетом fs-extra, который весьма популярен и хорошо поддерживается. Он представляет собой замену модуля fs , расширяющую его возможности.
Метод remove() из пакета fs-extra умеет удалять папки, в которых уже что-то есть.
Установить этот модуль можно так:
Вот пример его использования:
Его методами можно пользоваться в виде промисов:
Допустимо и применение конструкции async/await:
Модуль fs
Выше мы уже сталкивались с некоторыми методами модуля fs , применяемыми при работе с файловой системой. На самом деле, он содержит ещё много полезного. Напомним, что он не нуждается в установке, для того, чтобы воспользоваться им в программе, его достаточно подключить:
После этого у вас будет доступ к его методам, среди которых отметим следующие, некоторые из которых вам уже знакомы:
- fs.rename()
- fs.renameSync()
- fs.write()
- fs.writeSync()
В Node.js 10 имеется экспериментальная поддержка этих API, основанных на промисах.
Исследуем метод fs.rename() . Вот асинхронная версия этого метода, использующая коллбэки:
При использовании его синхронной версии для обработки ошибок используется конструкция try/catch :
Основное различие между этими вариантами использования данного метода заключается в том, что во втором случае выполнение скрипта будет заблокировано до завершения файловой операции.
Модуль path
Модуль path, о некоторых возможностях которого мы тоже уже говорили, содержит множество полезных инструментов, позволяющих взаимодействовать с файловой системой. Как уже было сказано, устанавливать его не нужно, так как он является частью Node.js. Для того чтобы пользоваться им, его достаточно подключить:
Свойство path.sep этого модуля предоставляет символ, использующийся для разделения сегментов пути ( \ в Windows и / в Linux и macOS), а свойство path.delimiter даёт символ, используемый для отделения друг от друга нескольких путей ( ; в Windows и : в Linux и macOS).
Рассмотрим и проиллюстрируем примерами некоторые методы модуля path .
▍path.basename()
Возвращает последний фрагмент пути. Передав второй параметр этому методу можно убрать расширение файла.
▍path.dirname()
Возвращает ту часть пути, которая представляет имя директории:
▍path.extname()
Возвращает ту часть пути, которая представляет расширение файла:
▍path.isAbsolute()
Возвращает истинное значение если путь является абсолютным:
▍path.join()
Соединяет несколько частей пути:
▍path.normalize()
Пытается выяснить реальный путь на основе пути, который содержит символы, использующиеся при построении относительных путей вроде . , .. и // :
▍path.parse()
Преобразует путь в объект, свойства которого представляют отдельные части пути:
- root : корневая директория.
- dir : путь к файлу, начиная от корневой директории
- base : имя файла и расширение.
- name : имя файла.
- ext : расширение файла.
В результате его работы получается такой объект:
▍path.relative()
Принимает, в качестве аргументов, 2 пути. Возвращает относительный путь из первого пути ко второму, основываясь на текущей рабочей директории:
▍path.resolve()
Находит абсолютный путь на основе переданного ему относительного пути:
Итоги
Читайте также: