Jak parsować JSON przy użyciu Node.js?

971

Jak mam przeanalizować JSON za pomocą Node.js? Czy jest jakiś moduł, który bezpiecznie zweryfikuje i parsuje JSON?

Tikhon Jelvis
źródło

Odpowiedzi:

1099

Możesz po prostu użyć JSON.parse.

Definicja JSONobiektu jest częścią specyfikacji ECMAScript 5 . node.js jest oparty na silniku V8 Google Chrome , który jest zgodny ze standardem ECMA. Dlatego node.js ma również obiekt globalny [docs] .JSON

Uwaga - JSON.parsemoże powiązać bieżący wątek, ponieważ jest to metoda synchroniczna. Jeśli więc planujesz parsować duże obiekty JSON, użyj parsera strumieniowego json.

Felix Kling
źródło
Czy ktoś wie, dlaczego nie ma tego w oficjalnej dokumentacji? A jeśli tak, to gdzie go znaleźć?
snapfractalpop
34
@snapfractalpop: Dokumentacja opisuje tylko funkcje itp., które są częścią node.js. Standardowe funkcje JavaScript są częścią V8 , na której znajduje się node.js. Odpowiednio zaktualizowałem odpowiedź.
Felix Kling
1
@FelixKling Jeśli chodzi o to, co jest warte, tutaj jest mnóstwo rzeczy na wiki github: github.com/joyent/node/wiki/…
damianb
tutaj opublikowałem demo, w którym możesz zobaczyć i pobawić się tą odpowiedzią online (przykład parsowania znajduje się w pliku app.js - następnie kliknij przycisk Uruchom i zobacz wynik w terminalu): link możesz zmodyfikować kod i zobacz wpływ ...
nathan g
Twoja odpowiedź wymaga wcześniejszej znajomości składni JavaScript. Jak trudno byłoby pokazać przykład użycia? JSON.parse (str); // jest przyjazny dla nooba i dlatego jest lepszą odpowiedzią
webb
661

możesz wymagać plików .json.

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

Na przykład, jeśli config.jsonplik znajduje się w tym samym katalogu, co plik kodu źródłowego, należy użyć:

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

lub (rozszerzenie pliku można pominąć):

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

zauważ, że requirejest synchroniczny i czyta plik tylko raz , kolejne wywołania zwracają wynik z pamięci podręcznej

Pamiętaj również, że powinieneś używać tego tylko do plików lokalnych pod twoją absolutną kontrolą, ponieważ potencjalnie wykonuje on dowolny kod w pliku.

eliocs
źródło
4
Jeśli używasz tej metody do parsowania pliku, upewnij się, że uwzględniłeś ścieżkę dla wymagania. Na przykład może być konieczne zrobienie czegoś takiego: wymaga './nazwa_pliku-z-dodatkowym rozszerzeniem' (na przykład, jeśli plik znajduje się w bieżącym katalogu)
SnapShot
94
Pamiętaj, że odpowiedź jest buforowana. Np. Jeśli wstawisz powyżej wymagaj wywołania funkcji, wywołaj funkcję, zmień plik JSON i ponownie wywołaj funkcję, otrzymasz starą wersję pliku JSON. Kilka razy mnie złapał!
Ben Clayton
15
Zauważ też, że requirejest synchroniczny. Jeśli fs.readFilezamiast tego chcesz zsynchronizować przyjazne użycieJSON.parse
Evan Moran
29
Czy takie podejście potraktuje plik jako JavaScript, a tym samym potencjalnie uruchomi dowolny kod w pliku .json?
d11wtq
15
Prosta uwaga: nie zapomnij użyć .jsonrozszerzenia! Jeśli twój plik NIE ma .jsonrozszerzenia, polecenie wymaga nie będzie traktować go jako pliku json.
Jason
323

Możesz użyćJSON.parse() .

Powinieneś być w stanie używać tego JSONobiektu w dowolnej implementacji JavaScript kompatybilnej z ECMAScript 5 . I V8 , na którym zbudowano Node.js, jest jednym z nich.

