javascript - Como analisar o JSON usando o Node.js?




(20)

É simples, você pode converter JSON em string usando JSON.stringify(json_obj) e converter string em JSON usando JSON.parse("your json string") .

Como devo analisar o JSON usando o Node.js? Existe algum módulo que irá validar e analisar o JSON de forma segura?


Analisando um fluxo JSON? Use 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


Aproveite a função de tentativa do Lodash para retornar um objeto de erro, que você pode manipular com a função 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

Certifique-se sempre de usar JSON.parse no try catch block, já que o node sempre lançará um erro inesperado se você tiver algum dado corrompido no seu json, então use este código em vez de simples JSON.Parse

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

Como você não sabe que sua string é realmente válida, eu colocaria primeiro em um try catch. Além disso, como os blocos try catch não são otimizados pelo nó, eu colocaria a coisa toda em outra função:

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

OU em "estilo assíncrono"

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

Eu uso fs-extra . Eu gosto muito porque, embora suporte callbacks, também suporta Promises . Por isso, apenas me permite escrever o meu código de uma forma muito mais legível:

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

Ele também tem muitos métodos úteis que não vêm junto com o módulo fs padrão e , além disso, também liga os métodos do módulo fs nativo e os promete.

NOTA: Você ainda pode usar os métodos nativos do Node.js. Eles são promisified e copiados para fs-extra. Veja as notas sobre fs.read() & fs.write()

Então é basicamente todas as vantagens. Espero que os outros achem isso útil.


Inclua a biblioteca node-fs .

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

Para mais informações sobre a biblioteca 'fs', consulte a documentação em http://nodejs.org/api/fs.html


Isso tinha que ser gritado comigo: só funciona para arquivos .json .

Se o final do arquivo é diferente, isso não funciona!


Minha solução:

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

Nenhum outro módulo precisa ser necessário.
Apenas use
var parsedObj = JSON.parse(yourObj);
Acho que não há problemas de segurança em relação a isso


Só quero completar a resposta (como eu lutei com isso por um tempo), quero mostrar como acessar as informações do json, este exemplo mostra o acesso ao 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);
  }
})


Se o arquivo de origem JSON for muito grande, considere a rota assíncrona por meio da abordagem async / await nativa com o Node.js 8.0 da seguinte forma

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

Todo mundo aqui falou sobre o JSON.parse, então eu pensei em dizer algo mais. Existe um ótimo módulo Connect com muitos middlewares para tornar o desenvolvimento de aplicativos mais fácil e melhor. Um dos middlewares é o bodyParser . Ele analisa JSON, html-forms e etc. Há também um middleware específico para JSON analisar apenas noop .

Dê uma olhada nos links acima, pode ser realmente útil para você.


Use JSON.parse(str); . Leia mais JSON.parse .

aqui estão alguns exemplos:

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

obj = JSON.parse(jsonStr);

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

Você pode usar JSON.parse () (que é uma função interna que provavelmente forçará você a envolvê-lo com instruções try-catch).

Ou use alguma biblioteca npm de análise JSON, algo como json-parse-or



Usando JSON para sua configuração com o Node.js? Leia isto e tenha suas habilidades de configuração acima de 9000 ...

Nota: Pessoas que reivindicam dados = require ('./ data.json'); é um risco de segurança e desvalorizar as respostas das pessoas com zelo zeloso: você está exatamente e completamente errado . Tente colocar o não-JSON nesse arquivo ... O nó lhe dará um erro, exatamente como faria se você fizesse a mesma coisa com o arquivo manual muito mais lento e difícil de ler e depois o JSON.parse () subsequente. Por favor, pare de espalhar informações erradas; Você está ferindo o mundo, não ajudando. O nó foi projetado para permitir isso; não é um risco de segurança!

Aplicativos apropriados vêm em 3 + camadas de configuração:

  1. Configuração do servidor / contêiner
  2. Configuração da aplicação
  3. (opcional) Configuração do Inquilino / Comunidade / Organização
  4. Configuração do usuário

A maioria dos desenvolvedores trata o servidor e a configuração do aplicativo como se ele pudesse mudar. Não pode. Você pode estratificar as alterações das camadas superiores umas sobre as outras, mas está modificando os requisitos básicos . Algumas coisas precisam existir! Faça sua configuração agir como se ela fosse imutável, porque parte dela é basicamente igual ao seu código-fonte.

