Node.js භාවිතයෙන් මම JSON විග්‍රහ කළ යුත්තේ කෙසේද? JSON ආරක්ෂිතව වලංගු කර විග්‍රහ කරන මොඩියුලයක් තිබේද?

ඔබට සරලව භාවිතා කළ හැකිය JSON.parse .

JSONවස්තුවෙහි අර්ථ දැක්වීම ECMAScript 5 පිරිවිතරයේ කොටසකි . node.js ගූගල් ක්‍රෝම් හි V8 එන්ජිම මත ගොඩනගා ඇති අතර එය ECMA ප්‍රමිතියට අනුකූල වේ. එබැවින් node.js හි ගෝලීය වස්තුවක් ද ඇත ^[docs]JSON .

සටහන - JSON.parseවත්මන් නූල් ගැටගැසීමට හැකි වන්නේ එය සමමුහුර්ත ක්‍රමයක් වන බැවිනි. එබැවින් ඔබ විශාල JSON වස්තු විග්‍රහ කිරීමට අදහස් කරන්නේ නම් ප්‍රවාහය json විග්‍රහකයක් භාවිතා කරන්න.

ඔබට .json ගොනු අවශ්‍ය විය හැකිය.

var parsedJSON = require('./file-name');

උදාහරණයක් config.jsonලෙස ඔබේ මූලාශ්‍ර කේත ගොනුවට සමාන නාමාවලියක ගොනුවක් තිබේ නම්:

var config = require('./config.json');

හෝ (ගොනු දිගුව මඟ හැරිය හැක):

var config = require('./config');

බවයි සටහන් requireවන්නේ සමමුහුර්ත සහ එකම ගොනුව කියවන වරක් , පහත සඳහන් ඇමතුම් හැඹිලි සිට ප්රතිඵලයක් ආපසු

තවද මෙය ඔබ භාවිතා කළ යුත්තේ ඔබේ නිරපේක්ෂ පාලනය යටතේ ඇති දේශීය ගොනු සඳහා පමණි, මන්ද එය ගොනුව තුළ ඇති ඕනෑම කේතයක් ක්‍රියාත්මක කළ හැකි බැවිනි.

ඔයාට පාවිච්චි කරන්න පුළුවන් JSON.parse() .

JSONඕනෑම ECMAScript 5 අනුකූල JavaScript ක්‍රියාත්මක කිරීමේදී ඔබට වස්තුව භාවිතා කළ හැකිය . හා V8 Node.js ගොඩනැගිය හැකි, ඔවුන්ගෙන් එක් කෙනෙක් ය.

සටහන: සංවේදී තොරතුරු (උදා: මුරපද) ගබඩා කිරීම සඳහා ඔබ JSON ගොනුවක් භාවිතා කරන්නේ නම්, එය කිරීම වැරදි ක්‍රමයයි. හෙරොකු එය කරන්නේ කෙසේදැයි බලන්න: https://devcenter.heroku.com/articles/config-vars#setting-up-config-vars-for-a-deployed-application . ඔබේ වේදිකාව එය කරන්නේ කෙසේදැයි process.envසොයා ගෙන කේතය තුළ සිට වින්‍යාස විචල්‍යයන් ලබා ගැනීමට භාවිතා කරන්න.

JSON දත්ත අඩංගු නූලක් විග්‍රහ කිරීම

var str = '{ "name": "John Doe", "age": 42 }';
var obj = JSON.parse(str);

JSON දත්ත අඩංගු ගොනුවක් විග්‍රහ කිරීම

ඔබට fsමොඩියුලය සමඟ සමහර ගොනු මෙහෙයුම් කිරීමට සිදුවේ .

අසමමුහුර්ත අනුවාදය

var fs = require('fs');

fs.readFile('/path/to/file.json', 'utf8', function (err, data) {
    if (err) throw err; // we'll not consider error handling for now
    var obj = JSON.parse(data);
});

සමමුහුර්ත අනුවාදය