Uwaga: jeśli używasz pliku JSON do przechowywania poufnych informacji (np. Haseł), jest to niewłaściwy sposób. Zobacz, jak robi to Heroku: https://devcenter.heroku.com/articles/config-vars#setting-up-config-vars-for-a-deployed-application . Dowiedz się, jak robi to Twoja platforma, i użyj, process.envaby pobrać zmienne konfiguracji z kodu.


Analizowanie ciągu zawierającego dane JSON

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

Analizowanie pliku zawierającego dane JSON

Będziesz musiał wykonać kilka operacji na plikach za pomocą fsmodułu.

Wersja asynchroniczna

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

Wersja synchroniczna

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

Chcesz użyć require? Pomyśl jeszcze raz!

Czasami możesz użyćrequire :

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

Ale nie polecam tego z kilku powodów:

  1. requirejest synchroniczny. Jeśli masz bardzo duży plik JSON, dusi on twoją pętlę zdarzeń. Naprawdę trzeba korzystać JSON.parsez fs.readFile.
  2. requireodczyta plik tylko raz . Kolejne wywołania requiretego samego pliku zwrócą kopię z pamięci podręcznej. Nie jest to dobry pomysł, jeśli chcesz czytać .jsonplik, który jest stale aktualizowany. Możesz użyć hacka . Ale w tym momencie łatwiej jest po prostu użyć fs.
  3. Jeśli plik nie ma .jsonrozszerzenia, requirenie będzie traktować zawartości pliku jako JSON.

Poważnie! ZastosowanieJSON.parse .


load-json-file moduł

Jeśli czytasz dużą liczbę .jsonplików (i jesteś wyjątkowo leniwy), pisanie kodu bojlera za każdym razem staje się denerwujące. Możesz zapisać niektóre znaki za pomocą load-json-filemodułu.

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

Wersja asynchroniczna

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

Wersja synchroniczna

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

Przetwarzanie JSON ze strumieni

Jeśli zawartość JSON jest przesyłana strumieniowo przez sieć, musisz użyć analizatora składni JSON przesyłanego strumieniowo. W przeciwnym razie spowoduje to powiązanie procesora i uduszenie pętli zdarzeń do momentu pełnego przesłania treści JSON.

W tym celu dostępnych jest wiele pakietów w NPM . Wybierz to, co dla Ciebie najlepsze.


Obsługa błędów / bezpieczeństwo

Jeśli nie masz pewności, czy cokolwiek, co jest przekazywane, JSON.parse()jest poprawnym JSON , upewnij się, że dołączasz wywołanie do JSON.parse()wewnątrz try/catchbloku. Podany przez użytkownika ciąg JSON może spowodować awarię aplikacji, a nawet doprowadzić do luk w zabezpieczeniach. Upewnij się, że obsługa błędów jest wykonywana, jeśli analizujesz JSON podany zewnętrznie.

sampathsris
źródło
2
and could even lead to security holesz ciekawości, jak?
natario
6
@natario: Mówimy tutaj o JS po stronie serwera. Załóżmy, że ktoś analizuje dostarczony przez użytkownika JSON. Jeśli założeniem jest, że JSON jest zawsze dobrze sformułowany, osoba atakująca może wysłać nieco zniekształcony JSON, aby wyzwolić błąd, który po rozlaniu na stronę klienta może ujawnić istotne informacje o systemie. Lub jeśli JSON był zniekształcony i zawierał tekst <script>..., a błąd został przelany na stronę klienta, masz tam błąd XSS. Dlatego IMO jest ważne, aby obsługiwać błędy JSON dokładnie tam, gdzie je analizujesz.
sampathsris,
1
@NickSteele: Jednak zmieniłem „to nie jest zalecane” na „nie polecam”. Mam nadzieję, że jesteś teraz szczęśliwy.
sampathsris
1
@NickSteele: Biorąc pod uwagę wymienione przeze mnie wady, nie sądzę, aby była to dobrze zaprojektowana funkcja. Wydaje mi się, że niektórzy ludzie myśleli „hej, czy nie byłoby fajnie zastosować requireJSON?” i nawet nie zawracał sobie głowy dokumentowaniem skutków ubocznych. Oznaczało to również, że wymagany akceptuje pliki w dwóch językach: JavaScript i JSON (nie, nie są takie same). Tyle o SRP.
sampathsris,
1
@NickSteele: Tak, tylko dla konfiguracji działa poprawnie. Ale JSON nie jest używany tylko do konfiguracji.
sampathsris
85

