Working with JSON

What is JSON?
Java Script Object Notation, or JSON, is a lightweight data format that
has become the defacto standard for the web. JSON can be represented
as either a list of values, e.g. an Array, or a hash of properties and
values, e.g. an Object.
Array, Object
[ a, m, y ]
{ name : value }

• // a JSON array
["one", "two", "three"]
// a JSON object
{
"one": 1, // name : “Mukesh”
"two": 2,
"three": 3
}
Format of Node.js Object: JSON-
object
• Create an Object of student:
var student =
{
Name: "Amit",
Branch:"BCA",
City: "kathmandu",
Mobile: "99946730"
};

Encoding and Decoding
JavaScript provides 2 methods for encoding data structures to JSON and
encoding JSON back to JavaScript objects and arrays. They are both
available on the JSON object that is available in the global scope.
JSON.stringify takes a JavaScript object or array and returns a
serialized string in the JSON format.

const data = {
name: 'John Doe',
age: 32,
title: 'Vice President of JavaScript'
};
const jsonStr = JSON.stringify(data);
console.log(jsonStr);
// prints '{"name":"John Doe","age":32,"title":"Vice President of
JavaScript"}'

JSON.parse takes a JSON string and decodes it to a
JavaScript data structure.
const jsonStr =
'{"name":"John Doe","age":32,"title":"Vice President of JavaScript"}';
const data = JSON.parse(jsonStr);
console.log(data.title);
// prints 'Vice President of JavaScript'

What is valid JSON?
There are a few rules to remember when dealing with data in JSON
format. There are several pitfall that can produce invalid JSON as well.
• Empty objects and arrays are okay
• Strings can contain any unicode character, this includes object properties
• null is a valid JSON value on it's own
• All object properties should always be double quoted
• Object property values must be one of the following: String, Number,
Boolean, Object, Array, null
• Number values must be in decimal format, no octal or hex
representations
• Trailing commas on arrays are not allowed

These are all examples of valid JSON.
{"name":"John Doe","age":32,"title":"Vice President of JavaScript"}
["one", "two", "three"]
// nesting valid values is okay
{"names": ["John Doe", "Jane Doe"] }
[ { "name": "John Doe"}, {"name": "Jane Doe"} ]
{} // empty hash
[] // empty list
null
{ "key": "uFDD0" } // unicode escape codes

These are all examples of bad JSON formatting.
{ name: "John Doe", 'age': 32 } // name and age should be in double
quotes
[32, 64, 128, 0xFFF] // hex numbers are not allowed
{ "name": "John Doe", "age": undefined } // undefined is an invalid
value
// functions and dates are not allowed
{ "name": "John Doe",
"birthday": new Date('Fri, 26 Jan 2019 07:13:10 GMT'),
"getName": function() {
return this.name;
}}

Calling JSON.parse with an invalid JSON string will result in a
SyntaxError being thrown. If you are not sure of the validity of your
JSON data, you can anticipate errors by wrapping the call in a try/catch
block.
Notice that the only complex values allowed in JSON are objects and
arrays. Functions, dates and other types are excluded. This may not
seem to make sense at first. But remember that JSON is a data format,
not a format for transferring complex JavaScript objects along with
their functionality.

Example-1
const book = {
title : “Node.js Book",
author : "Basarat Ali Syed"
}
const bookJSON = JSON.stringify(book)
console.log(book)
console.log(bookJSON)

Example-2
const book =
{
title : "Narinder Modi",
author : "xyz"
}
console.log(book.title)
console.log(bookJSON.title)

Example-3
const book =
{
author : "xyz"
}
const bookObj = JSON.parse(bookJSON)
console.log(bookObj.title)

Example-4
const fs = require("fs")
const book = {
author : "xyz"
}
const bookObj = JSON.parse(bookJSON)
fs.writeFileSync("myjson.json",bookJSON)

Example-5
//const book = {
// title : "Narinder Modi",
// author : "xyz"
//}
//const bookJSON = JSON.stringify(book)
//console.log(book.title)
//console.log(bookJSON.title)
//const bookObj = JSON.parse(bookJSON)
const dataBuffer = fs.readFileSync("myjson.json")
//console.log(dataBuffer)
console.log(dataBuffer.toString())

Example-6
//const book = {
// author : "xyz"
//}
const dataJSON = dataBuffer.toString()
const bookObj = JSON.parse(dataJSON)
console.log(bookObj)

Example-7
//const book = {
// author : "xyz"
//}
const dataJSON = dataBuffer.toString()
const bookObj = JSON.parse(dataJSON)

How to read and write JSON file using
Node.js ?
Method 1: Using require method: The simplest method to read a JSON
file is to require it in a node.js file using require() method.
• const data = require('path/to/file/filename’);
• Example: Create a users.json file in the same directory where index.js
file present. Add following data to the JSON file.
• users.json file:

[
{
"name": "John",
"age": 21,
"language": ["JavaScript", "PHP", "Python"]
},
{
"name": "Smith",
"age": 25,
"language": ["PHP", "Go", "JavaScript"]
}
]

Now, add the following code to your index.js file.
const users = require("./users");
console.log(users);
Now, run the file using the command:
node index.js

• Method 2: Using the fs module: We can also use node.js fs module to
read a file. The fs module returns a file content in string format so we
need to convert it into JSON format by using JSON.parse() in-built
method.
• Add the following code into your index.js file:
• index.js file:

const fs = require("fs");
// Read users.json file
fs.readFile("users.json", function(err, data) {
// Check for errors
if (err) throw err;
// Converting to JSON
const users = JSON.parse(data);
console.log(users); // Print users
});

Writing to a JSON file: We can write data into a JSON file by
using the node.js fs module. We can use writeFile method to
write data into a file.
• Syntax: fs.writeFile("filename", data, callback);

Example: We will add a new user to the existing JSON file, we
have created in the previous example. This task will be
completed in three steps:
• Read the file using one of the above methods.
• Add the data using .push() method.
• Write the new data to the file using JSON.stringify() method
to convert data into string.

const fs = require("fs"); // STEP 1: Reading JSON file
const users = require("./users"); // Defining new user
let user = {
name: "New User",
age: 30,
language: ["PHP", "Go", "JavaScript"]
};
// STEP 2: Adding new data to users object
users.push(user);
// STEP 3: Writing to a file
fs.writeFile("users.json", JSON.stringify(users), err => {
// Checking for errors
if (err) throw err;
console.log("Done writing"); // Success
});

Working with JSON

More Related Content

What's hot (20)

Similar to Working with JSON (20)

More from Lovely Professional University (20)

Recently uploaded (20)

Working with JSON