var fs = require('fs');
var json = JSON.parse(fs.readFileSync('/path/to/file.json', 'utf8'));

ඔබට භාවිතා කිරීමට requireඅවශ්‍යද? නැවත සිතන්න!

ඔබට සමහර විට භාවිතා කළ හැකියrequire :

var obj = require('path/to/file.json');

නමුත්, හේතු කිහිපයක් නිසා මම මෙය නිර්දේශ නොකරමි:

1. requireසමමුහුර්ත වේ. ඔබ සතුව ඉතා විශාල JSON ගොනුවක් තිබේ නම්, එය ඔබගේ සිදුවීම් ලූපය යටපත් කරනු ඇත. ඔබ සැබවින්ම භාවිතා JSON.parseකළ යුතුයfs.readFile යුතුය.
2. requireගොනුව කියවන්නේ එක් වරක් පමණි . පසුව requireඑකම ගොනුවක් සඳහා වන ඇමතුම් හැඹිලි පිටපතක් ලබා දෙනු ඇත. .jsonඅඛණ්ඩව යාවත්කාලීන වන ගොනුවක් කියවීමට ඔබට අවශ්‍ය නම් හොඳ අදහසක් නොවේ . ඔබට හැක් එකක් භාවිතා කළ හැකිය . නමුත් මෙම අවස්ථාවේදී, සරලව භාවිතා කිරීම පහසුයfs .
3. ඔබේ ගොනුවට .jsonදිගුවක් requireනොමැති නම්, ගොනුවේ අන්තර්ගතය JSON ලෙස සලකන්නේ නැත.

බරපතල ලෙස! භාවිතා කරන්නJSON.parse .

load-json-file මොඩියුලය

ඔබ .jsonලිපිගොනු විශාල ප්‍රමාණයක් කියවන්නේ නම් , (සහ ඔබ අතිශයින් කම්මැලි නම්), සෑම විටම බොයිලර් ප්ලේට් කේතය ලිවීම කරදරයක් බවට පත්වේ. load-json-fileමොඩියුලය භාවිතා කිරීමෙන් ඔබට සමහර අක්ෂර සුරැකිය හැක .

const loadJsonFile = require('load-json-file');

අසමමුහුර්ත අනුවාදය

loadJsonFile('/path/to/file.json').then(json => {
    // `json` contains the parsed object
});

සමමුහුර්ත අනුවාදය

let obj = loadJsonFile.sync('/path/to/file.json');

ධාරාවන්ගෙන් JSON විග්‍රහ කිරීම

JSON අන්තර්ගතය ජාලය හරහා ප්‍රවාහනය කරන්නේ නම්, ඔබ ප්‍රවාහය කරන JSON විග්‍රහකය භාවිතා කළ යුතුය. එසේ නොවුවහොත් එය ඔබගේ ප්‍රොසෙසරය ගැට ගසා JSON අන්තර්ගතය සම්පුර්ණයෙන්ම ප්‍රවාහය වන තෙක් ඔබේ සිදුවීම් ලූපය යටපත් කරනු ඇත.

ඇත NPM පැකේජ ඕනෑ තරම් ලබා ගත හැකි මේ සඳහා. ඔබට වඩාත් සුදුසු දේ තෝරන්න.

දෝෂ හැසිරවීම / ආරක්ෂාව

කිරීමට සමත් වන බව ඕනෑම දෙයක් නම්, ඔබට අවිශ්වාස නම් JSON.parse()වේ වලංගු JSON , වන ලෙස ඉල්ලා ආවරණය කිරීමට වග බලා ගන්න JSON.parse()ඇතුළේ try/catchවාරණ. JSON නූලක් ලබා දී ඇති පරිශීලකයෙකුට ඔබගේ යෙදුම බිඳ වැටිය හැකි අතර ආරක්ෂක වළලු පවා ඇති විය හැකිය. ඔබ බාහිරව සපයන ලද JSON විග්‍රහ කරන්නේ නම් දෝෂ හැසිරවීම සිදු කරන බවට වග බලා ගන්න.

