Как записать данные в json файл javascript
Перейти к содержимому

Как записать данные в json файл javascript

  • автор:


Read/Write JSON Files with Node.js

When you want to store data between server restarts with Node, JSON files are a simple and convenient choice. Whether you are reading a config file or persisting data for your application, Node has some built in utilities that make it easy to read and write JSON files.

Using JSON files in your app can be a useful way to persist data. We will look at a few different methods for working with JSON files.

In this tutorial we will:

  • Read JSON data from disk
  • Learn to use fs module to interact with the filesystem
  • Persist data to a JSON file
  • Use JSON.parse and JSON.stringify to convert data to and from JSON format

By the end of this tutorial you should be able to work with JSON files using Node’s built-in fs module.

Say you have a customer.json file saved to disk that holds a record for a customer in your store.

As part of your store app, you want to access the customer’s address, and then update the order count after an order is placed.

In this tutorial, we are going to look at how to read and write to our customer.json file.

Work with files with fs

Accessing files in Node is done with the native module fs, which gives you functions to watch, read, and write files along with many other tools to work with the filesystem. Because it’s a native module, we can require it in our code without installing it. Just call const fs = require(‘fs’) .

The fs module gives us the option of synchronous or asynchronous versions of many of its functions. The synchronous versions block execution of other code until they are done accessing the filesystem, reading, or writing data. An async function will run without blocking other code. You can learn more about sync/async behavior here.

This synchronous behavior can be useful in some places, like at startup when reading a config file before any other code is run, but becomes a big issue when used in a webserver where all incoming requests would be blocked while a synchronous file read is running. For this reason, you generally want to use the async versions of fs functions in your code. We will focus on async operations, but will also show the synchronous equivalent.

To read and write files asynchronously with fs we will use fs.readFile and fs.writeFile .

We also will use the global JSON helper to convert objects to JSON strings, and JSON strings to objects.

Reading a JSON file

The simplest way to read a JSON file is to require it. Passing require() with the path to a JSON file will synchronously read and parse the data into a JavaScript object.

But reading JSON files with require has its downsides. The file will only be read once; requiring it again returns the cached data from the first time require was run. This is fine for loading static data on startup (like config data). But for reading a file that changes on disk, like our customer.json might, we need to manually read the file using the asynchronous fs.readFile .

Reading a file with fs.readFile

To access the customer’s address, we need to:

  • read the JSON data from the file
  • parse the JSON string into a JavaScript object

To load the data from customer.json file, we will use fs.readFile, passing it the path to our file, an optional encoding type, and a callback to receive the file data.

If the file is successfully read, the contents will be passed to the callback.

‘./ customer .json’ is the relative path to the the file ‘utf8’ is an optional parameter for the encoding of the file we are reading, this can be left out
(err, jsonString) => <> is the callback function that runs after the file has been read.

Now we have the contents of the file as a JSON string, but we need to turn the string into an object.

Before we can use the data from the callback in our code, we must turn it into an object. JSON.parse takes JSON data as input and returns a new JavaScript object. Otherwise, we would just have a string of data with properties we can’t access.

JSON.parse can throw exception errors and crash our program if passed an invalid JSON string. To prevent crashing we wrap JSON.parse in a try catch statement to gracefully catch any errors.

This example shows reading and parsing a JSON file:

Using the jsonString from reading customer.json, we create an object, and can access the address property. If JSON.parse throws an error, we handle it in the catch block.

Now we have an object representation of the data in our customer.json file!

We can also read the file synchronously using fs.readFileSync . Instead of taking a callback, readFileSync returns the file content after reading the file.

We can use this knowledge to create a reusable helper function to read and parse a JSON file.

Here we create a function called jsonReader that will read and parse a JSON file for us. It takes the path to the file and a callback to receive the parsed object and any errors. It will catch any errors thrown by JSON.parse for us.

Writing to a file with fs.writeFile

Writing JSON to the filesystem is similar to reading it. We will use fs.writeFile to asynchronously write data to a newCustomer.json file.

First, to write data to a JSON file, we must create a JSON string of the data with JSON.stringify . This returns a JSON string representation of a JavaScript object, which can be written to a file. Similar to parsing data into an object when reading a file, we must turn our data into a string to be able to write it to a file.