użyj obiektu JSON :

JSON.parse(str);
Mark Kahn
źródło
12
To tylko powiela najlepszą odpowiedź. Proszę rozważyć usunięcie; zatrzymasz punkty.
Dan Dascalescu
6
Ta odpowiedź ma 50 głosów pozytywnych. Zgodnie z zasadą 1% prawdopodobnie 5000 użytkowników spędzało czas na czytaniu tej odpowiedzi, co nie dodaje niczego do pierwszej. Fakt, że ma 3 lata, tylko pogarsza problem :)
Dan Dascalescu
16
@DanDascalescu - Jeśli zauważysz, dwie odpowiedzi zostały opublikowane dokładnie w tym samym czasie 3 lata temu. Oba zapewniają te same informacje. Tak jest w przypadku całego SO, nie zamierzam wybierać połowy moich odpowiedzi tylko dlatego, że nie były to zaakceptowane odpowiedzi.
Mark Kahn
8
Dla mnie ta seria komentarzy była dość interesująca, ale sama odpowiedź była stratą czasu. ... Nie jestem pewien, czy to sugeruje, że odpowiedź powinna zostać usunięta, ponieważ wtedy nie widziałbym wątku komentarza. Ale inaczej powiedziałbym tak.
MalcolmOcean
7
@DanDascalescu, uważam, że ta odpowiedź jest jaśniejsza i od razu do rzeczy. Ten zaakceptowany nie podaje przykładu użycia i jest mylący z powodu wielu linków i dodatkowych elementów.
andresgottlieb
37

Kolejny przykład 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);
});
piractwo
źródło
2
Podoba mi się, że to podejście nie wymaga, aby plik json był lokalny dla aplikacji. Dziękuję Ci!
Charles Brandt
35

Chciałbym wspomnieć, że istnieją alternatywy dla globalnego obiektu JSON. JSON.parsei JSON.stringifyoba są synchroniczne, więc jeśli chcesz radzić sobie z dużymi obiektami, możesz chcieć sprawdzić niektóre asynchroniczne moduły JSON.

Zobacz: https://github.com/joyent/node/wiki/Modules#wiki-parsers-json

Haider
źródło
1
Jest to szczególnie prawdziwe, jeśli oczekuje się danych JSON z połączeń przychodzących. Jeśli zniekształcony JSON jest analizowany przez JSON.parsecałą aplikację ulegnie awarii lub, przy użyciu process.on('uncaughtException', function(err) { ... });, ostatecznie nie będzie szansy na wysłanie użytkownikowi błędu „źle zniekształcony JSON”.
Paul
3
Który to asyncparser? Nie znalazłem tego.
bxshi
3
Połączona strona jest teraz oznaczona „DEPRECATED” i opisuje się jako „wyblakły relikt”.
nikt
30

Dołącz node-fsbibliotekę.

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

Aby uzyskać więcej informacji na temat biblioteki „fs”, zapoznaj się z dokumentacją pod adresem http://nodejs.org/api/fs.html

Abhishek Verma
źródło
2
Warto zauważyć, że powinieneś zawinąć linię pliku var w try / catch na wypadek, gdyby Twój JSON nie parsował lub plik nie istnieje.
Fostah
3
Lub po prostu skorzystaj z oddzwaniania!
lawx
10

Ponieważ nie wiesz, że Twój ciąg jest rzeczywiście prawidłowy, postawiłbym go na pierwszym miejscu w próbach catch. Ponieważ bloki try catch nie są zoptymalizowane według węzłów, chciałbym umieścić całą tę funkcję w innej funkcji:

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