JSON වස්තුව භාවිතා කරන්න :

JSON.parse(str);

JSON.parse හි තවත් උදාහරණයක්:

var fs = require('fs');
var file = __dirname + '/config.json';

fs.readFile(file, 'utf8', function (err, data) {
  if (err) {
    console.log('Error: ' + err);
    return;
  }

  data = JSON.parse(data);

  console.dir(data);
});

ගෝලීය JSON වස්තුවට විකල්ප ඇති බව සඳහන් කිරීමට කැමැත්තෙමි. JSON.parseසහJSON.stringify දෙකම සම මුහුර්තක වේ, ඒ නිසා ඔබ විශාල වස්තූන් සමග ගනුදෙනු කිරීමට අවශ්ය නම් ඔබට අසමමිතික JSON මොඩියුල සමහර පරීක්ෂා කිරීමට ඔබට අවශ්ය විය හැකිය.

බලන්න: https://github.com/joyent/node/wiki/Modules#wiki-parsers-json

node-fsපුස්තකාලය ඇතුළත් කරන්න .

var fs = require("fs");
var file = JSON.parse(fs.readFileSync("./PATH/data.json", "utf8"));

'Fs' පුස්තකාලය පිළිබඳ වැඩි විස්තර සඳහා, http://nodejs.org/api/fs.html හි ඇති ලියකියවිලි බලන්න.

ඔබේ නූල ඇත්ත වශයෙන්ම වලංගු බව ඔබ නොදන්නා හෙයින්, මම එය පළමුවෙන් උත්සාහ කර බලන්නෙමි. උත්සාහක ඇල්ලීමේ වාරණ නෝඩ් මඟින් ප්‍රශස්තිකරණය නොකෙරෙන හෙයින්, මම සියල්ලම වෙනත් ශ්‍රිතයකට දමමි:

function tryParseJson(str) {
    try {
        return JSON.parse(str);
    } catch (ex) {
        return null;
    }
}

හෝ "අසින්ක් ශෛලිය"

function tryParseJson(str, callback) {
    process.nextTick(function () {
      try {
          callback(null, JSON.parse(str));
      } catch (ex) {
          callback(ex)
      }
    })
}

JSON ප්‍රවාහයක් විග්‍රහ කරනවාද? භාවිතා කරන්න JSONStream.

var request = require('request')
  , JSONStream = require('JSONStream')

request({url: 'http://isaacs.couchone.com/registry/_all_docs'})
    .pipe(JSONStream.parse('rows.*'))
    .pipe(es.mapSync(function (data) {
      return data
    }))

https://github.com/dominictarr/JSONStream

මෙහි සිටින සෑම කෙනෙක්ම JSON.parse ගැන පවසා ඇති නිසා මම වෙනත් දෙයක් පැවසීමට සිතුවෙමි. යෙදුම් සංවර්ධනය කිරීම පහසු සහ වඩා හොඳ කිරීම සඳහා විශාල මොඩියුලයක් බොහෝ මිඩ්ල්වෙයාර් සමඟ සම්බන්ධ වන්න . මිඩ්ල්වෙයාර් වලින් එකක් වන්නේ බොඩිපාර්සර් ය . එය JSON, html-forms සහ වෙනත් දේ විග්‍රහ කරයි . JSON විග්‍රහ කිරීම සඳහා නිශ්චිත මිඩ්ල්වෙයාර් එකක් ඇත.

ඉහත සබැඳි දෙස බලන්න, එය ඔබට සැබවින්ම ප්‍රයෝජනවත් විය හැකිය.

JSON.parse("your string");

එච්චරයි.

මෙහි වෙනත් පිළිතුරු සඳහන් කර ඇති පරිදි, වින්‍යාස ගොනුවක් වැනි ආරක්ෂිත සහ පවතින බව ඔබ දන්නා දේශීය json ගොනුවක් අවශ්‍ය වනු ඇත:

var objectFromRequire = require('path/to/my/config.json'); 

