Al depurar usando console.log(), ¿cómo puedo obtener el objeto completo?

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

Salidas:

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

Pero también quiero ver el contenido de la propiedad f.

Necesitas usar 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 */))

Salidas

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

Ver util.inspect()documentos .

Puede usar JSON.stringifyy obtener una buena sangría, así como quizás una sintaxis más fácil de recordar.

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

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

El tercer argumento establece el nivel de sangría, por lo que puede ajustarlo como desee.

Más detalles aquí si es necesario:

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

^{Una compilación de las muchas respuestas útiles de (al menos) Node.js v0.10.33(estable) / v0.11.14(inestable) presumiblemente a través de (al menos) v7.7.4(la versión actual a partir de la última actualización de esta respuesta). Punta del sombrero a Rory O'Kane por su ayuda.}

tl; dr

Para obtener el resultado deseado para el ejemplo en la pregunta, use console.dir():

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

¿Por qué no util.inspect()? Porque ya está en el corazón de la salida de diagnóstico: console.log()y console.dir()también como el uso deutil.inspect() Node.js REPL implícitamente . Generalmente no es necesariorequire('util') llamar util.inspect()directamente.

Detalles abajo.

• console.log()(y su alias console.info()):

  • Si el primer argumento NO es una cadena de formato : util.inspect()se aplica automáticamente a cada argumento:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • Tenga en cuenta que no puede pasar opciones a través deutil.inspect() , en este caso, lo que implica limitaciones notables 2:
      • La profundidad estructural de la salida está limitada a 2 niveles. (el valor predeterminado).
        • Como no puede cambiar esto con console.log(), debe usar console.dir(): console.dir(myObject, { depth: null }impresiones con profundidad ilimitada ; vea abajo.
      • No puede activar la coloración de sintaxis.
  • Si el primer argumento ES una cadena de formato (ver abajo): se usa util.format()para imprimir los argumentos restantes basados ​​en la cadena de formato (ver abajo); p.ej:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • Nota:
      • NO hay marcador de posición para representar objetos util.inspect() estilo.
      • JSON generado con %jNO está bien impreso.

• console.dir():

  • Acepta solo 1 argumento para inspeccionar , y siempre aplica util.inspect(), esencialmente, un contenedor util.inspect()sin opciones por defecto; p.ej:
    • 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 + : el segundo argumento opcional especifica las opciones parautil.inspect() - ver a continuación; p.ej:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• REPL : imprime implícitamente el valor de retorno de cualquier expresión util.inspect() con un color de sintaxis ;
  es decir, simplemente escribiendo el nombre de una variable y presionando Enter se imprimirá una versión inspeccionada de su valor; p.ej:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()automáticamente imprime bonitas representaciones de objetos y matrices , pero produce una salida multilínea solo cuando es necesario .

• El comportamiento de impresión bonita puede ser controlado por la compactpropiedad en el optionsargumento opcional ; falseusa la salida multilínea incondicionalmente , mientras que truedesactiva la impresión bonita por completo; también se puede establecer en un número (el valor predeterminado es 3) para controlar el comportamiento condicional de varias líneas; consulte los documentos .

• De forma predeterminada, la salida se ^ajusta a alrededor de 60 caracteres ^{, gracias, Shrey} , independientemente de si la salida se envía a un archivo o terminal. En la práctica, dado que los saltos de línea solo ocurren en los límites de la propiedad , a menudo terminará con líneas más cortas, pero también pueden ser más largas (por ejemplo, con valores de propiedad largos).

• En v6.3.0 + puede usar la breakLengthopción para anular el límite de 60 caracteres; si lo configura Infinity, todo se genera en una sola línea.

Si desea tener más control sobre la impresión bonita, considere usar JSON.stringify()con un tercer argumento , pero tenga en cuenta lo siguiente:

• Falla con objetos que tienen referencias circulares , como moduleen el contexto global.
• Los métodos (funciones) por diseño NO serán incluidos.
• No puede optar por mostrar propiedades ocultas (no enumerables).
• Llamada de ejemplo:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect()objeto de opciones (segundo argumento):

Se puede pasar un objeto de opciones opcionales que altere ciertos aspectos de la cadena formateada; Algunas de las propiedades admitidas son:

^{Consulte los últimos documentos de Node.js para obtener la lista completa actual.}

• showHidden

  • si true, entonces también se mostrarán las propiedades no enumerables del objeto [aquellas designadas para no aparecer cuando se usa for keys in objo Object.keys(obj)]. Por defecto es false.

• depth

  • indica inspeccionar cuántas veces debe repetirse mientras formatea el objeto. Esto es útil para inspeccionar objetos grandes y complicados. El valor predeterminado es 2. Para que se repita indefinidamente, pase null.

• colors

  • si es verdadero, la salida tendrá un estilo con códigos de color ANSI. Por defecto es false. Los colores son personalizables [... - ver enlace].

• customInspect

  • si false, entonces no se llamarán las inspect()funciones personalizadas definidas en los objetos que se están inspeccionando. Por defecto es true.

util.format()marcadores de posición de cadena de formato (1er argumento)

Algunos de los marcadores de posición admitidos son:

^{Consulte los últimos documentos de Node.js para obtener la lista completa actual.}

• %s - Cuerda.
• %d - Número (tanto entero como flotante).
• %j - JSON.
• %%- signo de porcentaje único ('%'). Esto no consume un argumento.

Otro método simple es convertirlo a json

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

Prueba esto:

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

Desde Node.js 6.4.0, esto se puede resolver elegantemente con util.inspect.defaultOptions:

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

Quizás console.dires todo lo que necesitas.

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

Utiliza util.inspect en obj e imprime la cadena resultante en stdout.

use la opción util si necesita más control.

También puedes hacer

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

Una buena forma de inspeccionar objetos es usar la opción nodo - inspeccionar con Chrome DevTools for Node .

node.exe --inspect www.js

Abra chrome://inspect/#devicesen Chrome y haga clic en Abrir DevTools dedicado para el nodo

Ahora cada objeto registrado está disponible en el inspector como JS normal que se ejecuta en Chrome.

No es necesario volver a abrir el inspector, se conecta al nodo automáticamente tan pronto como el nodo se inicia o reinicia. Es posible que --inspect y Chrome DevTools for Node no estén disponibles en versiones anteriores de Node y Chrome.

Ambos usos se pueden aplicar:

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

Creo que esto podría ser útil para ti.

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

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

Como se menciona en esta respuesta :

JSON.stringifyEl tercer parámetro define la inserción de espacios en blanco para una impresión bonita. Puede ser una cadena o un número (número de espacios).

Simplemente puede agregar un inspect()método a su objeto que anulará la representación del objeto en los console.logmensajes

p.ej:

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

entonces, su objeto se representará como se requiere en console.log y node shell

Un truco simple sería usar el debugmódulo para agregar DEBUG_DEPTH=nullcomo variable de entorno al ejecutar el script

Ex.

DEBUG = * DEBUG_DEPTH = nodo nulo index.js

En tu codigo

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

El nodo REPL tiene una solución integrada para anular cómo se muestran los objetos, ver aquí .

El módulo REPL utiliza internamente util.inspect(), al imprimir valores. Sin embargo, util.inspectdelega la llamada a la inspect() función del objeto , si tiene una.

Opción más fácil:

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

JSON.stringify ()

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

Excelente para la inspección profunda de objetos de datos. Este enfoque funciona en matrices anidadas y objetos anidados con matrices.