LUB w „stylu asynchronicznym”

function tryParseJson(str, callback) {
    process.nextTick(function () {
      try {
          callback(null, JSON.parse(str));
      } catch (ex) {
          callback(ex)
      }
    })
}
Vlad
źródło
2
Chcę tylko zauważyć, że proces.nextTick nie jest aysnc. Po prostu odkłada czytanie pliku do następnego wywołania funkcji w pętli zdarzeń JS. Aby asynchronicznie uruchomić JSON.parse, musisz użyć innego wątku niż główny wątek Node.js
Alexander Mills,
9

Analizujesz strumień JSON? Zastosowanie 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

Burcu Dogan
źródło
7

Wszyscy tutaj opowiadali o JSON.parse, więc pomyślałem o czymś innym. Istnieje świetny moduł Połącz z wieloma oprogramowaniem pośredniczącym, aby ułatwić i usprawnić tworzenie aplikacji. Jednym z programów pośrednich jest bodyParser . Analizuje JSON, formularze HTML itp. Istnieje również specyficzne oprogramowanie pośrednie do analizowania JSON tylko noop .

Spójrz na powyższe linki, może to być naprawdę pomocne.

Saransh Mohapatra
źródło
7
JSON.parse("your string");

To wszystko.

debianmaster
źródło
6

jak wspomniano w innych odpowiedziach, prawdopodobnie potrzebujesz albo lokalnego pliku json, o którym wiesz, że jest bezpieczny i obecny, jak plik konfiguracyjny:

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

lub użyć globalnego obiektu JSON do parsowania wartości ciągu na obiekt:

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

zwróć uwagę, że gdy potrzebujesz pliku, jego zawartość jest oceniana, co stwarza zagrożenie bezpieczeństwa w przypadku, gdy nie jest to plik json, ale plik js.

tutaj opublikowałem demo, w którym możesz zobaczyć obie metody i grać z nimi online (przykład parsowania znajduje się w pliku app.js - następnie kliknij przycisk Uruchom i zobacz wynik w terminalu): http: // staging1 .codefresh.io / labs / api / env / json-parse-example

możesz zmodyfikować kod i zobaczyć wpływ ...

nathan g
źródło
5

Używasz JSON do konfiguracji z Node.js? Przeczytaj to i zdobądź umiejętności konfiguracyjne ponad 9000 ...

Uwaga: osoby twierdzące, że dane = wymagają („./ data.json”); jest zagrożeniem dla bezpieczeństwa i odrzuca odpowiedzi ludzi z gorliwym zapałem: Dokładnie i całkowicie się mylisz . Spróbuj umieścić plik inny niż JSON w tym pliku ... Węzeł wyświetli błąd, dokładnie tak , jak gdyby zrobiłeś to samo z dużo wolniejszym i trudniejszym kodowaniem ręcznego odczytu pliku, a następnie JSON.parse (). Przestańcie rozpowszechniać dezinformacje; ranisz świat, nie pomagasz. Węzeł został zaprojektowany, aby to umożliwić; to nie jest zagrożenie bezpieczeństwa!

Odpowiednie aplikacje są dostępne w ponad 3 warstwach konfiguracji:

  1. Konfiguracja serwera / kontenera
  2. Konfiguracja aplikacji
  3. (opcjonalnie) Konfiguracja dzierżawcy / społeczności / organizacji
  4. Konfiguracja użytkownika

Większość programistów traktuje konfigurację serwera i aplikacji tak, jakby mogła się zmienić. Nie może Możesz nakładać na siebie zmiany z wyższych warstw, ale modyfikujesz wymagania podstawowe . Niektóre rzeczy muszą istnieć! Spraw, by twoja konfiguracja zachowywała się tak, jakby była niezmienna, ponieważ niektóre z nich są po prostu, podobnie jak kod źródłowy.