හෝ වස්තුවකට නූල් අගයක් විග්‍රහ කිරීමට ගෝලීය JSON වස්තුව භාවිතා කිරීම:

var stringContainingJson = '\"json that is obtained from somewhere\"';
var objectFromParse = JSON.parse(stringContainingJson);

ඔබට ගොනුවක් අවශ්‍ය වූ විට එම ගොනුවේ අන්තර්ගතය ඇගයීමට ලක් කරන අතර එය json ගොනුවක් නොව js ගොනුවක් නම් ආරක්ෂක අවදානමක් හඳුන්වා දෙයි.

මෙන්න, මම ක්‍රම දෙකම දැක ඒවා සමඟ සබැඳිව සෙල්ලම් කළ හැකි නිරූපණයක් ප්‍රකාශයට පත් කර ඇත (විග්‍රහ කිරීමේ උදාහරණය app.js ගොනුවේ ඇත - ඉන්පසු ධාවන බොත්තම ක්ලික් කර ටර්මිනලයේ ප්‍රති result ලය බලන්න): http: // staging1 .codefresh.io / labs / api / env / json-parse-example

ඔබට කේතය වෙනස් කර බලපෑම දැක ගත හැකිය ...

Node.js සමඟ ඔබේ වින්‍යාසය සඳහා JSON භාවිතා කරනවාද? මෙය කියවා ඔබේ වින්‍යාස කිරීමේ කුසලතා 9000 ට වඩා ලබා ගන්න ...

