Durante il debug utilizzando console.log(), come posso ottenere l'intero oggetto?

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

Uscite:

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

Ma voglio anche vedere il contenuto della proprietà f.

Devi usare 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 */))

Uscite

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

Vedi util.inspect()documenti .

È possibile utilizzare JSON.stringifye ottenere un rientro gradevole e forse più facile da ricordare la sintassi.

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

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

Il terzo argomento imposta il livello di rientro, in modo da poterlo regolare come desiderato.

Maggiori dettagli qui se necessario:

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

^{Una raccolta delle molte risposte utili da (almeno) Node.js v0.10.33(stabile) / v0.11.14(instabile) presumibilmente attraverso (almeno) v7.7.4(la versione attuale dall'ultimo aggiornamento a questa risposta). Punta del cappello a Rory O'Kane per il suo aiuto.}

tl; dr

Per ottenere l'output desiderato per l'esempio nella domanda, utilizzare console.dir():

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

Perché no util.inspect()? Perché è già al centro dell'output diagnostico: console.log()e console.dir()così come il REPL Node.js usano util.inspect() implicitamente . Generalmente non è necessariorequire('util') e chiamare util.inspect()direttamente.

Dettagli sotto.

• console.log()(e il suo alias, console.info()):

  • Se il 1 ° argomento NON è una stringa di formato : util.inspect()viene automaticamente applicato a ogni argomento:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • Si noti che non è possibile passare attraverso le opzioniutil.inspect() in questo caso, il che implica 2 notevoli limitazioni:
      • La profondità strutturale dell'output è limitata a 2 livelli (impostazione predefinita).
        • Poiché non è possibile modificarlo con console.log(), è necessario invece utilizzare console.dir(): console.dir(myObject, { depth: null }stampe con profondità illimitata ; vedi sotto.
      • Non è possibile attivare la colorazione della sintassi.
  • Se il 1 ° argomento È una stringa di formato (vedi sotto): usa util.format()per stampare gli argomenti rimanenti in base alla stringa di formato (vedi sotto); per esempio:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • Nota:
      • Non esiste un segnaposto per rappresentare gli oggetti in util.inspect() stile.
      • JSON generato con %jNON è abbastanza stampato.

• console.dir():

  • Accetta solo 1 argomento da esaminare e si applica sempre util.inspect()- in sostanza, un wrapper per util.inspect()senza opzioni per impostazione predefinita; per esempio:
    • 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 + : il secondo argomento opzionale specifica le opzioni perutil.inspect() - vedi sotto; per esempio:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• REPL : stampa implicitamente il valore restituito di qualsiasi espressione util.inspect() con colorazione di sintassi ;
  cioè, basta digitare il nome di una variabile e premere Invio per stampare una versione ispezionata del suo valore; per esempio:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()stampa automaticamente le rappresentazioni di oggetti e array , ma produce output multilinea solo quando necessario .

• Il comportamento di stampa carina può essere controllato da compact proprietà optionsnell'argomento facoltativo ; falseutilizza l'output multilinea incondizionatamente , mentre truedisabilita del tutto la stampa carina; può anche essere impostato su un numero (il valore predefinito è 3) per controllare il comportamento condizionale su più righe - vedere i documenti .

• Per impostazione predefinita, l'output è racchiuso in circa 60 caratteri ^{grazie, Shrey} , indipendentemente dal fatto che l'output sia inviato a un file o a un terminale. In pratica, poiché le interruzioni di riga si verificano solo ai confini delle proprietà , si finisce spesso con linee più brevi, ma possono anche essere più lunghe (ad esempio, con valori di proprietà lunghi).

• In v6.3.0 + è possibile utilizzare l' breakLengthopzione per ignorare il limite di 60 caratteri; se lo si imposta su Infinity, tutto viene emesso su una sola riga.

Se vuoi un maggiore controllo su pretty-printing, considera l'utilizzo JSON.stringify()con un terzo argomento , ma nota quanto segue:

• Non riesce con oggetti con riferimenti circolari , ad esempio modulenel contesto globale.
• Metodi (funzioni) NON saranno inclusi nella progettazione.
• Non puoi scegliere di mostrare proprietà nascoste (non enumerabili).
• Esempio di chiamata:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect()oggetto options (secondo argomento):

Opzioni opzionali passare un oggetto che modifica alcuni aspetti della stringa formattata; alcune delle proprietà supportate sono:

^{Consulta gli ultimi documenti Node.js per l'elenco completo corrente.}

• showHidden

  • if true, verranno mostrate anche le proprietà non enumerabili dell'oggetto [quelle designate per non apparire quando si usa for keys in objo Object.keys(obj)]. L'impostazione predefinita è false.

• depth

  • indica ispezionare quante volte ricorrere durante la formattazione dell'oggetto. Ciò è utile per ispezionare oggetti complessi di grandi dimensioni. Il valore predefinito è 2. Per farlo ricorrere indefinitamente, passa null.

• colors

  • se vero, l'output sarà disegnato con codici colore ANSI. L'impostazione predefinita è false. I colori sono personalizzabili [… - vedi link].

• customInspect

  • se false, quindi le inspect()funzioni personalizzate definite sugli oggetti da ispezionare non verranno chiamate. L'impostazione predefinita è true.

util.format()segnaposto per stringhe di formato (1 ° argomento)

Alcuni dei segnaposto supportati sono:

^{Consulta gli ultimi documenti Node.js per l'elenco completo corrente.}

• %s - Corda.
• %d - Numero (sia intero che mobile).
• %j - JSON.
• %%- segno di percentuale singolo ('%'). Questo non consuma un argomento.

Un altro metodo semplice è convertirlo in json

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

Prova questo:

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

Da Node.js 6.4.0, questo può essere elegantemente risolto con util.inspect.defaultOptions:

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

forse console.dirè tutto ciò di cui hai bisogno.

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

Usa util.inspect su obj e stampa la stringa risultante su stdout.

utilizzare l'opzione util se è necessario un maggiore controllo.

Puoi anche fare

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

Un buon modo per ispezionare gli oggetti è utilizzare l' opzione nodo --inspect con Chrome DevTools per Nodo .

node.exe --inspect www.js

Apri chrome://inspect/#devicesin Chrome e fai clic su Apri DevTools dedicato per Nodo

Ora ogni oggetto registrato è disponibile in inspector come JS normale in esecuzione in Chrome.

Non è necessario riaprire inspector, si collega automaticamente al nodo non appena il nodo si avvia o si riavvia. Sia --inspect che Chrome DevTools per Node potrebbero non essere disponibili nelle versioni precedenti di Node e Chrome.

Entrambi questi usi possono essere applicati:

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

Penso che questo potrebbe esserti utile.

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

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

Come menzionato in questa risposta :

JSON.stringifyIl terzo parametro definisce l'inserimento di spazi vuoti per la stampa carina. Può essere una stringa o un numero (numero di spazi).

Puoi semplicemente aggiungere un inspect()metodo al tuo oggetto che sovrascriverà la rappresentazione dell'oggetto nei console.logmessaggi

per esempio:

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

quindi, l'oggetto verrà rappresentato come richiesto in console.log e nella shell dei nodi

Un semplice trucco sarebbe usare il debugmodulo per aggiungere DEBUG_DEPTH=nullcome variabile di ambiente quando si esegue lo script

Ex.

DEBUG = * DEBUG_DEPTH = nodo null index.js

Nel tuo codice

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

Il nodo REPL ha una soluzione integrata per sovrascrivere la modalità di visualizzazione degli oggetti, vedere qui .

Il modulo REPL utilizza internamente util.inspect(), durante la stampa di valori. Tuttavia, util.inspectdelega la chiamata alla inspect() funzione dell'oggetto , se presente.

L'opzione più semplice:

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

JSON.stringify ()

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

Ottimo per un'ispezione approfondita degli oggetti dati. Questo approccio funziona su matrici nidificate e oggetti nidificati con matrici.