Możesz użyć JSON.stringify i uzyskać ładne wcięcie, a także być może łatwiejszą do zapamiętania składnię.

console.log(JSON.stringify(myObject, null, 4));

{
    "a": "a",
    "b": {
        "c": "c",
        "d": {
            "e": "e",
            "f": {
                "g": "g",
                "h": {
                    "i": "i"
                }
            }
        }
    }
}

Trzeci argument ustawia poziom wcięcia, więc można go dostosować zgodnie z potrzebami.

Więcej szczegółów tutaj w razie potrzeby:

Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify

^{Kompilacja wielu przydatnych odpowiedzi z (przynajmniej) węzła.js v0.10.33 (stable) / v0.11.14 (unstable) prawdopodobnie przez (co najmniej) v7.7.4 (wersja aktualna od ostatniej aktualizacji do tej odpowiedzi). Napiwek dla Rory 'ego O' Kane ' a za jego pomoc.}

Tl; dr

Aby uzyskać pożądany wynik dla przykładu w pytaniu, użyj console.dir():

console.dir(myObject, { depth: null }); // `depth: null` ensures unlimited recursion

Dlaczego nie util.inspect()? Ponieważ jest już w samym sercu wyjścia diagnostycznego: console.log() i console.dir() oraz węzeł.js REPL użycie util.inspect() implicite. To ogólnie Nie konieczne do require('util') i zadzwoń util.inspect() bezpośrednio.

Szczegóły poniżej.

• console.log() (i jego pseudonim, console.info()):

  • jeśli pierwszy argument nie jest ciągiem formatującym: util.inspect() jest automatycznie stosowany do każdego argumentu:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • zauważ, że ty nie można przekazać opcji przez util.inspect() w tym przypadku, co oznacza 2 znaczące ograniczenia:
      • strukturalna głębokość wyjścia jest ograniczona do 2 poziomy (domyślne).
        • ponieważ nie możesz tego zmienić za pomocą console.log(), musisz zamiast tego użyć console.dir(): console.dir(myObject, { depth: null } wydruki z nieograniczoną głębokością ; patrz poniżej.
      Nie możesz włączyć kolorowania składni.
• jeśli pierwszy argument jest ciągiem formatującym (patrz niżej): używa util.format() wypisanie pozostałych argumentów na podstawie ciągu formatującego (patrz niżej); np.:
  • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
  • Uwaga:
    • nie ma elementu zastępczego do reprezentowania obiektów util.inspect()-Styl.
    • JSON wygenerowany przez {[22] } nie jest ładnie wydrukowany.

• REPL: domyślnie wyświetla wartość zwracaną dowolnego wyrażenia z util.inspect() ze składnią kolorowanki ;
  tzn. samo wpisanie nazwy zmiennej i naciśnięcie Enter wyświetli sprawdzoną wersję jej wartości; np.:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect() automatycznie ładuje obiekty I array reprezentacje , ale tworzy Wielowierszowe wyjście tylko w razie potrzeby .

• Zachowanie pretty-printing może być kontrolowane przez właściwość compact w opcji options argument; false używa wielowierszowego wyjścia bezwarunkowo , podczas gdy true całkowicie wyłącza drukowanie pretty; może być również ustawiony na numer (domyślnie jest to 3) do kontrolowania warunkowego zachowania wielowierszowego-zobacz dokumenty.

• Domyślnie wyjście jest owinięte na około 60 znaków ^{dzięki, Shrey} , niezależnie od tego, czy wyjście jest wysyłane do pliku czy do terminala. W praktyce, od linii przerwy zdarzają się tylko na granicach właściwości , często kończy się to krótszymi liniami, ale mogą być również dłuższe (np. z długimi wartościami właściwości).

• W wersji 6.3.0+ możesz użyć opcji breakLength, aby nadpisać limit 60 znaków; jeśli ustawisz go na Infinity, wszystko będzie wyświetlane na pojedynczej linii.

Jeśli chcesz mieć większą kontrolę nad drukowaniem, rozważ użycie JSON.stringify() Z trzecim argumentem , ale zwróć uwagę na po:

• nie działa z obiektami, które mają odniesienia okrągłe , takie jak module W kontekście globalnym.
• metody (funkcje) z założenia nie będą uwzględniane.
• nie można zdecydować się na wyświetlanie ukrytych (nieliczalnych) właściwości.
• przykładowe wywołanie:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect() options object (2nd argument):

Opcjonalne opcje można przekazać obiekt, który zmienia pewne aspekty sformatowanego ciągu znaków; niektóre obsługiwane właściwości to:

^{Zobacz najnowszy węzeł.js docs dla aktualnej, pełnej listy.}

• showHidden

  • jeśli true, wtedy wyświetlone zostaną również nieoznaczalne właściwości obiektu [te, które mają Nie pojawiać się podczas używania for keys in obj lub Object.keys(obj)]. Domyślnie: false.

• depth

  • mówi inspect ile razy rekurencyjnie formatować obiekt. Jest to przydatne do kontroli dużych skomplikowanych obiektów. Domyślnie 2. Aby uczynić go rekurencyjnym w nieskończoność, podaj null.

• colors

  • jeśli true, to wyjście będzie stylizowane na kod koloru ANSI. Domyślnie false. Kolory są konfigurowalne [...- zobacz link].

• customInspect

  • if false, then custom inspect() funkcje zdefiniowane na sprawdzanych obiektach nie będą wywoływane. Domyślnie true.

util.format() format-string placeholders (1. argument)

niektóre z obsługiwanych elementów zastępczych to:

^{Zobacz najnowszy węzeł.js docs dla aktualnej, pełnej listy.}

• %s – Sznurek.
• {–58]} - Liczba (zarówno liczba całkowita jak i zmiennoprzecinkowa).
• %j – JSON.
• %% - pojedynczy znak procentowy ('%'). To nie pochłania argumentów.

Inną prostą metodą jest przekonwertowanie go na json

console.log('connection : %j', myObject);

Spróbuj tego:

console.dir(myObject,{depth:null})

Od Węzła.js 6.4.0, można to elegancko rozwiązać za pomocą util.inspect.defaultOptions:

require("util").inspect.defaultOptions.depth = null;
console.log(myObject);

Być może console.dir to wszystko, czego potrzebujesz.

Http://nodejs.org/api/console.html#console_console_dir_obj

Używa util.sprawdź na obj i wydrukuj wynikowy ciąg na stdout.

Użyj opcji util, jeśli potrzebujesz większej kontroli.

Możesz również zrobić

console.log(JSON.stringify(myObject, null, 3));

Dobrym sposobem na sprawdzenie obiektów jest użycie opcji node --inspect z Chrome DevTools dla Node.

node.exe --inspect www.js

Otwórz chrome://inspect/#devices w chrome i kliknij Otwórz dedykowane narzędzia DevTools dla węzła

Teraz każdy zalogowany obiekt jest dostępny w Inspektorze jak zwykły JS działający w chrome.

Nie ma potrzeby ponownego otwierania Inspektora, łączy się on z węzłem automatycznie po uruchomieniu lub ponownym uruchomieniu węzła. Zarówno -- inspect i Chrome DevTools for node może nie być dostępny w starszych wersjach Node i Chrome.

Oba te zastosowania można zastosować:

// more compact, and colour can be applied (better for process managers logging)
console.dir(queryArgs, { depth: null, colors: true });

// get a clear list of actual values
console.log(JSON.stringify(queryArgs, undefined, 2));

Myślę, że to może być dla Ciebie przydatne.

const myObject = {
   "a":"a",
   "b":{
      "c":"c",
      "d":{
         "e":"e",
         "f":{
            "g":"g",
            "h":{
               "i":"i"
            }
         }
      }
   }
};

console.log(JSON.stringify(myObject, null, '\t'));

Jak wspomniano w ta odpowiedź :

JSON.stringify's trzeci parametr definiuje wstawianie białej przestrzeni dla ładny-druk. Może to być łańcuch lub liczba (liczba spacji).

Możesz po prostu dodać do obiektu metodę inspect(), która nadpisze reprezentację obiektu w wiadomościach console.log

Eg:

var myObject = {
   "a":"a",
   "b":{
      "c":"c",
      "d":{
         "e":"e",
         "f":{
            "g":"g",
            "h":{
               "i":"i"
            }
         }
      }
   }
};
myObject.inspect = function(){ return JSON.stringify( this, null, ' ' ); }

Następnie, Twój obiekt będzie reprezentowany zgodnie z wymaganiami w obu konsolach.log and node shell

Aktualizacja:

Obiekt.inspect został wycofany ( https://github.com/nodejs/node/issues/15549 ). użyj myObject [util.sprawdź.custom] zamiast:

const util = require('util')

var myObject = {
  /* nested properties not shown */
}

myObject[util.inspect.custom] = function(){ return JSON.stringify( this, null, 4 ); }


console.log(util.inspect(myObject))

Prostą sztuczką byłoby użycie modułu debug do dodania DEBUG_DEPTH=null jako zmiennej środowiskowej podczas uruchamiania skryptu

Ex.

DEBUG= * DEBUG_DEPTH = null node index.js

In you code

const debug = require('debug');
debug("%O", myObject);

Najprostsza opcja:

    console.log('%O', myObject);

REPL węzła ma wbudowane rozwiązanie do nadpisywania sposobu wyświetlania obiektów, zobacz tutaj .

Moduł REPL używa wewnętrznie util.inspect(), podczas drukowania wartości. Jednak util.inspect przekazuje wywołanie do obiektu inspect() funkcja, jeśli ją posiada.

JSON.stringify ()

let myVar = {a: {b: {c: 1}}};
console.log(JSON.stringify( myVar, null, 4 ))

Świetne do głębokiej inspekcji obiektów danych. To podejście działa na zagnieżdżonych tablicach i zagnieżdżonych obiektach z tablicami.

Jeśli szukasz sposobu na pokazanie ukrytych przedmiotów w tablicy, musisz przejść maxArrayLength: Infinity

console.log(util.inspect(value, { maxArrayLength: Infinity }));