සටහන: දත්ත = අවශ්‍ය යැයි කියා සිටින පුද්ගලයින් ('./ data.json'); එය ආරක්ෂක අවදානමක් වන අතර ජ්වලිත ජ්වලිතයකින් මිනිසුන්ගේ පිළිතුරු පහත් කොට සලකයි: ඔබ හරියටම හා සම්පූර්ණයෙන්ම වැරදියි . එම ගොනුව තුල නොවන JSON තැබීමෙන් උත්සාහ කරන්න ... node එකක් මතම ඊට අදාල ඔබ දෝෂයක් ලබා දෙනු ඇත, හරියටම ඔබ සමග එකම දෙයක් කළා නම් කරන මෙන් බොහෝ ) මන්දගාමී හා අමාරු කේතය අත්පොත ගොනුව කියවා පසුව JSON.parse (. කරුණාකර වැරදි තොරතුරු පැතිරවීම නවත්වන්න; ඔබ ලෝකයට රිදවනවා මිස උදව් කරන්නේ නැහැ. නෝඩ් නිර්මාණය කර ඇත්තේ මෙයට ඉඩ දීම සඳහා ය; එය ආරක්ෂක අවදානමක් නොවේ!

නිසි යෙදුම් 3+ ස්ථර වින්‍යාස වලින් පැමිණේ :

1. සේවාදායකය / බහාලුම් වින්‍යාසය
2. යෙදුම් වින්‍යාසය
3. (අත්‍යවශ්‍ය නොවේ) කුලී නිවැසියන් / ප්‍රජා / සංවිධාන වින්‍යාසය
4. පරිශීලක වින්‍යාසය

බොහෝ සංවර්ධකයින් ඔවුන්ගේ සේවාදායකය සහ යෙදුම් වින්‍යාසය වෙනස් කළ හැකි ලෙස සලකයි. එයට බැහැ. ඔබට ඉහළ ස්ථර වලින් එකිනෙකට ඉහළින් ස්ථර වෙනස් කළ හැකිය , නමුත් ඔබ මූලික අවශ්‍යතා වෙනස් කරයි . සමහර දේවල් අවශ්ය පවතී යයි! ඔබගේ වින්‍යාසය වෙනස් කළ නොහැකි ලෙස ක්‍රියා කරන්න, මන්ද සමහර ඒවා මූලික වශයෙන් ඔබේ ප්‍රභව කේතය මෙන් වේ.

ඔබගේ දේවල් ගොඩක් උත්සාහ / උඩ කොටස් සමඟ ඔබේ config පැටවීම littering වැනි ප්රති-රටාවන් ආරම්භක නායකත්වය පසුව වෙනස් කිරීමට යන්නේ නැහැ, ඔබට දිගටම කරගෙන යා හැක බොරුවට බව දකින්න කිරීමට අපොහොසත් වුවහොත්, තොරව නිසි ලෙස යෙදුමකින් ඔබට . ඔබට බැහැ. ඔබට හැකි නම්, එය අයත් වන්නේ ප්‍රජා / පරිශීලක වින්‍යාස ස්ථරයට මිස සේවාදායකයට / යෙදුම් වින්‍යාස ස්ථරයට නොවේ. ඔයා ඒක වැරදියි. යෙදුම එහි බූට්ස්ට්‍රැප් එක අවසන් වූ විට විකල්ප දේවල් ඉහළින් තැබිය යුතුය.

ඔබේ හිස බිත්තියට පහර දීම නවත්වන්න: ඔබේ වින්‍යාසය අතිශය සරල විය යුතුය .

සරල json වින්‍යාස ගොනුවක් සහ සරල app.js ගොනුවක් භාවිතා කරමින් ප්‍රොටොකෝල්-අ nost ෙයවාදී හා දත්ත සම්පත්-අ nost ෙයවාදී සේවා රාමුවක් තරම් සංකීර්ණ දෙයක් සැකසීම කොතරම් පහසුදැයි බලන්න.

container-config.js ...

{
    "service": {
        "type"  : "http",
        "name"  : "login",
        "port"  : 8085
    },
    "data": {
        "type"  : "mysql",
        "host"  : "localhost",
        "user"  : "notRoot",
        "pass"  : "oober1337",
        "name"  : "connect"
    }
}

index.js ... (සියල්ල බලගන්වන එන්ජිම)

var config      = require('./container-config.json');       // Get our service configuration.
var data        = require(config.data.type);            // Load our data source plugin ('npm install mysql' for mysql).
var service     = require(config.service.type);         // Load our service plugin ('http' is built-in to node).
var processor   = require('./app.js');                  // Load our processor (the code you write).

var connection  = data.createConnection({ host: config.data.host, user: config.data.user, password: config.data.pass, database: config.data.name });
var server      = service.createServer(processor);
connection.connect();
server.listen(config.service.port, function() { console.log("%s service listening on port %s", config.service.type, config.service.port); });

app.js ... (ඔබේ ප්‍රොටෝකෝලය-අ nost ෙයවාදියා සහ දත්ත ප්‍රභව අ nost ෙයවාදියාට බලය සපයන කේතය)

module.exports = function(request, response){
    response.end('Responding to: ' + request.url);
}

මෙම රටාව භාවිතා කරමින්, ඔබට දැන් ඔබගේ ඇරඹූ යෙදුමට ඉහළින් ප්‍රජා සහ පරිශීලක වින්‍යාසගත කළ හැකි දෑ පැටවිය හැකිය, dev ops ඔබේ වැඩ භාජනයකට ගෙන ගොස් එය පරිමාණය කිරීමට සූදානම්ය. ඔබ කියවා ඇත්තේ බහුකාර්ය සඳහා ය. පරිශීලක භූමිය හුදෙකලා වේ. දැන් ඔබ භාවිතා කරන්නේ කුමන සේවා ප්‍රොටෝකෝලය, ඔබ භාවිතා කරන්නේ කුමන දත්ත සමුදා වර්ගයද යන්න සහ හොඳ කේත ලිවීම කෙරෙහි අවධානය යොමු කරන්න.

ඔබ ස්ථර භාවිතා කරන්නේ, ඔබ සත්යය තනි ප්රභවය මත සියලු දේ සඳහා, ඕනෑම අවස්ථාවක (වෙනත් ස්ථර config වස්තුව) දී විශ්වාසය තැබිය හැකි නිසා, සහ වැලැක්විමට දෝෂයක් චෙක්පත් සෑම පියවරක දී ම, "අයියෝ ජරාව, මම කරන්න යන්නේ කෙසේද ගැන වද වෙන මේ නිසි වින්‍යාසය නොමැතිව වැඩ කරන්න?!? ".

මගේ විසඳුම:

var fs = require('fs');
var file = __dirname + '/config.json';

fs.readFile(file, 'utf8', function (err, data) {
    if (err) {
        console.log('Error: ' + err);
        return;
    }

    data = JSON.parse(data);

    console.dir(data);
});

පිළිතුර සම්පුර්ණ කිරීමට අවශ්‍යය (මම ටික වේලාවක් ඒ සමඟ පොරබදමින් සිටියදී), json තොරතුරු වෙත ප්‍රවේශ වන ආකාරය පෙන්වීමට අවශ්‍ය නම්, මෙම උදාහරණයෙන් දැක්වෙන්නේ Json Array වෙත ප්‍රවේශ වීම:

var request = require('request');
request('https://server/run?oper=get_groups_joined_by_user_id&user_id=5111298845048832', function (error, response, body) {
  if (!error && response.statusCode == 200) {
    var jsonArr = JSON.parse(body);
    console.log(jsonArr);
    console.log("group id:" + jsonArr[0].id);
  }
})

මෙය හැකි තරම් සංකීර්ණ කිරීමට සහ හැකි තරම් පැකේජ ගෙන ඒමට ...

const fs = require('fs');
const bluebird = require('bluebird');
const _ = require('lodash');
const readTextFile = _.partial(bluebird.promisify(fs.readFile), _, {encoding:'utf8',flag:'r'});
const readJsonFile = filename => readTextFile(filename).then(JSON.parse);

මෙය ඔබට කිරීමට ඉඩ දෙයි:

var dataPromise = readJsonFile("foo.json");
dataPromise.then(console.log);

නැතහොත් ඔබ අසංක / භාවිතා කරන්නේ නම්:

let data = await readJsonFile("foo.json");

භාවිතා කිරීමෙන් readFileSyncලැබෙන වාසිය නම්, ගොනුව තැටියෙන් කියවන අතරතුර ඔබේ නෝඩ් සේවාදායකයාට වෙනත් ඉල්ලීම් ක්‍රියාවට නැංවිය හැකිය.

JSON.parse ඔබ විග්‍රහ කරන json නූල් වල ආරක්ෂාව සහතික නොකරයි. ඔබ json-safe-parse හෝ ඒ හා සමාන පුස්තකාලයක් වැනි පුස්තකාලයක් දෙස බැලිය යුතුය .

Json-safe-parse npm පිටුවෙන්:

JSON.parse විශිෂ්ටයි, නමුත් එය ජාවාස්ක්‍රිප්ට් සන්දර්භය තුළ එක් බරපතල අඩුපාඩුවක් ඇත: එය ඔබට උරුම වූ දේපල අභිබවා යාමට ඉඩ දෙයි. ඔබ විශ්වාස කළ නොහැකි ප්‍රභවයකින් (උදා: පරිශීලකයෙකු) JSON විග්‍රහ කරන්නේ නම් මෙය ප්‍රශ්නයක් බවට පත්විය හැකි අතර, ඒ සඳහා ඔබ ඇමතීමේ කාර්යයන් පවතිනු ඇතැයි අපේක්ෂා කෙරේ.

දෝෂ සහිත වස්තුවක් ආපසු ලබා දීමට ලොඩාෂ්ගේ උත්සාහයේ ක්‍රියාකාරිත්වය, ඔබට isError ශ්‍රිතය සමඟ කටයුතු කළ හැකිය.

// Returns an error object on failure
function parseJSON(jsonString) {
   return _.attempt(JSON.parse.bind(null, jsonString));
}


// Example Usage
var goodJson = '{"id":123}';
var badJson = '{id:123}';
var goodResult = parseJSON(goodJson);
var badResult = parseJSON(badJson);

if (_.isError(goodResult)) {
   console.log('goodResult: handle error');
} else {
   console.log('goodResult: continue processing');
}
// > goodResult: continue processing

if (_.isError(badResult)) {
   console.log('badResult: handle error');
} else {
   console.log('badResult: continue processing');
}
// > badResult: handle error

ඔබේ Json හි යම් දූෂිත දත්ත තිබේ නම් සෑම විටම අනපේක්ෂිත දෝෂයක් ඇති බැවින් JSON.parse උත්සාහක ඇල්ලීමේ අවහිරය භාවිතා කිරීමට වග බලා ගන්න. එබැවින් සරල JSON වෙනුවට මෙම කේතය භාවිතා කරන්න.

try{
     JSON.parse(data)
}
catch(e){
   throw new Error("data is corrupted")
  }

ඔබේ JSON හි අදහස් කිහිපයක් එකතු කිරීමට සහ කොමා පසුපස ලුහුබැඳීමට ඔබට අවශ්‍ය නම් පහත ක්‍රියාත්මක කිරීම අවශ්‍ය වේ:

var fs = require('fs');

var data = parseJsData('./message.json');

console.log('[INFO] data:', data);

function parseJsData(filename) {
    var json = fs.readFileSync(filename, 'utf8')
        .replace(/\s*\/\/.+/g, '')
        .replace(/,(\s*\})/g, '}')
    ;
    return JSON.parse(json);
}

