javascript - Node.js का उपयोग कर JSON का विश्लेषण कैसे करें?




(22)

node-fs पुस्तकालय शामिल करें।

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

'एफएस' लाइब्रेरी पर अधिक जानकारी के लिए, http://nodejs.org/api/fs.html पर दस्तावेज़ देखें

Node.js का उपयोग करके JSON को कैसे पार्स करना चाहिए? क्या कोई मॉड्यूल है जो JSON को सुरक्षित रूप से मान्य और पार्स करेगा?


Node.js के साथ आपकी कॉन्फ़िगरेशन के लिए JSON का उपयोग करना? इसे पढ़ें और 9 000 से अधिक अपने विन्यास कौशल प्राप्त करें ...

नोट: लोग दावा करते हैं कि डेटा = आवश्यकता है ('./ data.json'); एक सुरक्षा जोखिम है और उत्साही उत्साह के साथ लोगों के जवाब को कम करना: आप बिल्कुल और पूरी तरह से गलत हैं । उस फ़ाइल में गैर-JSON डालने का प्रयास करें ... नोड आपको एक त्रुटि देगा, ठीक उसी तरह जैसे यदि आपने मैन्युअल फ़ाइल को पढ़ने के लिए धीमे और कड़ी मेहनत के साथ वही काम किया था और उसके बाद JSON.parse ()। कृपया गलत जानकारी फैलाना बंद करो; आप दुनिया को चोट पहुंचा रहे हैं, मदद नहीं कर रहे हैं। नोड को इसकी अनुमति देने के लिए डिज़ाइन किया गया था; यह एक सुरक्षा जोखिम नहीं है!

उचित अनुप्रयोग कॉन्फ़िगरेशन की 3+ परतों में आते हैं:

  1. सर्वर / कंटेनर कॉन्फ़िगरेशन
  2. एप्लिकेशन कॉन्फ़िगरेशन
  3. (वैकल्पिक) किरायेदार / समुदाय / संगठन विन्यास
  4. उपयोगकर्ता विन्यास

अधिकांश डेवलपर्स अपने सर्वर और ऐप कॉन्फ़िगरेशन का इलाज करते हैं जैसे कि यह बदल सकता है। यह नहीं कर सकता आप एक दूसरे के शीर्ष पर उच्च परतों से परिवर्तन ले सकते हैं, लेकिन आप मूल आवश्यकताओं को संशोधित कर रहे हैं । कुछ चीजों को अस्तित्व में रहने की जरूरत है! अपने कॉन्फ़िगरेशन एक्ट को अपरिवर्तनीय बनाओ, क्योंकि इसमें से कुछ मूल रूप से आपके स्रोत कोड की तरह है।

यह देखने में नाकाम रहे कि स्टार्टअप एंटी-पैटर्न के बाद आपकी बहुत सी चीजें बदलने जा रही हैं जैसे कि कोशिश / पकड़ ब्लॉक के साथ अपनी कॉन्फ़िगरेशन लोडिंग को कूड़े हुए, और नाटक करने से आप अपने उचित सेटअप एप्लिकेशन के बिना जारी रख सकते हैं। आप नहीं कर सकते यदि आप कर सकते हैं, जो समुदाय / उपयोगकर्ता कॉन्फ़िगरेशन परत में है, सर्वर / ऐप कॉन्फ़िगरेशन परत नहीं। आप बस गलत कर रहे हैं। एप्लिकेशन को बूटस्ट्रैप समाप्त होने पर वैकल्पिक सामग्री शीर्ष पर स्तरित की जानी चाहिए।

दीवार के खिलाफ अपने सिर को टक्कर मारना बंद करो: आपकी कॉन्फ़िगरेशन अति सरल होनी चाहिए।

एक सरल जेसन कॉन्फ़िगरेशन फ़ाइल और सरल app.js फ़ाइल का उपयोग करके प्रोटोकॉल-अज्ञेयवादी और डेटासोर्स-अज्ञेय सेवा ढांचे के रूप में कुछ जटिल स्थापित करना कितना आसान है, इस पर एक नज़र डालें ...

कंटेनर-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 ... (वह कोड जो आपके प्रोटोकॉल-अज्ञेयवादी और डेटा-स्रोत अज्ञेयवादी सेवा को शक्ति देता है)

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

इस पैटर्न का उपयोग करके, अब आप अपने बूट किए गए ऐप के शीर्ष पर समुदाय और उपयोगकर्ता कॉन्फ़िगरेशन सामान लोड कर सकते हैं, dev ops आपके काम को कंटेनर में घुमाने और इसे स्केल करने के लिए तैयार है। आप बहुमुखी के लिए पढ़ रहे हैं। उपयोगकर्तालैंड अलग है। अब आप किस सेवा प्रोटोकॉल का उपयोग कर रहे हैं, आप किस डेटाबेस प्रकार का उपयोग कर रहे हैं, और केवल अच्छे कोड लिखने पर ध्यान केंद्रित कर सकते हैं।

चूंकि आप परतों का उपयोग कर रहे हैं, आप किसी भी समय (स्तरित कॉन्फ़िगरेशन ऑब्जेक्ट) पर सब कुछ के लिए सच्चाई के एक स्रोत पर भरोसा कर सकते हैं, और हर कदम पर त्रुटि जांच से बच सकते हैं, "ओह बकवास, मैं इसे कैसे बनाने जा रहा हूं उचित विन्यास के बिना काम?!? "।


हमेशा कोशिश करें कि ब्लॉक पकड़ने में JSON.parse का उपयोग करें क्योंकि नोड हमेशा एक अप्रत्याशित त्रुटि फेंक देता है यदि आपके जेसन में कुछ दूषित डेटा है तो सरल JSON.Parse के बजाय इस कोड का उपयोग करें

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

मैं उल्लेख करना चाहता हूं कि वैश्विक JSON ऑब्जेक्ट के विकल्प हैं। JSON.parse और JSON.stringify दोनों सिंक्रोनस हैं, इसलिए यदि आप बड़ी वस्तुओं से निपटना चाहते हैं तो आप कुछ एसिंक्रोनस JSON मॉड्यूल को देखना चाहेंगे।

एक नज़र डालें: https://github.com/joyent/node/wiki/Modules#wiki-parsers-json


यदि आप अपने 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);
}

ध्यान दें कि यदि आपके JSON में "abc": "foo // bar" जैसा कुछ है तो यह अच्छी तरह से काम नहीं कर सकता है। तो वाईएमएमवी।


आप .json फ़ाइलों की require हो सकती require

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

उदाहरण के लिए यदि आपके पास एक ही निर्देशिका में config.json फ़ाइल है जो आपकी स्रोत कोड फ़ाइल के रूप में उपयोग करेगी:

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

या (फ़ाइल एक्सटेंशन छोड़ा जा सकता है):

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

नोट करें कि require सिंक्रोनस है और केवल एक बार फाइल को पढ़ती है, कॉल के परिणाम कैश से परिणाम लौटाते हैं

यह भी ध्यान रखें कि आपको केवल स्थानीय फाइलों के लिए अपने पूर्ण नियंत्रण के तहत इसका उपयोग करना चाहिए, क्योंकि यह फ़ाइल के भीतर किसी भी कोड को संभावित रूप से निष्पादित करता है।



मेरा समाधान:

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.parse आपके द्वारा पार्सिंग की जेसन स्ट्रिंग की सुरक्षा सुनिश्चित नहीं करेगा। आपको json-safe-parse या इसी तरह की लाइब्रेरी जैसी लाइब्रेरी देखना चाहिए।

जेसन-सेफ-पार्स एनपीएम पेज से:

JSON.parse बहुत अच्छा है, लेकिन जावास्क्रिप्ट के संदर्भ में इसकी एक गंभीर दोष है: यह आपको विरासत गुणों को ओवरराइड करने की अनुमति देता है। यह एक मुद्दा बन सकता है यदि आप किसी अविश्वसनीय स्रोत से JSON को पार्स कर रहे हैं (उदाहरण: एक उपयोगकर्ता), और उस पर कॉलिंग फ़ंक्शंस आप मौजूद होने की उम्मीद करेंगे।


var array={
    Action: 'Login',
    ErrorCode: 3,
    Detail: 'Your account not found.'
};
var http=require('http'),
    PORT=8789,
    server=function(req,res){
        res.writeHead(200,{'Content-Type':'application/json'});

        // JSON
        res.end(JSON.stringify(array));
    }

http.createServer(server).listen(PORT);
console.log('Server started.');

आप बस JSON.parse उपयोग कर सकते हैं।

node.js V8 पर बनाया गया है, जो वैश्विक ऑब्जेक्ट JSON[docs] प्रदान करता है। JSON ऑब्जेक्ट की परिभाषा ईसीएमएस्क्रिप्ट 5 विनिर्देश का हिस्सा है

नोट - JSON.parse वर्तमान थ्रेड को JSON.parse सकता है क्योंकि यह एक तुल्यकालिक विधि है। तो यदि आप बड़ी JSON ऑब्जेक्ट्स को पार्स करने की योजना बना रहे हैं तो स्ट्रीमिंग जेसन पार्सर का उपयोग करें।


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);
});

var fs = require('fs');

