console.log()Jak mogę uzyskać pełny obiekt podczas debugowania za pomocą ?

const myObject = {
   "a":"a",
   "b":{
      "c":"c",
      "d":{
         "e":"e",
         "f":{
            "g":"g",
            "h":{
               "i":"i"
            }
         }
      }
   }
};    
console.log(myObject);

Wyjścia:

{ a: 'a', b: { c: 'c', d: { e: 'e', f: [Object] } } }

Ale chcę też zobaczyć zawartość nieruchomości f.

Musisz użyć util.inspect():

const util = require('util')

console.log(util.inspect(myObject, {showHidden: false, depth: null}))

// alternative shortcut
console.log(util.inspect(myObject, false, null, true /* enable colors */))

Wyjścia

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

Zobacz util.inspect()dokumenty .

Możesz użyć JSON.stringifyi 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, dzięki czemu można go dostosować zgodnie z potrzebami.

Więcej informacji tutaj w razie potrzeby:

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

^{Kompilacja wielu użytecznych odpowiedzi z (przynajmniej) Node.js v0.10.33(stabilny) / v0.11.14(niestabilny) prawdopodobnie poprzez (przynajmniej) v7.7.4(aktualną wersję z ostatniej aktualizacji tej odpowiedzi). Czubek kapelusza dla Rory O'Kane za 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()? Bo to już na samym wyjściu diagnostycznym console.log()i console.dir()jak również node.js REPL używać util.inspect() niejawnie . Zasadniczo nie jest koniecznerequire('util')util.inspect() bezpośrednie połączenie .

Szczegóły poniżej.

• console.log()(i jego alias console.info()):

  • Jeśli pierwszy argument NIE jest ciągiem formatu : 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 ]'
    • Należy pamiętać, że nie można przejść opcje poprzez util.inspect()w tym przypadku, co oznacza 2 znaczące ograniczenia:
      • Strukturalna głębokość wyjścia jest ograniczona do 2 poziomów (domyślnie).
        • Ponieważ nie możesz tego zmienić za pomocą console.log(), musisz zamiast tego użyć console.dir(): console.dir(myObject, { depth: null }wydruków z nieograniczoną głębią ; patrz poniżej.
      • Nie można włączyć kolorowania składni.
  • Jeśli pierwszy argument JEST łańcuchem formatu (patrz poniżej): używa util.format()do wydrukowania pozostałych argumentów na podstawie ciągu formatu (patrz poniżej); na przykład:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • Uwaga:
      • Nie ma symbolu zastępczego reprezentującego styl obiektów util.inspect() .
      • JSON wygenerowany przy pomocy %jNIE jest ładnie wydrukowany.

• console.dir():

  • Akceptuje tylko 1 argument do sprawdzenia i zawsze ma zastosowanie util.inspect()- zasadniczo opakowanie util.inspect()bez opcji domyślnie; na przykład:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.dir(o); // Effectively the same as console.log(o) in this case.
  • Node.js v0.11.14 + : Opcjonalny drugi argument określa opcje dlautil.inspect() - patrz poniżej; na przykład:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• REPL : domyślnie drukuje wartość zwrotną dowolnego wyrażenia za util.inspect() pomocą kolorowania składni ;
  tzn. wystarczy wpisać nazwę zmiennej i nacisnąć Enter, aby wydrukować sprawdzoną wersję jej wartości; na przykład:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()automatycznie ładnie drukuje reprezentacje obiektów i tablic , ale generuje wielowierszowe dane wyjściowe tylko w razie potrzeby .

• Zachowanie ładnego drukowania może być kontrolowane przez compactwłaściwość w opcjonalnym optionsargumencie; bezwarunkowofalse używa wyjścia wieloliniowego , a całkowicie wyłącza ładne drukowanie; można go również ustawić na liczbę (domyślnie jest to ), aby kontrolować warunkowe zachowanie wielu linii - patrz dokumentacja .true3

• Domyślnie, wynik jest zawijany na około 60 znaków ^{dzięki, Shrey} , niezależnie od tego, czy dane wyjściowe są wysyłane do pliku czy terminala. W praktyce, ponieważ podziały linii występują tylko na granicach właściwości , często kończy się to krótszymi liniami, ale mogą być one również dłuższe (np. Z długimi wartościami właściwości).

• W wersji 6.3.0 + możesz użyć breakLengthopcji, aby zastąpić limit 60 znaków; jeśli ustawisz na Infinity, wszystko jest wyprowadzane w jednym wierszu.

Jeśli chcesz mieć większą kontrolę nad ładnym drukowaniem, rozważ użycie JSON.stringify()trzeciego argumentu , ale zwróć uwagę na następujące kwestie :

• Nie działa z obiektami, które mają odwołania cykliczne , na przykład modulew kontekście globalnym.
• Metody (funkcje) z założenia NIE zostaną uwzględnione.
• Nie możesz włączyć wyświetlania ukrytych (niepoliczalnych) 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()obiekt opcji (drugi argument):

Można przekazać opcjonalny obiekt opcji, który zmienia niektóre aspekty sformatowanego ciągu; niektóre obsługiwane właściwości to:

^{Zobacz najnowsze dokumenty Node.js, aby uzyskać aktualną, pełną listę.}

• showHidden

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

• depth

  • informuje, ile razy ma się powtarzać podczas formatowania obiektu. Jest to przydatne do kontroli dużych skomplikowanych obiektów. Domyślnie jest to 2. Aby powtarzać się w nieskończoność, podaj null.

• colors

  • jeśli true, wówczas wyjście będzie stylizowane za pomocą kodów kolorów ANSI. Domyślnie to false. Kolory można dostosowywać [… - patrz link].

• customInspect

  • jeśli false, to inspect()funkcje niestandardowe zdefiniowane na kontrolowanych obiektach nie będą wywoływane. Domyślnie to true.

util.format()symbole zastępcze ciągu formatu (pierwszy argument)

Niektóre z obsługiwanych symboli zastępczych to:

^{Zobacz najnowsze dokumenty Node.js, aby uzyskać aktualną, pełną listę.}

• %s - Strunowy.
• %d - Liczba (zarówno liczba całkowita, jak i liczba zmiennoprzecinkowa).
• %j - JSON.
• %%- pojedynczy znak procentu („%”). To nie zużywa argumentu.

Inną prostą metodą jest konwersja do formatu json

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

Spróbuj tego:

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

Od wersji Node.js 6.4.0 można to elegancko rozwiązać za pomocą util.inspect.defaultOptions:

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

może console.dirto wszystko czego potrzebujesz.

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

Używa util.inspect na obj i wypisuje powstały ciąg na standardowe wyjście.

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

Możesz też zrobić

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

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

node.exe --inspect www.js

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

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

Nie ma potrzeby ponownego otwierania inspektora, łączy się on z węzłem automatycznie, gdy tylko węzeł się uruchomi lub uruchomi ponownie. Zarówno --inspect, jak i Chrome DevTools dla Node mogą nie być dostępne 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 może ci się to przydać.

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 tej odpowiedzi :

JSON.stringifyTrzeci parametr określa wstawianie białych znaków do ładnego drukowania. Może to być ciąg znaków lub liczba (liczba spacji).

Możesz po prostu dodać inspect()metodę do swojego obiektu, która zastąpi reprezentację obiektu w console.logwiadomościach

na przykład:

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

wtedy twój obiekt będzie reprezentowany zgodnie z wymaganiami zarówno w pliku console.log, jak i powłoce węzła

Prostą sztuczką byłoby użycie debugmodułu, aby dodać DEBUG_DEPTH=nulljako zmienną środowiskową podczas uruchamiania skryptu

Dawny.

DEBUG = * DEBUG_DEPTH = null node index.js

W twoim kodzie

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

Węzeł REPL ma wbudowane rozwiązanie do przesłonięcia sposobu wyświetlania obiektów, patrz tutaj .

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

Najłatwiejsza opcja:

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

JSON.stringify ()

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

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