"abc": "foo // bar"ඔබේ JSON හි වැනි දෙයක් තිබේ නම් එය හොඳින් ක්‍රියාත්මක නොවන බව සලකන්න . ඉතින් වයි.එම්.වී.

JSON ප්‍රභව ගොනුව තරමක් විශාල නම්, දේශීය අසමමුහුර්ත හරහා අසමමුහුර්ත මාර්ගය සලකා බැලීමට / Node.js 8.0 සමඟ ප්‍රවේශය සඳහා බලා සිටින්න.

const fs = require('fs')

const fsReadFile = (fileName) => {
    fileName = `${__dirname}/${fileName}`
    return new Promise((resolve, reject) => {
        fs.readFile(fileName, 'utf8', (error, data) => {
            if (!error && data) {
                resolve(data)
            } else {
                reject(error);
            }
        });
    })
}

async function parseJSON(fileName) {
    try {
        return JSON.parse(await fsReadFile(fileName));
    } catch (err) {
        return { Error: `Something has gone wrong: ${err}` };
    }
}

parseJSON('veryBigFile.json')
    .then(res => console.log(res))
    .catch(err => console.log(err))

මම fs-extra භාවිතා කරමි . මම එයට බොහෝ කැමතියි - එය ඇමතුම් ලබා ගැනීමට සහාය දෙන නමුත්- එය පොරොන්දු සඳහාද සහාය වේ. එබැවින් එය මගේ කේතය වඩාත් කියවිය හැකි ආකාරයකින් ලිවීමට මට හැකියාව ලබා දෙයි:

