vous pouvez exiger .des fichiers json.

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

par exemple, si vous avez un fichier config.json dans le même répertoire que votre fichier de code source, vous utiliserez:

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

or (une extension de fichier peut être omise):

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

notez que require est synchrone et ne lit le fichier qu'une seule fois , suite aux appels retourner le résultat de cache

notez aussi que vous ne devez l'utiliser que pour les fichiers locaux sous votre contrôle absolu, car il exécute potentiellement n'importe quel code dans le fichier.

vous pouvez utiliser JSON.parse() .

vous devriez pouvoir utiliser l'objet JSON sur n'importe quel ECMAScript 5 implémentation JavaScript compatible. Et V8 , sur lequel noeud.js est construit est l'un d'entre eux.

l'Analyse d'une chaîne de caractères contenant les données JSON

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

analyse d'un fichier contenant des données JSON

vous devrez effectuer quelques opérations de fichiers avec le module fs .

version asynchrone

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

version synchrone

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

vous voulez utiliser require ? Détrompez-vous!

vous pouvez parfois utiliser require :

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

mais, je ne le recommande pas pour plusieurs raisons:

Note: Si vous utilisez un fichier JSON pour stocker des informations sensibles (par exemple des mots de passe), c'est la mauvaise façon de le faire. Voir comment Heroku le fait: https://devcenter.heroku.com/articles/config-vars#setting-up-config-vars-for-a-deployed-application . Découvrez comment votre plate-forme le fait, et utilisez process.env pour récupérer les variables de configuration dans le code.

1. require est synchrone. Si vous avez un très gros fichier JSON, il étouffera votre boucle d'événement. Vous devez vraiment utiliser JSON.parse avec fs.readFile .
2. require Lira le fichier une seule fois . Les appels subséquents à require pour le même fichier retourneront une copie mise en cache. Pas une bonne idée si vous voulez lire un "1519180920 fichier est mis à jour continuellement. Vous pouvez utiliser "1519790920 un" hack . Mais à ce stade, il est plus facile d'utiliser simplement fs .
3. si votre fichier n'a pas d'extension .json , require ne traitera pas le contenu du fichier comme JSON.

sérieusement! Utilisez JSON.parse .

load-json-file module

Si vous lisez grand nombre des fichiers .json , (et si vous êtes extrêmement paresseux), il devient ennuyeux d'écrire du code boilerplate à chaque fois. Vous pouvez sauvegarder quelques caractères en utilisant le module load-json-file .

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

version asynchrone

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

version synchrone

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

Parsing JSON from streams

si le contenu JSON est diffusé en continu sur le réseau,vous devez utiliser un analyseur de flux JSON. Sinon, il bloquera votre processeur et étouffera votre boucle d'événement jusqu'à ce que le contenu de JSON soit entièrement strié.

il y a beaucoup de paquets disponibles en NPM pour cela. Choisir ce qui est le mieux pour vous.

Traitement Des Erreurs /Sécurité

si vous n'êtes pas sûr que ce qui est passé à JSON.parse() est valide JSON , assurez-vous de joindre l'appel à JSON.parse() dans un bloc try/catch . Une chaîne JSON fournie par l'utilisateur pourrait planter votre application, et pourrait même conduire à des trous de sécurité. Assurez-vous que la gestion des erreurs est faite si vous analysez JSON fourni à l'extérieur.

utiliser le objet JSON :

JSON.parse(str);

un autre exemple de 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);
});

j'aimerais mentionner qu'il existe des alternatives à l'objet global JSON. JSON.parse et JSON.stringify sont tous deux synchrones, donc si vous voulez traiter avec de gros objets, vous pourriez vouloir vérifier certains des modules asynchrones JSON.

Avoir un coup d'oeil: https://github.com/joyent/node/wiki/Modules#wiki-parsers-json

Inclure node-fs de la bibliothèque.

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

pour plus d'informations sur la bibliothèque 'fs', voir la documentation à http://nodejs.org/api/fs.html

puisque vous ne savez pas si votre chaîne est valide, je la mettrais d'abord dans une prise d'essai. Aussi puisque les blocs de capture d'essai ne sont pas optimisés par noeud, je mettrais la chose entière dans une autre fonction:

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

OU en "async" style

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

de l'Analyse d'un flux JSON? Utilisez 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("your string");

C'est tout.

comme d'autres réponses ici ont mentionné, vous voulez probablement soit exiger un fichier JSON local que vous savez être sûr et présent, comme un fichier de configuration:

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

ou pour utiliser l'objet global JSON pour analyser une valeur de chaîne dans un objet:

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

notez que lorsque vous avez besoin d'un fichier, le contenu de ce fichier est évalué, ce qui introduit un risque de sécurité au cas où il ne s'agirait pas d'un fichier json mais d'un fichier js.

ici, j'ai publié une démo où vous pouvez voir les deux méthodes et jouer avec elles en ligne (l'exemple d'analyse est dans app.js fichiers, puis cliquez sur le bouton exécuter et voir le résultat dans le terminal): http://staging1.codefresh.io/labs/api/env/json-parse-example

vous pouvez modifier le code et voir l'impact...

tout le monde ici a parlé de JSON.analyser, alors j'ai pensé à dire quelque chose d'autre. Il ya un grand module Connect avec de nombreux middleware pour rendre le développement des applications plus facile et meilleure. L'un des middlewares est bodyParser . Il analyse JSON, html-forms et etc. Il existe également un middleware spécifique pour JSON parsing seulement noop .

regardez les liens ci-dessus, il peut être vraiment utile pour vous.

ma solution:

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