So we create a customer object with our data below, and turn it into a string.

If you try to write an object to a file without stringifying it, your file will be empty and look like this:

Once the data is stringified, we can use fs.writeFile to create a new customer file. We pass fs.writeFile the filepath, our customer data to write, and a callback that will be excecuted after the file is written. If the newCustomer.json file doesn’t already exist, it will be created; if it does exist, it will be overwritten!

Here is an example of writing a JSON file with fs.writeFile :

And that’s it! Once the callback runs, the file has been written to disk. Note: we are only passed an error object; the filedata we wrote isn’t passed to the callback.

We can also write a file synchronously in the same way using fs.writeFileSync :

After your file is finished writing, it will look something like this:

Stringifying by default puts your data all on a single line. Optionally, you can make the output file human-readable by passing the number of spaces to indent by to JSON.stringify :

Above, we told stringify to indent the data with 2 spaces.

Now your output file should look like this:

Updating JSON files

Now that we are able to read and write our customer files, we can use them as a simple kind of database. If we want to update the data in the JSON file, we can read the contents, change the data, and then write the new data back to the file:

Definitely not the most efficient database you could choose, but working with JSON files like this is a simple way to persist data in your project.

Wrapping up

JSON is one of the most common types of data you’ll work with in Node, and being able to read and write JSON files is very useful. You’ve learned how to use fs.readFile and fs.writeFile to asynchronously work with the filesystem, as well as how to parse data to and from JSON format, and catch errors from JSON.parse .

You can use require to read a JSON file at startup to synchronously parse a JSON file in one line. And now you can use a simple JSON file as a data store.

If you want to learn more, you can read up on what JSON actually is, and find out more about synchronous vs asynchronous code.


статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.

Чтение и запись файлов JSON с помощью Node.js