const fs = require('fs-extra');
fs.readJson("path/to/foo.json").then(obj => {
    //Do dome stuff with obj
})
.catch(err => {
    console.error(err);
});

සම්මත fsමොඩියුලය සමඟ නොපැමිණෙන බොහෝ ප්‍රයෝජනවත් ක්‍රම ද එහි ඇති අතර , ඊට ඉහළින්, එය ස්වදේශීය fsමොඩියුලයේ ක්‍රමෝපායන් පාලම් කර ඒවා සහතික කරයි.

සටහන: ඔබට තවමත් ස්වදේශීය Node.js ක්‍රම භාවිතා කළ හැකිය. ඒවා පොරොන්දු වී fs-extra වෙත පිටපත් කරනු ලැබේ. fs.read()සහ සටහන් බලන්නfs.write()

එබැවින් එය මූලික වශයෙන් සියලු වාසි වේ. අනෙක් අයට මෙය ප්‍රයෝජනවත් වේ යැයි මම බලාපොරොත්තු වෙමි.

ඔබට ආරක්ෂිත ආකාරයකින් JSON Node.js සමඟ විග්‍රහ කිරීමට අවශ්‍ය නම් (aka: පරිශීලකයාට දත්ත ආදානය කළ හැකිය, නැතහොත් පොදු API) ආරක්ෂිත-ජේසන්-විග්‍රහය භාවිතා කිරීමට මම යෝජනා කරමි .