Brak dostrzeżenia, że ​​wiele rzeczy nie zmieni się po uruchomieniu, prowadzi do anty-wzorców, takich jak zaśmiecanie konfiguracji ładowaniem blokami try / catch i udawanie, że możesz kontynuować bez poprawnie skonfigurowanej aplikacji. Nie możesz Jeśli możesz, należy do warstwy konfiguracji społeczności / użytkowników, a nie warstwy konfiguracji serwera / aplikacji. Po prostu źle to robisz. Opcjonalne elementy należy nakładać warstwami na wierzch, gdy aplikacja zakończy ładowanie.

Przestań walić głową w ścianę: Twoja konfiguracja powinna być bardzo prosta .

Zobacz, jak łatwo jest skonfigurować coś tak złożonego, jak platforma usługowa niezależna od protokołu i od źródła danych przy użyciu prostego pliku konfiguracyjnego json i prostego pliku 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 ... (silnik, który napędza wszystko)

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 ... (kod, który zasila twoją usługę agnostyczną niezależną od protokołu i źródła danych)

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

Korzystając z tego wzorca, możesz teraz załadować elementy konfiguracji społeczności i użytkowników na uruchomioną aplikację, programista jest gotowy, aby wrzucić twoją pracę do kontenera i skalować. Jesteś czytany za multitenanta. Userland jest odizolowany. Możesz teraz rozdzielić obawy dotyczące używanego protokołu usługi, używanego typu bazy danych i skoncentrować się na pisaniu dobrego kodu.

Ponieważ używasz warstw, można polegać na jednym źródle prawdy za wszystko, w dowolnym momencie (warstwowy obiektu config) i kontroli błędów unikać na każdym kroku, martwiąc się o „O cholera, jak mam zamiar zrobić to pracować bez odpowiedniej konfiguracji?!? ".

Nick Steele
źródło
4

Moje rozwiązanie:

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);
});
Ravindra Galav
źródło
Dzięki @eloyesp, próbowałem użyć tego kodu, ale wciąż pojawiają się TypeError: path must be a string or Bufferbłędy - jakiś pomysł, od czego zacząć debugowanie tego problemu?
GPP
4

Po prostu chcę uzupełnić odpowiedź (ponieważ zmagałem się z nią przez chwilę), chcę pokazać, jak uzyskać dostęp do informacji json, ten przykład pokazuje dostęp do tablicy 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);
  }
})

Eli
źródło
3

Aby uczynić to tak skomplikowanym, jak to możliwe i przynieść jak najwięcej paczek, jak to możliwe ...

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

Pozwala to na:

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

Lub jeśli używasz asynchronizacji / czekaj:

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

Zaletą readFileSynctego jest fakt, że serwer Node może przetwarzać inne żądania podczas odczytywania pliku z dysku.

mpen
źródło
2

JSON.parse nie zapewni bezpieczeństwa analizowanego ciągu json. Powinieneś spojrzeć na bibliotekę taką jak json-safe-pars lub podobną bibliotekę.

Ze strony json-safe-parse npm:

JSON.parse jest świetny, ale ma jedną poważną wadę w kontekście JavaScript: pozwala zastąpić odziedziczone właściwości. Może to stać się problemem, jeśli analizujesz JSON z niezaufanego źródła (np. Użytkownika) i wywołujesz funkcje na nim, które prawdopodobnie istniałyby.

Timothy C. Quinn
źródło
2

Wykorzystaj funkcję prób Lodash, aby zwrócić obiekt błędu, który możesz obsłużyć za pomocą funkcji 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
l3x
źródło
3
Czy możesz wyjaśnić, dlaczego dodałeś .bindzamiast po prostu używać _.attempt (JSON.parse, str)
steviejay,
2

Zawsze upewnij się, że używasz JSON.parse w try catch catch , ponieważ węzeł zawsze generuje nieoczekiwany błąd, jeśli masz jakieś uszkodzone dane w swoim jsonie, więc użyj tego kodu zamiast prostego JSON.Parse

try{
     JSON.parse(data)
}
catch(e){
   throw new Error("data is corrupted")
  }