Одним из лучших способов обмена информацией между приложениями, написанными на разных языках, является использование формата JSON [https://en.wikipedia.org/wiki/JSON] (нотация объектов JavaScript). Благодаря единообразию и простоте JSON почти полностью заменил XML в качестве стандартного формата обмена данными в программном обеспечении, особенно в веб-сервисах. Учитывая широкое использование JSON в программных приложениях, особенно в приложениях на основе JavaScript, важно уметь читать и писать.

Время чтения: 8 мин.

Один из лучших способов обмена информацией между приложениями, написанными на разных языках, — это использование формата JSON (JavaScript Object Notation). Благодаря единообразию и простоте JSON почти полностью заменил XML в качестве стандартного формата обмена данными в программном обеспечении, особенно в веб-сервисах.

Учитывая широкое использование JSON в программных приложениях, и особенно в приложениях на основе JavaScript, важно знать, как читать и записывать данные JSON в файл в Node.js. В этой статье мы объясним, как выполнять эти функции.

Чтение файла JSON

Давайте сначала посмотрим, как мы можем прочитать уже созданный файл. Но прежде чем мы это сделаем, нам нужно создать файл. Откройте новое окно в вашем любимом текстовом редакторе и добавьте в него следующий текст:

Теперь сохраните этот файл как «student.json» в каталоге вашего проекта.

Чтобы прочитать данные JSON из файла, мы можем использовать модуль Node.js fs. В этом модуле доступны две функции, которые мы можем использовать для чтения файлов из файловой системы: readFile и readFileSync .

Хотя обе эти функции выполняют схожие задачи, например, читают файлы с диска, разница заключается в том, как эти функции выполняются на самом деле, что мы объясним более подробно в следующих разделах.

Использование fs.readFileSync

Функция readFileSync считывает данные из файла. Эта функция блокирует выполнение остальной части кода до тех пор, пока все данные не будут прочитаны из файла. Эта функция особенно полезна, когда вашему приложению необходимо загрузить параметры конфигурации, прежде чем оно сможет выполнять какие-либо другие задачи.

Чтобы продолжить наш пример, давайте воспользуемся этой функцией для чтения файла "student.json", который мы создали ранее, с readFileSync функции readFileSync. Добавьте следующий код в файл .js:

В приведенном выше коде Node.js мы сначала загружаем fs в наше приложение. Затем мы используем readFileSync и передаем ей относительный путь к файлу, который мы хотим прочитать. Если напечатать объект rawdata на консоль, вы увидите исходные данные (в буфере ) на экране консоли:

Однако мы хотим читать файл в его формате JSON, а не необработанные шестнадцатеричные данные. Здесь в JSON.parse вступает функция JSON.parse. Эта функция обрабатывает синтаксический анализ необработанных данных, преобразует их в текст ASCII и анализирует фактические данные JSON в объект JavaScript. Теперь, если вы распечатаете student на консоли, вы получите следующий вывод:

Как видите, JSON из нашего файла был успешно загружен в объект student

Использование fs.readFile

Другой способ чтения файла JSON в Node.js — использование функции readFile В отличие от функции readFileSync readFile считывает данные файла асинхронно. Когда readFile функция readFile, начинается процесс чтения файла, и сразу же управление переходит к следующей строке, выполняющей оставшиеся строки кода. После загрузки данных файла эта функция вызовет предоставленную ей функцию обратного вызова. Таким образом, вы не блокируете выполнение кода, ожидая, пока операционная система вернется к вам с данными.

В нашем примере readFile принимает два параметра: путь к файлу, который должен быть прочитан, и функцию обратного вызова, которая должна быть вызвана, когда файл будет полностью прочитан. При желании вы также можете включить параметр с параметрами, но мы не будем рассматривать их в этой статье.

Взгляните на следующий пример, чтобы понять, как использовать функцию readFile

Приведенный выше код делает то же самое, что и наш предыдущий фрагмент кода (с дополнительным console.log ), но делает это асинхронно. Вот несколько отличий, которые вы, возможно, заметили:

  • (err, data) => <> : это наша функция обратного вызова, которая выполняется после полного чтения файла.
  • err : Так как мы не можем легко использовать попробовать / поймать с асинхронным кодом, функция вместо дает нам err объект , если что — то пойдет не так. null если ошибок не было

Вы также могли заметить, что мы readFile строку в консоль сразу после вызова readFile. Это сделано для того, чтобы показать вам поведение асинхронного кода. Когда приведенный выше сценарий будет выполнен, вы увидите, что этот console.log выполняется до выполнения readFile обратного вызова readFile. Это связано с тем, что readFile не блокирует выполнение кода при чтении данных из файловой системы.

Вывод кода будет выглядеть так:

Как видите, последняя строка кода в нашем файле на самом деле является той, которая появляется первой в выводе.

Использование require

Другой подход — использовать глобальный require для чтения и анализа файлов JSON. Это тот же метод, который вы используете для загрузки модулей Node, но его также можно использовать для загрузки JSON.

Взгляните на следующий пример.

Он работает точно так же, как readFileSync мы показали выше, но это глобально доступный метод, который вы можете использовать где угодно, что имеет свои преимущества.

Однако у функции require есть несколько недостатков:

  • Require — это синхронная функция, которая вызывается только один раз, что означает, что вызовы получают кешированный результат. Если файл обновлен, вы не можете перечитать его с помощью этого метода.
  • Ваш файл должен иметь расширение .json, поэтому он не может быть таким гибким. Без правильного расширения require не обрабатывает файл как файл JSON.

Запись JSON в файл

Подобно readFile и readFileSync , есть две функции для записи данных в файлы : writeFile и writeFileSync . Как следует из названий, writeFile записывает данные в файл асинхронным способом, в то время writeFileSync функция writeFileSync записывает данные в файл синхронным образом.

Мы рассмотрим подробнее в следующих разделах.

Использование fs.writeFileSync

Функция writeFileSync принимает 2-3 параметра: путь к файлу для записи данных, данные для записи и необязательный параметр.


Обратите внимание: если файл еще не существует, для вас создается новый файл. Взгляните на следующий пример:

В приведенном выше примере мы сохраняем наш объект JSON student в файл с именем «student-2.json». Обратите внимание, что здесь мы должны использовать JSON.stringify перед сохранением данных. Точно так же, как нам нужно было проанализировать данные в формате JSON, когда мы читаем файл JSON, нам нужно «преобразовать» данные в строку, прежде чем мы сможем сохранить их в строковой форме в файле.

Выполните приведенный выше код и откройте файл student-2.json. Вы должны увидеть в файле следующее содержимое:

Хотя это данные, которые мы хотели записать, они представлены в виде одной строковой строки, которую нам трудно прочитать. Если вы хотите, чтобы сериализованный JSON был удобочитаемым человеком, измените JSON.Stringify следующим образом:

Здесь мы говорим методу добавить новые строки и пару отступов в сериализованный JSON. Теперь, если вы откроете файл "student-2.json", вы должны увидеть текст в следующем формате.

Использование fs.writeFile

Как я уже говорил ранее, writeFile функция выполняется в асинхронном режиме, что означает наш код не блокируется , а данные записываются в файл. И, как и в случае с асинхронными методами ранее, нам нужно передать обратный вызов этой функции.

Давайте напишем еще один файл, student-3.json, с writeFile функции writeFile.

Результатом вышеупомянутого скрипта будет:

И снова вы можете видеть, что последняя строка нашего кода фактически отображается первой в консоли, поскольку наш обратный вызов еще не был вызван. Это приводит к значительной экономии времени выполнения, если у вас есть большие объемы данных для записи в файл или если у вас довольно много файлов для записи.

Учить больше

Хотите узнать больше об основах Node.js? Лично я бы порекомендовал пройти онлайн-курс, например Learn Node.js от Веса Боса <.bos-link>. Вы не только изучите самый современный синтаксис ES2017, но и сможете создать полноценное ресторанное приложение. По моему опыту, создание подобных реальных приложений — самый быстрый способ учиться.


В этой статье мы показали, как вы можете читать и записывать данные JSON из файлов и в файлы, что является очень распространенной и важной задачей, которую нужно знать, как веб-программист.

fs есть несколько методов как для чтения, так и для записи в файлы JSON. Функции readFile и readFileSync будут читать данные JSON из файла асинхронно и синхронно соответственно. Вы также можете использовать глобальный require для обработки чтения / анализа данных JSON из файла в одной строке кода. Однако require является синхронным и может читать данные JSON только из файлов с расширением .json.

Точно так же функции writeFile и writeFileSync из fs записывают данные JSON в файл асинхронным и синхронным образом соответственно.

How to write data to a JSON file using Javascript

For example, I have a .JSON file that has the following:

What would be the javascript code to push another object <"nissan": "sentra", "color": "green">into this .json array to make the .json file look like

The reason I’m asking is I am finding a lot of information online on how to pull data from a .json file using AJAX but not writing new data to the .json file using AJAX to update the .json file with additional data.

Any help would be appreciated!

3 Answers 3

You have to be clear on what you mean by «JSON».

Some people use the term JSON incorrectly to refer to a plain old JavaScript object, such as [] . This one happens to be an array. If you want to add a new element to the array, just push it, as in

The word JSON may also be used to refer to a string which is encoded in JSON format:

Note the (single) quotation marks indicating that this is a string. If you have such a string that you obtained from somewhere, you need to first parse it into a JavaScript object, using JSON.parse :

Now you can manipulate the object any way you want, including push as shown above. If you then want to put it back into a JSON string, then you use JSON.stringify :

JSON is also used as a common way to format data for transmission of data to and from a server, where it can be saved (persisted). This is where ajax comes in. Ajax is used both to obtain data, often in JSON format, from a server, and/or to send data in JSON format up to to the server. If you received a response from an ajax request which is JSON format, you may need to JSON.parse it as described above. Then you can manipulate the object, put it back into JSON format with JSON.stringify , and use another ajax call to send the data to the server for storage or other manipulation.

You use the term «JSON file». Normally, the word «file» is used to refer to a physical file on some device (not a string you are dealing with in your code, or a JavaScript object). The browser has no access to physical files on your machine. It cannot read or write them. Actually, the browser does not even really have the notion of a «file». Thus, you cannot just read or write some JSON file on your local machine. If you are sending JSON to and from a server, then of course, the server might be storing the JSON as a file, but more likely the server would be constructing the JSON based on some ajax request, based on data it retrieves from a database, or decoding the JSON in some ajax request, and then storing the relevant data back into its database.

Do you really have a «JSON file», and if so, where does it exist and where did you get it from? Do you have a JSON-format string, that you need to parse, mainpulate, and turn back into a new JSON-format string? Do you need to get JSON from the server, and modify it and then send it back to the server? Or is your «JSON file» actually just a JavaScript object, that you simply need to manipulate with normal JavaScript logic?

Работа с файлами

Дмитрий Фитискин Нетология

Дмитрий Фитискин

руководитель направления «Программирование»

План занятия

Работа с js , json и node файлами.

Примерный код домашней работы по ES2015

Реально код, выполняющий какие-то действия, начинается далеко не сразу.

В чем проблема такого кода?

  • Суть решаемой задачи ускользает за деталями реализации.
  • Отдельные части кода не использовать в других проектах.
  • Файл получается слишком большой и без навигатора в нем сложно ориентироваться.

Как это исправить? Лучше всего разбить наш код на части.

Вынесем описание класса в отдельный файл

Вынесем данные

Также вынесем данные покемонов в отдельный файл pokemons.json :

Как нам теперь получить классы и данные?

Код после выноса классов и данных, естественно, не работает :

Но зато теперь тут все четко и по делу.

Создание собственных модулей

Создадим простой модуль

В файле random.js реализуем функцию генерации случайного числа:

Экспортируем нашу функцию

Для этого нужно присвоить её в module.exports

module — специальная переменная, доступная в любом модуле, которая содержит информацию о модуле: имя файла, дочерние модули, родительский модуль.

В некоторых случаях промежуточные переменные не нужны

Можно присвоить сразу в module.exports

В свойстве exports объект, который модуль экспортирует, и который будет доступен при подключении.

Использование модуля

Создадим файл index.js , который будет использовать нашу функцию генерации случайных чисел:

Сейчас этот код выдает ошибку: ReferenceError: random is not defined

Подключим модуль и определим random

Для подключения модуля используется функция require . Она принимает путь к файлу модуля и возвращает объект module.exports этого модуля.

Укажем относительный путь к модулю в require . Расширения .js , .json и .node можно опустить

Подключенный модуль можно использовать на лету

Так как require возвращает ровно то, что присвоено в module.exports

Подключаемые модули кэшируются

Сброс кеша

Есть возможность сбросить кэш:

Но это имеет смысл делать только при особой необходимости. Обычно кеширование дает больше плюсов.

Экспорт нескольких сущностей

Допустим, мы хотим создать функции фильтров для массивов в filters.js

Используем наши фильтры

Можно подключить весь модуль

А можно присвоить только нужные свойства

Избавимся от лишних переменных в нашем модуле

Сразу добавить все нужные свойства в module.exports

Чтобы сократить повторения, можно использовать exports — ссылка на module.exports

Присвоение в exports не даст нужного результата

Так как это просто ссылка на module.exports

Связь module.exports и exports

Хорошо показана в этом псевдокоде:

Переменные, объявленные в модуле, не доступны при подключении

Создадим файл private.js :

Не экспортированные переменные становятся «приватными»:

Подключаем модуль, который ничего не экспортирует

Наше приложение app.js :

Ошибок не выдается. Сама функция require вернет пустой объект <> . Но код модуля выполнится.

process — еще один глобальный объект, содержит информацию о текущем запущенном процессе. process.argv — аргументы этого процесса.

Подключение JSON-файлов

Создадим файл number-list.json :

И используем эти данные в нашем коде с фильтрами:

При подключении .json файла создается JavaScript-объект, содержащий данные из файла. Преобразовывать ничего не нужно.

Итого про require

  • Для подключения собственного модуля require и путь к файлу модуля.
  • Расширения файла .js , .json и .node можно опускать.
  • Подключенный модуль можно использовать на лету или получить из него только нужные свойства и методы.
  • Можно подключать модули, которые ничего не экспортируют. Получим пустой объект. Но код модуля выполнится. Иногда это все, что нам нужно.

Итого про module.exports

  • Для экспорта присвойте нужную сущность в module.exports .
  • Для задания свойств можно использовать ссылку exports .
  • Подключенные модули кешируются.
  • Переменные, объявленные внутри модуля, недоступны за его пределами. Доступно только то, что присвоено в module.exports .

Системные модули

Для подключения тоже используем require

Главное отличие: в require мы передаем не путь, а название системного модуля.

Например, весь функционал взаимодействия с файловой системой реализован в модуле fs , и чтобы его использовать, нам нужно его подключить.

Мы можем присвоить модуль в любую переменную

Функция require по сути возвращает то, что является модулем. Это не обязательно объект. И мы присваиваем результат в переменную, или можем его тут же использовать:

Асинхронные функции

Асинхронные функции — основа Node.js

  • Такая функция выполняется сразу.
  • Но для получения результата требуется какое-то время.
  • Поэтому после выполнения функции результат еще не доступен.
  • Поэтому в такую функцию мы передаем нашу функцию, которая обычно называется функцией обратного вызова, или колбэком.
  • Когда результат будет готов, система вызовет наш колбэк, и передаст в него результат.

Пример асинхронной функции — setTimeout

Имитируем длительное получение данных с помощью setTimeout

Разберем получившийся пример

  • getData не возвращает данные, потому что иначе код подвис на полторы секунды.
  • Когда данные «готовы», вызывается переданная функция callback .
  • Стандартный паттерн организации асинхронного кода с функциями обратного вызова: первым аргументом передается ошибка, а остальные — уже данные. Если ошибок нет, передаётся null или false .
  • Мы не можем обработать числа сразу. Нам нужно дождаться их получения.
  • Поэтому весь наш код в колбэке.

Паттерн «ошибка + результат»

Исход длительной операции — ошибка

Любой длительный процесс может завершиться либо с ошибкой, либо успешно. В случае, когда ожидание завершилось ошибкой, нам нужно передать информацию об ошибке:

Исход длительной операции — успех

В случае, когда ожидание завершилось успешно, нам нужно передать данные:

Аргументы функции обратного вызова

Для того, чтобы передача информации о состоянии и результат длительной операции были однообразны, используют такой подход:

  • Первым аргументом передают информацию об ошибке либо null , если ошибки нет.
  • Вторым и последующими аргументами передают результат. Который имеет смысл, если ошибки не случилось.

Поэтому, при таком подходе легко реализовать код функции обратного вызова, просто понимая, что мы ждем массив чисел:

Работа с файлами

Метод readFile асинхронный

Это означает, что система не будет ожидать завершения операции и продолжит работу.

Результат выполнения примера кода

Как видите, сообщение о том, что файл прочитан, вывелось до того, как вывелось содержимое файла. По сути, асинхронные вызовы работают как setTimeout , только колбэк вызывается не через определенное время, а после завершения операции.

Метод readFile асинхронный

Поэтому, если мы хотим выполнить какое-то действие после выполнения асинхронной функции, то это действие нужно делать в функции обратного вызова.

Получаем список файлов в папке

Проверим права на запись в файле

  1. fs.constants.F_OK — есть доступ на чтение/запись/исполнение
  2. fs.constants.R_OK — есть доступ на чтение
  3. fs.constants.W_OK — есть доступ на запись
  4. fs.constants.X_OK — есть доступ на исполнение

Записываем данные в файл

Создаем папку

Переименуем файл

Аналогично можно переименовать или переместить файл или папку.

Допишем данные в файл

Последовательность асинхронных вызовов

Параллельное выполнение независимых операций

Нет никакой гарантии, что файлы будут созданы в том порядке, как был вызван метод writeFile

Последовательное выполнение зависимых операций

Что, если нам сначала нужно создать папку, а потом создать файл в ней?

Если мы просто последовательно вызовем mkdir и writeFile , нет никаких гарантий, что файл создастся после того, как будет создана папка. Он может быть создан и раньше. И это приведет к ошибке.

Выполнять зависимое действие нужно в колбеке

А это приводит к огромной вложенности функций обратного вызова. И абсолютно нечитаемому коду.


Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *