¿Cómo puedo obtener el objeto completo en Node.js's console.log (), en lugar de '[Object]'?


894

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.

Respuestas:


1460

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 .


44
Buena solución Aunque no es necesario especificar {showHidden: false} siempre que su valor predeterminado sea falso.
ecdeveloper

36
Bueno saber; no estoy seguro de cuándo se introdujo, pero a partir de al menos el nodo se aplica v0.10.33 console.log() implícitamenteutil.inspect() a sus argumentos, suponiendo que el primero no es una cadena de formato. Si está satisfecho con util.inspect()las opciones predeterminadas, simplemente console.log(myObject)lo hará, no es necesario util; console.dir()hace lo mismo, pero acepta solo 'objeto para inspeccionar; por lo menos v0.11.14, puede pasar el objeto de opciones util.inspect()como el segundo argumento; Mi respuesta tiene más detalles.
mklement0

44
@ mklement0 Tengo el nodo v5.3.0 y cuando console.log(obj)todavía imprimo [Objeto] para objetos profundamente anidados :( Realmente desearía que se comportara como usted describe.
SSH Este

47
@SSH: console.log()está invariablemente limitado a 2 niveles (porque usa util.inspect()el valor predeterminado sin permitirle cambiarlo); console.dir()tiene el mismo límite de forma predeterminada, pero puede pasar un objeto de opciones como el segundo argumento para cambiar eso (que se pasa a util.inspect(); tenga en cuenta que console.dir() solo puede imprimir 1 objeto a la vez, sin embargo. Para imprimir con profundidad ilimitada, use console.dir(myObject, { depth: null }).
mklement0

13
console.dir(myObject, { depth: null })es trabajo para mí
Veck Hsiao

632

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


2
también +1 para saltos de línea y sangría, casi siempre deseado para mí personalmente
toblerpwn

59
Tenga en cuenta que no puede JSON.stringify objetos con referencias circulares . Como ocurriría con objetos DOM, por ejemplo. Stringify arrojará un "Error: convertir la estructura circular a JSON".
Ignacio Lago

11
Este no es el objeto completo. los objetos que solo contengan funciones serán {}. Por supuesto, eso puede ser positivo o negativo dependiendo de lo que desee imprimir.
Lawrence Weru el

1
console.log(JSON.stringify(myObject, null, 4));¡muy genial! https://gist.github.com/xgqfrms-GitHub/92aa2b00249f15084d24aa2e0a5d0300
xgqfrms

1
En mi caso, recibo este error TypeError: Conversión de estructura circular a JSON
Prem Sanil

313

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.

1
Una forma de simplificar esto sería hacer una pequeña función con nombre console.dir(...)sin todo el tipeo: show = (v, depth=null)=> console.dir(v,{depth:depth})y luego llamarlo así show(variable)o show(variable, depth=1).
loco.loop

56

Otro método simple es convertirlo a json

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

12
Buen truco, pero la salida no se embellecerá, lo que dificulta la lectura de objetos grandes (el punto de la pregunta).
Dan Dascalescu

2
sigue siendo muy útil y es más rápido copiar y pegar en jsonlint.com que requerir utils:)
SSH Este

1
Creo que este es genial cuando tienes un editor que formateará json para ti, pero solo necesitas copiarlo de REPL
jcollum

2
Esto es muy útil y útil si el objeto es pequeño
Chinmay Samant

43

Prueba esto:

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



21

También puedes hacer

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

19

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.

ingrese la descripción de la imagen aquí

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.


1
Un mensaje para mí: pruébalo ->node.exe --inspect index.js
Lonely

Esto debería estar en la parte superior. la mejor respuesta. :)
princebillyGK

11

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

10

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


4

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


3

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

@Bala Deberá instalar el módulo "depuración" en su proyecto "npm install debug --save"
Chintan

2

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.



0

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.