Rahul Kamboj
źródło
1

Jeśli chcesz dodać kilka komentarzy do swojego JSON i zezwolić na przecinki końcowe, możesz użyć poniższej implementacji:

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

Pamiętaj, że może nie działać dobrze, jeśli masz coś takiego "abc": "foo // bar"w swoim JSON. Więc YMMV.

Nux
źródło
1

Jeśli plik źródłowy JSON jest dość duży, warto rozważyć trasę asynchroniczną za pomocą natywnego asynchronizacji / oczekiwania na Node.js 8.0 w następujący sposób

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))
Lae Kettavong
źródło
1

Używam fs-extra . Bardzo mi się podoba, ponieważ - choć obsługuje oddzwanianie - obsługuje także obietnice . Pozwala mi to po prostu napisać kod w znacznie bardziej czytelny sposób:

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

Ma również wiele przydatnych metod, które nie są dostarczane wraz ze standardowym fsmodułem, a ponadto łączy je z fsmodułem macierzystym i obiecuje.

UWAGA: Nadal możesz używać natywnych metod Node.js. Są obiecane i kopiowane do fs-extra. Zobacz uwagi na temat fs.read()&fs.write()

To w zasadzie wszystkie zalety. Mam nadzieję, że inni uznają to za przydatne.

Mig82
źródło
1

Jeśli chcesz parsować JSON z Node.js w bezpieczny sposób (aka: użytkownik może wprowadzać dane lub publiczny interfejs API) sugerowałbym użycie bezpiecznego parsowania .

Użycie jest jak domyślne, JSON.parseale ochroni Twój kod przed:

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
Manuel Spigolon
źródło
0

Możesz użyć JSON.parse () (która jest wbudowaną funkcją, która prawdopodobnie zmusi cię do zawinięcia jej instrukcjami try-catch).

Lub użyj biblioteki JSON do analizowania npm, na przykład json-parse-or

C'estLaVie
źródło
0

Użyj tego, aby być po bezpiecznej stronie

var data = JSON.parse(Buffer.concat(arr).toString());
Victor Michael Kosgei
źródło
0

NodeJs jest serwerem opartym na JavaScript , więc możesz robić to tak, jak w czystym JavaScript ...

Wyobraź sobie, że to Json w NodeJs ...

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

Możesz to zrobić powyżej, aby uzyskać parsowaną wersję swojego jsona ...

Alireza
źródło
0

Jak wspomniano w powyższych odpowiedziach, możemy użyć JSON.parse()do parsowania napisów do JSON. Ale przed parsowaniem upewnij się, że parsujesz poprawne dane, w przeciwnym razie może to doprowadzić do awarii całej aplikacji

można go bezpiecznie używać w ten sposób

let parsedObj = {}
try {
    parsedObj = JSON.parse(data);
} catch(e) {
    console.log("Cannot parse because data is not is proper json format")
}
Shekar Mania
źródło
0

Zastosowanie JSON.parse(str);. Przeczytaj więcej na ten temat tutaj .

Oto kilka przykładów:

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

obj = JSON.parse(jsonStr);

console.log(obj.count);    // expected output: 42
console.log(obj.result);   // expected output: true
Praveen Poonia
źródło
-1

Nie są wymagane żadne dodatkowe moduły.
Po prostu użyj.
var parsedObj = JSON.parse(yourObj);
Nie sądzę, żeby były z tym jakieś problemy związane z bezpieczeństwem

Sachin S.
źródło
-2

To proste, możesz przekonwertować JSON na ciąg za pomocą JSON.stringify(json_obj)i przekonwertować ciąg na JSON za pomocą JSON.parse("your json string").

00imvj00
źródło
2
Czy spojrzałeś na najlepszą odpowiedź na to pytanie? Ma 3 lata i jest bardzo kompletny. Co chciałeś przekazać w trywialnych informacjach, które tutaj oferujesz?
Robby Cornelissen
2
Teraz nie trzymajmy się podwójnego standardu
danielmhanover