භාවිතය පෙරනිමිය හා සමාන JSON.parseනමුත් එය ඔබගේ කේතය මෙයින් ආරක්ෂා කරයි:

• මූලාකෘති විෂ වීම
• සහ ඉදිකිරීම්කරු අපයෝජනය :

const badJson = '{ "a": 5, "b": 6, "__proto__": { "x": 7 }, "constructor": {"prototype": {"bar": "baz"} } }'

const infected = JSON.parse(badJson)
console.log(infected.x) // print undefined

const x = Object.assign({}, infected)
console.log(x.x) // print 7

const sjson = require('secure-json-parse')
console.log(sjson.parse(badJson)) // it will throw by default, you can ignore malicious data also

ඔබට JSON.parse () භාවිතා කළ හැකිය (එය ගොඩනංවන ලද ශ්‍රිතයක් වන අතර එය උත්සාහක දිනුම් ප්‍රකාශ සමඟ එතීමට ඔබට බල කරනු ඇත).

නැතහොත් jSON විග්‍රහ කරන npm පුස්තකාලයක් භාවිතා කරන්න, json-parse-or වැනි දෙයක්

ආරක්ෂිත පැත්තේ සිටීමට මෙය භාවිතා කරන්න

var data = JSON.parse(Buffer.concat(arr).toString());

NodeJs යනු ජාවාස්ක්‍රිප්ට් මත පදනම් වූ සේවාදායකයකි, එබැවින් ඔබට එය පිරිසිදු ජාවාස්ක්‍රිප්ට් මඟින් කළ හැකිය ...

හිතන්න ඔයාට මේ Json එක NodeJs වල තියෙනවා කියලා ...

var details = '{ "name": "Alireza Dezfoolian", "netWorth": "$0" }';
var obj = JSON.parse(details);

ඔබේ json හි විග්‍රහ කළ අනුවාදයක් ලබා ගැනීමට ඔබට ඉහත කළ හැකිය ...

ඉහත පිළිතුරු වල සඳහන් පරිදි අපට භාවිතා කළ හැකිය JSON.parse() JSON වෙත නූල් විග්‍රහ කිරීමට නමුත් විග්‍රහ කිරීමට පෙර, නිවැරදි දත්ත විග්‍රහ කිරීමට වග බලා ගන්න, නැතිනම් එය ඔබගේ මුළු යෙදුමම පහතට ගෙන එනු ඇත

එය මේ ආකාරයෙන් භාවිතා කිරීම ආරක්ෂිතයි

let parsedObj = {}
try {
    parsedObj = JSON.parse(data);
} catch(e) {
    console.log("Cannot parse because data is not is proper json format")
}

භාවිතා කරන්න JSON.parse(str);. ඒ ගැන වැඩි විස්තර මෙතැනින් කියවන්න .

මෙන්න උදාහරණ කිහිපයක්:

var jsonStr = '{"result":true, "count":42}';

obj = JSON.parse(jsonStr);

console.log(obj.count);    // expected output: 42
console.log(obj.result);   // expected output: true

තවත් මොඩියුල අවශ්‍ය නොවේ.
යන්තම් භාවිතා
var parsedObj = JSON.parse(yourObj);
මම දොන් මේ සම්බන්ධයෙන් කිසිඳු ආරක්ෂක ප්රශ්න මතුව තිබෙන බව යි

එය සරලයි, ඔබට JSON භාවිතා කරමින් නූල් බවට පරිවර්තනය කළ හැකිය JSON.stringify(json_obj), සහ භාවිතයෙන් JSON බවට පරිවර්තනය කළ හැකිය JSON.parse("your json string").