Deixar de ver que muitas das suas coisas não vão mudar depois que a inicialização levar a antipadrões, como colocar lixo no seu carregamento de configuração com blocos try / catch, e fingir que você pode continuar sem o aplicativo de configuração correto. Você não pode. Se você puder, isso pertence à camada de configuração de comunidade / usuário, não à camada de configuração de servidor / aplicativo. Você está apenas fazendo errado. O material opcional deve ser colocado no topo quando o aplicativo terminar sua inicialização.

Pare de bater a cabeça contra a parede: sua configuração deve ser ultra simples .

Veja como é fácil configurar algo tão complexo quanto uma estrutura de serviço agnóstica e independente de fonte de dados usando um simples arquivo de configuração json e um simples arquivo app.js ...

container-config.js ...

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

index.js ... (o mecanismo que alimenta tudo)

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 ... (o código que aciona seu serviço agnóstico independente de protocolo e fonte de dados)

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

Usando esse padrão, agora você pode carregar o material de configuração da comunidade e do usuário sobre o seu aplicativo inicializado, dev ops está pronto para colocar seu trabalho em um contêiner e escalá-lo. Você é lido por vários usuários. Userland é isolado. Agora você pode separar as preocupações de qual protocolo de serviço você está usando, qual tipo de banco de dados você está usando e apenas focar em escrever um código bom.

Porque você está usando camadas, você pode confiar em uma única fonte de verdade para tudo, a qualquer momento (o objeto de configuração em camadas), e evitar verificações de erros a cada passo, preocupando-se com "oh merda, como eu vou fazer isso trabalhe sem configuração adequada?!? ".


Você pode usar JSON.parse .

Você deve ser capaz de usar o objeto JSON em qualquer implementação JavaScript compatível com ECMAScript 5 . E o V8 , no qual o Node.js é construído, é um deles.

Analisando uma string contendo dados JSON

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

Analisando um arquivo contendo dados JSON

Você terá que fazer algumas operações de arquivo com o módulo fs .

Versão assíncrona

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

Versão síncrona

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

Você quer usar require ? Pense de novo!

Você pode, às vezes, usar require :

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

Mas eu não recomendo isso por vários motivos:

Nota: Se você estiver usando um arquivo JSON para armazenar informações confidenciais (por exemplo, senhas), essa é a maneira errada de fazer isso. Veja como o Heroku faz isso: https://devcenter.heroku.com/articles/config-vars#setting-up-config-vars-for-a-deployed-application . Descubra como sua plataforma faz isso e use process.env para recuperar o config vars de dentro do código.

  1. require é síncrono. Se você tiver um arquivo JSON muito grande, ele irá sufocar o seu loop de eventos. Você realmente precisa usar JSON.parse com fs.readFile .
  2. require irá ler o arquivo apenas uma vez . Chamadas subseqüentes para require o mesmo arquivo retornará uma cópia em cache. Não é uma boa ideia se você quiser ler um arquivo .json que é continuamente atualizado. Você poderia usar um hack . Mas neste momento, é mais fácil simplesmente usar o fs .
  3. Se o seu arquivo não tiver uma extensão .json , require não tratará o conteúdo do arquivo como JSON.

A sério! Use JSON.parse .

load-json-file module

Se você estiver lendo um grande número de arquivos .json , (e se você é extremamente preguiçoso), torna-se chato escrever código clichê todas as vezes. Você pode salvar alguns caracteres usando o módulo load-json-file .

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

Versão assíncrona

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

Versão síncrona

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

Analisando JSON de fluxos

Se o conteúdo JSON for transmitido pela rede, você precisará usar um analisador JSON de streaming. Caso contrário, ele amarrará seu processador e sufocará o loop de eventos até que o conteúdo JSON seja totalmente transmitido.

Existem muitos pacotes disponíveis no NPM para isso. Escolha o que é melhor para você.

Tratamento de Erros / Segurança

Se você não tiver certeza se o que é transmitido para JSON.parse() é um JSON válido , certifique-se de colocar a chamada em JSON.parse() dentro de um bloco try/catch . Uma string JSON fornecida pelo usuário pode travar seu aplicativo e pode levar a falhas de segurança. Certifique-se de que a manipulação de erros seja feita se você analisar JSON fornecido externamente.


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

var fs = require('fs');

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

   if(err) 
      throw err;

   else {

   console.log(data.toString());

 }
})




node.js