je veux juste compléter la réponse (comme j'ai eu du mal avec elle pendant un certain temps), je veux montrer comment accéder à l'information json, cet exemple montre l'accès au tableau Json:

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

en utilisant JSON pour votre configuration avec Node.js? Lisez ceci et obtenez vos compétences de configuration de plus de 9000...

Note: personnes affirmant que data = require ('./données.json'); est un le risque de sécurité et la dévalorisation des réponses des gens avec zèle: vous êtes exactement et complètement faux . Essayez de placer non-JSON dans ce fichier... Nœud vous donnera une erreur, exactement comme si vous faisiez la même chose avec le beaucoup plus lent et plus difficile à coder le fichier manuel lu et puis JSON subséquent.analyser.)( S'il vous plaît, arrêtez de répandre la désinformation; vous faites du mal au monde, vous n'aidez pas. Node était conçu pour permettre cela; ce n'est pas un risque de sécurité!

les applications appropriées sont disponibles en 3+ couches de configuration:

1. Serveur/Conteneur config
2. config
3. (optionnel) locataire/communauté/organisation config
4. configuration Utilisateur

la plupart des développeurs traitent leur config de serveur et d'application comme si elle pouvait changer. C'est impossible. Vous pouvez changer la couche à partir de couches supérieures les unes sur les autres, mais vous êtes modifier exigences de base . Certaines choses besoin pour exister! Faites votre config d'agir comme il est immuable, parce qu'il est fondamentalement, tout comme votre code source.

ne pas voir que beaucoup de vos trucs ne vont pas changer après le démarrage conduit à des anti-patterns comme jeter des déchets sur votre chargement de configuration avec des blocs d'essai/catch, et prétendre que vous pouvez continuer sans votre application correctement configurée. Vous ne pouvez pas. Si vous pouvez, cela appartient à la couche de configuration communauté/Utilisateur, pas à la couche de configuration serveur/app. Tu le fais de travers. La substance optionnelle doit être superposée sur le dessus lorsque l'application termine il est bootstrap.

arrêtez de frapper votre tête contre le mur: votre configuration devrait être ultra simple .

regardez comme il est facile de configurer quelque chose d'aussi complexe qu'un protocole-agnostique et source de données-agnostique Service framework en utilisant un simple fichier de configuration json et application simple.fichier js...

conteneur-config.js...

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

de l'index.js... (le moteur qui alimente tout)

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... (le code qui alimente votre protocole-service agnostique et source de données)

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

en utilisant ce modèle, vous pouvez maintenant charger la communauté et la configuration de l'utilisateur choses sur le dessus de votre application démarrée, Dev ops est prêt à pousser votre travail dans un conteneur et l'échelle. Vous êtes lu pour multitenant. Userland est isolé. Vous pouvez maintenant séparer les préoccupations du protocole de service que vous utilisez, le type de base de données que vous utilisez, et juste se concentrer sur l'écriture de bon code.

parce que vous utilisez des couches, vous pouvez compter sur une seule source de vérité pour tout, à tout moment (l'objet de configuration en couches), et éviter les vérifications d'erreurs à chaque étape, s'inquiéter de " Oh merde, comment vais-je faire pour que ce fonctionne sans configuration appropriée?!?".

juste pour rendre cela aussi compliqué que possible, et d'apporter autant de paquets que possible...

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

cela vous permet de faire:

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

ou si vous utilisez async/wait:

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

l'avantage par rapport à l'utilisation de readFileSync est que votre serveur de noeud peut traiter d'autres requêtes pendant que le fichier est en lecture sur le disque.

si vous voulez ajouter quelques commentaires dans votre JSON et autoriser les virgules de queue, vous pouvez utiliser la mise en œuvre ci-dessous:

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

notez que cela pourrait ne pas bien fonctionner si vous avez quelque chose comme "abc": "foo // bar" dans votre JSON. Donc YMMV.

JSON.parse n'assurera pas la sécurité de la chaîne JSON que vous analysez. Vous devriez regarder une bibliothèque comme json-coffre-fort-analyser ou une bibliothèque semblable.

De json-coffre-fort-analyser les mnp page:

JSON.parse est grand, mais il a un défaut grave dans le contexte de JavaScript: il vous permet de passer outre les propriétés héritées. Cela peut devenir un problème si vous analysez JSON à partir d'une source non fiable (par exemple: un utilisateur), et l'appel des fonctions que vous attendez d'exister.

effet de levier de la fonction tentative de Lodash pour retourner un objet d'erreur, que vous pouvez gérer avec la fonction 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

Utilisez toujours JSON.analyser dans try catch bloc comme nœud de toujours jeter une Erreur Inattendue si vous avez quelques données corrompues dans votre json pour utiliser ce code à la place de simple JSON.Parse

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

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

si le fichier source JSON est assez grand, peut vouloir considérer la route asynchrone via async native / attente approche avec noeud.js 8.0 comme suit

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

cela a dû être crié à moi: cela ne fonctionne que pour les fichiers .json .

si la fin du fichier est différente, cela ne fonctionne pas!

vous pouvez utiliser JSON.parse () (qui est une fonction intégrée qui vous forcera probablement à l'envelopper avec des instructions try-catch).

Ou utiliser du JSON analyse mnp bibliothèque, quelque chose comme json-analyser-ou

utilisez ceci pour être du côté sûr

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

utilisez JSON.parse (str);

en savoir plus - JSON.analyser()

exemple -

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

obj = JSON.parse(jsonStr);

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

aucun autre module n'est requis.

Il suffit d'utiliser

var parsedObj = JSON.parse(yourObj);

Je ne pense qu'il y a des problèmes de sécurité concernant cette

c'est simple, vous pouvez convertir JSON en string en utilisant JSON.stringify(json_obj) , et convertir string en JSON en utilisant JSON.parse("your json string") .

var fs = require('fs');

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

   if(err) 
      throw err;

   else {

   console.log(data.toString());

 }
})