wake-up-neo.com

Wie kann ich das vollständige Objekt in Node.js console.log () anstelle von "[Object]" abrufen?

Wie kann ich beim Debuggen mit console.log() 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 der Eigenschaft f sehen.

739
user1372449

Sie müssen util.inspect() verwenden:

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() docs .

1236
250R

Sie können JSON.stringify verwenden und ein paar nette Einrückungen erhalten sowie sich die Syntax vielleicht leichter merken.

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 wie gewünscht anpassen können.

Weitere Details hier bei Bedarf:

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

551
user1106925

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 (Stand der Version vom letztes Update zu dieser Antwort).

tl; dr

util.inspect() ist das Herzstück der Diagnoseausgabe: console.log() und console.dir() sowie der Node.js REPL verwenden util.inspect() implizit , also ist es im Allgemeinen nicht notwendig, umrequire('util') und rufen Sie util.inspect() direkt an.

So erhalten Sie die gewünschte Ausgabe für das Beispiel in der Frage:

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

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 Optionen können nicht übergeben durch util.inspect() in diesem Fall, was 2 bemerkenswerte Einschränkungen impliziert:
        • Struktur Tiefe der Ausgabe ist beschränkt auf 2 Ebenen (Standard).
          • Da Sie dies mit console.log() nicht ändern können, müssen Sie stattdessen console.dir() verwenden: console.dir(myObject, { depth: null } druckt mit unlimited depth; siehe unten.
        • Sie können die Syntaxfärbung nicht aktivieren.
    • Wenn das erste Argument IS eine Formatzeichenfolge ist ​​(siehe unten): 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 KEINEN Platzhalter für die Darstellung des Stils objects util.inspect()-.
        • JSON, das mit %j generiert wurde, ist NICHT hübsch gedruckt.
  • console.dir():

    • Akzeptiert nur 1 zu untersuchendes Argument ​​und wendet immer util.inspect() an - im Wesentlichen ein Wrapper für util.inspect() ohne Optionen standardmäßig; 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 zweite Argument gibt Optionen für util.inspect() an - siehe unten; z.B.:
      • console.dir({ one: 1, two: 'deux'}, { colors: true }); // node 0.11+: Prints object representation with syntax coloring.
  • Die REPL: druckt implizit den Rückgabewert eines Ausdrucks mit util.inspect() mit Syntaxfärbung;
    Das heißt, wenn Sie 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(){} } // echoes the object definition with syntax coloring.

util.inspect() druckt automatisch (und immer) Pretty-Prints Objekt und Array Darstellungen, erzeugt aber mehrzeilig Ausgabe nur bei Bedarf - Wenn alles in eine Zeile passt, wird nur 1 Zeile gedruckt.

  • Standardmäßig wird die Ausgabe umbrochen mit ungefähr 60 Zeichen danke, Shrey , unabhängig davon, ob die Ausgabe an eine Datei oder ein Terminal gesendet wird. Da - Zeilenumbrüche nur an Eigenschaftsgrenzen auftreten , werden Sie in der Praxis häufig kürzere Zeilen erhalten, diese können jedoch auch länger sein (z. B. mit langen Eigenschaftswerten).

  • In v6.3.0 + können Sie die Option breakLength verwenden, um die Beschränkung auf 60 Zeichen zu überschreiben. Wenn Sie Infinity wählen, wird alles in einer single Zeile ausgegeben.

Wenn Sie mehr Kontrolle über das hübsche Drucken haben möchten, sollten Sie JSON.stringify() mit einem dritten Argument verwenden, aber beachten Sie Folgendes:

  • Fails mit Objekten mit Zirkelverweisen , wie z. B. module im globalen Kontext.
  • Methoden (Funktionen) werden standardmäßig NICHT einbezogen.
  • Sie können sich nicht dafür entscheiden, ausgeblendete (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() options object ​​(2. Argument):

quelle: http://nodejs.org/api/util.html#util_util_format_format

Ein optionales options Objekt kann übergeben werden, das bestimmte Aspekte der formatierten Zeichenfolge ändert:

  • showHidden
    • wenn true, werden auch die nicht aufzählbaren Eigenschaften des Objekts [die, die bei Verwendung von for keys in obj oder Object.keys(obj)] nicht angezeigt werden sollen] angezeigt. Der Standardwert ist false.
  • depth
    • teilt inspect mit, 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. Übergeben Sie null, um die Wiederholung auf unbestimmte Zeit zu ermöglichen.
  • colors
    • wenn true, wird die Ausgabe mit ANSI-Farbcodes formatiert. Der Standardwert ist false. Farben sind anpassbar [... - siehe Link].
  • customInspect
    • wenn false, werden benutzerdefinierte inspect()-Funktionen, die für die zu überprüfenden Objekte definiert sind, nicht aufgerufen. Der Standardwert ist true.

util.format() Format-String-Platzhalter (1. Argument)

quelle: http://nodejs.org/api/util.html#util_util_format_format

  • %s - Zeichenfolge.
  • %d - Number (sowohl Integer als auch Float).
  • %j - JSON.
  • % - einfaches Prozentzeichen ('%'). Dies verbraucht kein Argument.
247
mklement0

Eine andere einfache Methode ist die Konvertierung in json

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

Versuche dies:

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

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);
_
23
silverwind

vielleicht ist console.dir alles, was Sie brauchen.

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

Verwendet util.inspect auf obj und gibt den resultierenden String in stdout aus.

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

19
Luke W

Sie können auch tun

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

Eine gute Möglichkeit zum Überprüfen von Objekten ist die Verwendung der Option node - inspect mit Chrome DevTools for Node .

node.exe --inspect www.js

Öffnen Sie chrome://inspect/#devices in chrome und klicken Sie auf . Öffnen Sie dedizierte DevTools für Node .

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

enter image description here

Der Inspector 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 möglicherweise nicht verfügbar ältere Versionen von Node und Chrome.

14
Ali

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

// clear list of actual values

console.log(JSON.stringify(queryArgs, undefined, 2));
10
Erce

Ich denke, das könnte nützlich für Sie 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 diese Antwort erwähnt:

Der dritte Parameter von JSON.stringify definiert das Einfügen von Leerzeichen für hübsches Drucken. Es kann eine Zeichenfolge oder eine Zahl (Anzahl der Leerzeichen) sein.

4
Nirav Sutariya

Sie können Ihrem Objekt einfach eine inspect() - Methode hinzufügen, die die Darstellung des Objekts in console.log -Nachrichten ü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 in console.log und in der Knoten-Shell wie erforderlich dargestellt

4
harish2704

Ein einfacher Trick wäre die Verwendung des Moduls debug, um DEBUG_DEPTH=null als Umgebungsvariable beim Ausführen des Skripts hinzuzufügen

Ex.

DEBUG = * DEBUG_DEPTH = Nullknoten index.js

In deinem Code

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

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

Das Modul REPL verwendet beim Drucken von Werten intern util.inspect(). util.inspect delegiert den Aufruf jedoch an die Funktion inspect() des Objekts, falls vorhanden.

2
Lloyd