console.log()Wie kann ich beim Debuggen mit das vollständige Objekt abrufen?

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

Ausgänge:

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

Ich möchte aber auch den Inhalt des Eigentums sehen f.

Sie müssen verwenden 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 */))

Ausgänge

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

Siehe util.inspect()Dokumente .

Sie können verwenden JSON.stringifyund erhalten einige schöne Einrückungen sowie vielleicht leichter zu merkende Syntax.

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

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

Das dritte Argument legt die Einrückungsstufe fest, sodass Sie diese nach Bedarf anpassen können.

Weitere Details hier bei Bedarf:

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

^{Eine Zusammenstellung der vielen nützlichen Antworten von (mindestens) Node.js v0.10.33(stabil) / v0.11.14(instabil) vermutlich bis (mindestens) v7.7.4(die aktuelle Version zum letzten Update dieser Antwort). Tipp des Hutes an Rory O'Kane für seine Hilfe.}

tl; dr

Verwenden Sie console.dir(): Um die gewünschte Ausgabe für das Beispiel in der Frage zu erhalten :

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

Warum nicht util.inspect()? Weil es bereits das Herzstück der Diagnoseausgabe ist: console.log()und console.dir()ebenso wie die implizite Verwendung vonutil.inspect() Node.js REPL . Es ist in der Regel nicht erforderlich,require('util')util.inspect() direkt anzurufen .

Details unten.

• console.log()(und sein Alias console.info()):

  • Wenn das erste Argument KEINE Formatzeichenfolge ist : util.inspect()wird automatisch auf jedes Argument angewendet:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • Beachten Sie, dass Sie in diesem Fall keine Optionen weitergeben können util.inspect(), was zwei bemerkenswerte Einschränkungen impliziert:
      • Die strukturelle Tiefe der Ausgabe ist auf 2 Ebenen begrenzt (Standardeinstellung).
        • Da Sie dies nicht ändern können console.log(), müssen Sie stattdessen Folgendes verwenden console.dir(): console.dir(myObject, { depth: null }Drucke mit unbegrenzter Tiefe ; siehe unten.
      • Sie können die Syntaxfärbung nicht aktivieren.
  • Wenn das erste Argument eine Formatzeichenfolge ist (siehe unten): Wird verwendet util.format(), um die verbleibenden Argumente basierend auf der Formatzeichenfolge zu drucken (siehe unten). z.B:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • Hinweis:
      • Es gibt KEINE Platzhalter für die Darstellung von Objekten util.inspect() -Stil.
      • JSON, das mit generiert wurde, %jist NICHT hübsch gedruckt.

• console.dir()::

  • Akzeptiert nur 1 zu prüfendes Argument und gilt immer util.inspect()- im Wesentlichen ein Wrapper für util.inspect()standardmäßig ohne Optionen; z.B:
    • 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 + : Das optionale 2. Argument gibt Optionen fürutil.inspect() - siehe unten an; z.B:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• Die REPL : gibt implizit den Rückgabewert eines Ausdrucks util.inspect() mit Syntaxfarbe aus .
  Wenn Sie also nur den Namen einer Variablen eingeben und die Eingabetaste drücken, wird eine überprüfte Version ihres Werts gedruckt. z.B:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()druckt Objekt- und Array- Darstellungen automatisch hübsch aus , erzeugt jedoch nur bei Bedarf eine mehrzeilige Ausgabe .

• Das hübsche Druckverhalten kann durch die compactEigenschaft im optionalen optionsArgument gesteuert werden . falseverwendet die mehrzeilige Ausgabe bedingungslos , während truedas hübsche Drucken insgesamt deaktiviert wird. Es kann auch eine Zahl festgelegt werden (die Standardeinstellung ist 3), um das bedingte mehrzeilige Verhalten zu steuern - siehe Dokumente .

• Standardmäßig wird die Ausgabe ^{dank Shrey} mit etwa 60 Zeichen ^umbrochen , unabhängig davon, ob die Ausgabe an eine Datei oder ein Terminal gesendet wird. Da Zeilenumbrüche in der Praxis nur an Eigenschaftsgrenzen auftreten , werden häufig kürzere Zeilen angezeigt, die jedoch auch länger sein können (z. B. bei langen Eigenschaftswerten).

• In Version 6.3.0 + können Sie die breakLengthOption verwenden, um die Beschränkung auf 60 Zeichen zu überschreiben. Wenn Sie es einstellen, Infinitywird alles in einer einzigen Zeile ausgegeben .

Wenn Sie mehr Kontrolle über das hübsche Drucken wünschen, sollten Sie JSON.stringify()ein drittes Argument verwenden . Beachten Sie jedoch Folgendes:

• Fails mit Objekten , die haben zirkuläre Referenzen , wie moduleim globalen Kontext.
• Methoden (Funktionen) werden von Natur aus NICHT berücksichtigt.
• Sie können sich nicht dafür entscheiden, versteckte (nicht aufzählbare) Eigenschaften anzuzeigen.
• Beispielaufruf:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect()Optionsobjekt (2. Argument):

Es kann ein optionales Optionsobjekt übergeben werden, das bestimmte Aspekte der formatierten Zeichenfolge ändert. Einige der unterstützten Eigenschaften sind:

^{Die aktuelle vollständige Liste finden Sie in den neuesten Node.js-Dokumenten .}

• showHidden

  • Wenn true, werden auch die nicht aufzählbaren Eigenschaften des Objekts angezeigt [diejenigen, die bei Verwendung von for keys in objoder Object.keys(obj)nicht angezeigt werden sollen]. Der Standardwert ist false.

• depth

  • weist an, zu überprüfen, wie oft beim Formatieren des Objekts eine Rekursion durchgeführt werden soll. Dies ist nützlich, um große komplizierte Objekte zu untersuchen. Der Standardwert ist 2. Um eine unbegrenzte Wiederholung zu erreichen, übergeben Sie null.

• colors

  • Wenn true, wird die Ausgabe mit ANSI-Farbcodes gestaltet. Der Standardwert ist false. Farben sind anpassbar [… - siehe Link].

• customInspect

  • Wenn false, werden benutzerdefinierte inspect()Funktionen, die für die zu inspizierenden Objekte definiert wurden, nicht aufgerufen. Der Standardwert ist true.

util.format()Platzhalter für Formatzeichenfolgen (1. Argument)

Einige der unterstützten Platzhalter sind:

^{Die aktuelle vollständige Liste finden Sie in den neuesten Node.js-Dokumenten .}

• %s - String.
• %d - Zahl (sowohl Ganzzahl als auch Gleitkomma).
• %j - JSON.
• %%- einzelnes Prozentzeichen ('%'). Dies verbraucht kein Argument.

Eine andere einfache Methode besteht darin, es in json zu konvertieren

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

Versuche dies:

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

Seit Node.js 6.4.0 kann dies elegant gelöst werden mit util.inspect.defaultOptions:

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

Vielleicht console.dirist alles was du brauchst.

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

Verwendet util.inspect für obj und druckt die resultierende Zeichenfolge nach stdout.

Verwenden Sie die Option util, wenn Sie mehr Kontrolle benötigen.

Sie können auch tun

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

Eine gute Möglichkeit, Objekte zu untersuchen, ist die Verwendung der Option node --inspect mit Chrome DevTools for Node .

node.exe --inspect www.js

Öffnen Sie chrome://inspect/#devicesin Chrome und klicken Sie auf Dedicated DevTools for Node öffnen

Jetzt ist jedes protokollierte Objekt im Inspektor verfügbar, wie normales JS, das in Chrome ausgeführt wird.

Der Inspektor muss nicht erneut geöffnet werden. Er stellt automatisch eine Verbindung zum Knoten her, sobald der Knoten gestartet oder neu gestartet wird. Sowohl --inspect als auch Chrome DevTools for Node sind in älteren Versionen von Node und Chrome möglicherweise nicht verfügbar.

Beide Verwendungen können angewendet werden:

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

Ich denke, das könnte für Sie nützlich sein.

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

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

Wie in dieser Antwort erwähnt :

JSON.stringifyDer dritte Parameter definiert das Einfügen von Leerzeichen für das hübsche Drucken. Dies kann eine Zeichenfolge oder eine Zahl (Anzahl der Leerzeichen) sein.

Sie können inspect()Ihrem Objekt einfach eine Methode hinzufügen , die die Darstellung des Objekts in console.logNachrichten überschreibt

z.B:

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

Anschließend wird Ihr Objekt sowohl in console.log als auch in der Node-Shell nach Bedarf dargestellt

Ein einfacher Trick wäre das debugHinzufügen eines ModulsDEBUG_DEPTH=null als Umgebungsvariable beim Ausführen des Skripts

Ex.

DEBUG = * DEBUG_DEPTH = null node index.js

In deinem Code

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

Der Knoten REPL verfügt über eine integrierte Lösung zum Überschreiben der Anzeige von Objekten (siehe hier) .

Das REPL-Modul util.inspect()wird beim Drucken von Werten intern verwendet . Allerdings util.inspectDelegierten der Anruf an die inspect() Objektfunktion, wenn es einen hat.

Einfachste Option:

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

JSON.stringify ()

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

Ideal für die eingehende Prüfung von Datenobjekten. Dieser Ansatz funktioniert für verschachtelte Arrays und verschachtelte Objekte mit Arrays.