fs.readFile('ashish.json',{encoding:'utf8'},function(data,err) {

   if(err) 
      throw err;

   else {

   console.log(data.toString());

 }
})

सुरक्षित पक्ष पर रहने के लिए इसका इस्तेमाल करें

var डेटा = JSON.parse (Buffer.concat (arr) .toString ());


आप JSON.parse उपयोग कर सकते हैं

आप किसी भी ईसीएमएस्क्रिप्ट 5 संगत जावास्क्रिप्ट कार्यान्वयन पर JSON ऑब्जेक्ट का उपयोग करने में सक्षम होना चाहिए। और V8 , जिस पर नोड.जेएस बनाया गया है उनमें से एक है।

जेएसओएन डेटा युक्त स्ट्रिंग को पार्स करना

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');

लेकिन, मैं कई कारणों से इसकी अनुशंसा नहीं करता हूं:

नोट: यदि आप संवेदनशील जानकारी (जैसे पासवर्ड) स्टोर करने के लिए JSON फ़ाइल का उपयोग कर रहे हैं, तो ऐसा करने का गलत तरीका है। देखें कि हेरोोकू यह कैसे करता है: https://devcenter.heroku.com/articles/config-vars#setting-up-config-vars-for-a-deployed-application एप्लिकेशन। पता लगाएं कि आपका प्लेटफॉर्म कैसा करता है, और कोड के भीतर से कॉन्फ़िगर वर्र्स को पुनर्प्राप्त करने के लिए process.env का उपयोग करें।

  1. require तुल्यकालिक है। यदि आपके पास एक बहुत बड़ी JSON फ़ाइल है, तो यह आपके ईवेंट लूप को चकित करेगी। आपको वास्तव में JSON.parse साथ fs.readFile का उपयोग करने की आवश्यकता है।
  2. require केवल फाइल को एक बार पढ़ा जाएगा। उसी फ़ाइल के लिए require कॉल करने के लिए बाद में कॉल कैश की गई प्रतिलिपि वापस कर देंगे। यदि आप एक .json फ़ाइल को लगातार अद्यतन करना चाहते हैं तो एक अच्छा विचार नहीं है। आप एक हैक का उपयोग कर सकते हैं। लेकिन इस बिंदु पर, बस fs उपयोग करना आसान है।
  3. यदि आपकी फ़ाइल में .json एक्सटेंशन नहीं है, तो फ़ाइल की सामग्री JSON के रूप में नहीं मानी जाएगी।

गंभीरता से! JSON.parse प्रयोग करें

jsonfile मॉड्यूल

यदि आप बड़ी संख्या में .json फ़ाइलों को पढ़ रहे हैं, (और यदि आप बेहद आलसी हैं), तो हर बार बॉयलरप्लेट कोड लिखना परेशान हो जाता है। आप jsonfile मॉड्यूल का उपयोग कर कुछ पात्रों को बचा सकते हैं।

var jf = require('jsonfile');

असीमित संस्करण

jf.readFile('/path/to/file.json', function(err, obj) {
  // obj contains JSON data
});

तुल्यकालिक संस्करण

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

धाराओं से JSON पार्सिंग

यदि जेएसओएन सामग्री नेटवर्क पर स्ट्रीम की जाती है, तो आपको एक स्ट्रीमिंग JSON पार्सर का उपयोग करने की आवश्यकता है। अन्यथा यह आपके प्रोसेसर को बांध देगा और आपके ईवेंट लूप को तब तक दबाएगा जब तक कि JSON सामग्री पूरी तरह से स्ट्रीम न हो जाए।

इसके लिए एनपीएम में बहुत सारे पैकेज उपलब्ध हैं । चुनें कि आपके लिए सबसे अच्छा क्या है।

त्रुटि हैंडलिंग / सुरक्षा

यदि आप अनिश्चित हैं कि जो भी JSON.parse() को पास किया गया है , वह वैध JSON है , तो कोशिश करें कि JSON.parse() को कॉल try/catch ब्लॉक के अंदर कॉल संलग्न करें। एक उपयोगकर्ता प्रदान करता है जो JSON स्ट्रिंग आपके एप्लिकेशन को क्रैश कर सकता है, और यहां तक ​​कि सुरक्षा छेद भी ले सकता है। सुनिश्चित करें कि अगर आप बाहरी रूप से प्रदत्त JSON को पार्स करते हैं तो त्रुटि प्रबंधन किया जाता है।


इसे यथासंभव जटिल बनाने के लिए, और जितना संभव हो सके उतने पैकेज लाएं ...

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);

या यदि आप async / await का उपयोग कर रहे हैं:

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

readFileSync का उपयोग करने पर लाभ यह है कि फ़ाइल को डिस्क से पढ़ने के दौरान आपका नोड सर्वर अन्य अनुरोधों को संसाधित कर सकता है।


एक 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
    }))

github.com/dominictarr/JSONStream


जैसा कि यहां अन्य उत्तरों का उल्लेख किया गया है, आप शायद स्थानीय जेएसओ फ़ाइल की आवश्यकता चाहते हैं जो आपको पता है कि कॉन्फ़िगरेशन फ़ाइल की तरह सुरक्षित और वर्तमान है:

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

या किसी ऑब्जेक्ट में स्ट्रिंग मान को पार्स करने के लिए वैश्विक JSON ऑब्जेक्ट का उपयोग करने के लिए:

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

ध्यान दें कि जब आपको फ़ाइल की आवश्यकता होती है तो उस फ़ाइल की सामग्री का मूल्यांकन किया जाता है, जो कि एक जेएसएस फ़ाइल नहीं है, लेकिन एक जेएस फ़ाइल में सुरक्षा जोखिम पेश करता है।

यहां, मैंने एक डेमो प्रकाशित किया है जहां आप दोनों विधियों को देख सकते हैं और उनके साथ ऑनलाइन खेल सकते हैं (पार्सिंग उदाहरण app.js फ़ाइल में है - फिर रन बटन पर क्लिक करें और परिणाम टर्मिनल में देखें): http://staging1.codefresh.io/labs/api/env/json-parse-example

आप कोड को संशोधित कर सकते हैं और प्रभाव देख सकते हैं ...


चूंकि आप नहीं जानते कि आपकी स्ट्रिंग वास्तव में मान्य है, मैं इसे पहले कोशिश करने के लिए रखूंगा। इसके अलावा, पकड़ने वाले ब्लॉक को नोड द्वारा अनुकूलित नहीं किया जाता है, इसलिए मैं पूरी चीज को किसी अन्य फ़ंक्शन में डाल दूंगा:

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

या "async शैली" में

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

यहां सभी ने JSON.parse के बारे में बताया है, इसलिए मैंने कुछ और कहने का सोचा। ऐप्स का विकास आसान और बेहतर बनाने के लिए एक शानदार मॉड्यूल कई मिडलवेयर से Connect है। मिडलवेयर में से एक bodyParser । यह जेएसओएन, एचटीएमएल-फॉर्म और इत्यादि का noop । जेएसओएन पार्सिंग केवल noop लिए एक विशिष्ट मिडलवेयर भी है।

उपरोक्त लिंक पर एक नज़र डालें, यह आपके लिए वास्तव में उपयोगी हो सकता है।


यह आसान है, आप JSON.stringify(json_obj) का उपयोग कर JSON को स्ट्रिंग में परिवर्तित कर सकते हैं, और JSON.parse("your json string") का उपयोग कर स्ट्रिंग को JSON में परिवर्तित कर JSON.parse("your json string")


यदि आप exports और / या modules.exports लिए किसी नए ऑब्जेक्ट का संदर्भ निर्दिष्ट करते हैं तो कुछ चीजें आपको सावधानी बरतनी चाहिए। exports :

1. मूल exports या module.exports से पहले जुड़े सभी गुण / विधियां निश्चित रूप से खो गई हैं क्योंकि निर्यातित वस्तु अब एक और नया संदर्भ देगी

यह एक स्पष्ट है, लेकिन यदि आप मौजूदा मॉड्यूल की शुरुआत में एक निर्यात विधि जोड़ते हैं, तो सुनिश्चित करें कि मूल निर्यातित वस्तु अंत में किसी अन्य ऑब्जेक्ट का संदर्भ नहीं दे रही है

exports.method1 = function () {}; // exposed to the original exported object
exports.method2 = function () {}; // exposed to the original exported object

module.exports.method3 = function () {}; // exposed with method1 & method2

var otherAPI = {
    // some properties and/or methods
}

exports = otherAPI; // replace the original API (works also with module.exports)

2. यदि exports या module.exports कोई एक नया मान संदर्भित करता है, तो वे किसी भी वस्तु का संदर्भ नहीं लेते हैं

exports = function AConstructor() {}; // override the original exported object
exports.method2 = function () {}; // exposed to the new exported object

// method added to the original exports object which not exposed any more
module.exports.method3 = function () {}; 

3. मुश्किल परिणाम। यदि आप दोनों exports और module.exports के संदर्भ को module.exports , तो यह कहना मुश्किल है कि कौन सी एपीआई उजागर हुई है (ऐसा लगता है कि module.exports जीतता है)

// override the original exported object
module.exports = function AConstructor() {};

// try to override the original exported object
// but module.exports will be exposed instead
exports = function AnotherConstructor() {}; 




javascript json node.js