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


Cuando se depura 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);

Productos:

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

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


545
2018-05-23 23:29


origen


Respuestas:


Tienes que 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))

Salidas

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

Ver util.inspect() documentos.


930
2018-05-23 23:30



Puedes usar JSON.stringify, y obtenga 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 según lo desee.

Más detalles aquí si es necesario:

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


442
2017-12-17 20:57



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

tl; dr

util.inspect() es el corazón de la salida de diagnóstico: console.log() y console.dir() así como el uso de REPL Node.js util.inspect()  implícitamente, por lo general, NO es necesario require('util') y llama util.inspect() directamente.

Para obtener el resultado deseado para el ejemplo en la pregunta:

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

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 mediante util.inspect() en este caso, lo que implica 2 limitaciones notables:
        • Estructural profundidad de la salida es limitado a 2 niveles (el valor por defecto).
          • Como no puedes cambiar esto con console.log(), en su lugar debes usar console.dir(): console.dir(myObject, { depth: null } imprime con ilimitado profundidad; vea abajo.
        • No puede activar el coloreado de sintaxis.
    • Si el primer argumento ES una cadena de formato (ver a continuación): usos util.format() para imprimir los argumentos restantes basados ​​en la cadena de formato (ver a continuación); 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 %j NO está bastante impreso.
  • console.dir():

    • Acepta solo 1 argumento para inspeccionary siempre se aplica util.inspect() - esencialmente, una envoltura para 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 para util.inspect() - vea abajo; p.ej.:
      • console.dir({ one: 1, two: 'deux'}, { colors: true }); // node 0.11+: Prints object representation with syntax coloring.
  • El REPL: imprime implícitamente el valor de retorno de cualquier expresión con util.inspect()  con  colorante de sintaxis;
    es decir, simplemente escribiendo el nombre de una variable y presionando Enter imprimirá una versión inspeccionada de su valor; p.ej.:
    • o = { one: 1, two: 'deux', foo: function(){} } // echoes the object definition with syntax coloring.

util.inspect() automáticamente (e invariablemente) impresiones bonitas objeto y formación representaciones, pero produce multilínea salida solo cuando sea necesario - si todo encaja en una línea, solo se imprime 1 línea.

  • Por defecto, la salida está envuelta alrededor de 60 caracteres Gracias, Shrey , independientemente de si la salida se envía a un archivo o una terminal. En la práctica, desde 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 + puedes usar el breakLength opción para anular el límite de 60 caracteres; si lo configuras en Infinity, todo sale en un soltero línea.

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

  • Falla con objetos que tienen referencias circulares, como module en el contexto global.
  • Métodos (funciones) NO serán incluidas por diseño.
  • No puede optar por mostrar propiedades ocultas (no enumerables).
  • Ejemplo de llamada:
    • 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 (2º argumento):

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

Un opcional opciones se puede pasar un objeto que altera ciertos aspectos de la cadena formateada:

  • showHidden
    • Si true, luego las propiedades no enumerables del objeto [las designadas para que no aparezcan cuando usa for keys in obj o Object.keys(obj)] se mostrará también. Predeterminado a false.
  • depth
    • le dice a inspeccionar cuántas veces recurrir al formatear 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 se diseñará con códigos de color ANSI. Predeterminado a false. Los colores son personalizables [... - ver enlace].
  • customInspect
    • Si false, luego personalizado inspect() las funciones definidas en los objetos que se inspeccionan no serán llamadas. Predeterminado a true.

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

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

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

139
2018-01-15 16:05



Otro método simple es convertirlo a json

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

43
2017-10-19 11:05



Prueba esto:

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

22
2018-03-02 01:27



quizás console.dir es 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.


16
2018-02-14 10:32



También puedes hacer

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

16
2018-01-26 20:32



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

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

13
2018-04-17 11:37