javascript - imprimir - console.log php

¿Cómo puedo obtener el objeto completo en la consola.log() de Node.js, en lugar de ''[Objeto]''?

Question

Al depurar utilizando 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 .

Answer 1

Ambos de estos usos pueden ser aplicados

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

Answer 2

Desde Node.js 6.4.0, esto se puede resolver de manera elegante con util.inspect.defaultOptions :

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

Answer 3

El nodo REPL tiene una solución integrada para anular la forma en que se muestran los objetos, consulte here .

El módulo REPL utiliza internamente util.inspect() cuando imprime valores. Sin embargo, util.inspect delega la llamada a la función inspect() del objeto, si la tiene.

Answer 4

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

Answer 5

Otro método simple es convertirlo a json.

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

Answer 6

Prueba esta función de ayuda

const l = (...params) => console.log(...params.map(param => JSON.stringify(param, null, 4)))

Uso:

l(obj1,obj2...)

También puede usarlo en otros entornos de javascript como PhantomJs, por ejemplo.

Answer 7

Prueba esto:

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

Answer 8

Puede usar JSON.stringify y obtener una sangría agradable, 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 ajustar eso como desee.

Más detalles aquí si es necesario:

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

Answer 9

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 la salida estándar.

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

Answer 10

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

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

luego, su objeto se representará como se requiere tanto en console.log como en el shell del nodo

Answer 11

Tambien puedes hacer

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

Answer 12

Un truco simple sería usar el módulo de debug para agregar DEBUG_DEPTH=null como 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);

Answer 13

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

node.exe --inspect www.js

Abra chrome://inspect/#devices en chrome y haga clic en Abrir DevTools dedicado para nodo

Ahora, todos los objetos registrados están disponibles en el inspector como JS normal ejecutándose en Chrome.

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

Answer 14

^{Una compilación de las muchas respuestas útiles de (al menos) Node.js v0.10.33 (estable) / v0.11.14 (inestable) probablemente 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() está en el corazón de la salida de diagnóstico: console.log() y console.dir() , así como el uso de REPL de Node.js util.inspect() implícitamente , por lo que generalmente no es necesario require(''util'') y llamar a util.inspect() directamente .

Para obtener la salida deseada 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 1er 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 de util.inspect() en este caso, lo que implica 2 limitaciones notables:
      • La profundidad estructural de la salida está limitada a 2 niveles (el valor predeterminado).
        • Ya que no puede cambiar esto con console.log() , en su lugar debe usar console.dir() : console.dir(myObject, { depth: null } imprime con profundidad ilimitada ; vea más abajo.
      • No puedes activar la sintaxis para colorear.
  • Si el 1er argumento ES una cadena de formato (ver más abajo): utiliza util.format() para imprimir los argumentos restantes en función de la cadena de formato (ver más 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() .
      • JSON generado con %j NO está bastante impreso.

• console.dir() :

  • Acepta solo 1 argumento para inspeccionar , y siempre aplica util.inspect() - esencialmente, un contenedor 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() ; consulte a continuación; 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 devuelto de cualquier expresión con util.inspect() con color de sintaxis ;
  es decir, simplemente escribiendo el nombre de una variable y presionando Entrar 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) imprime representaciones de objetos y matrices , pero produce una salida multilínea solo cuando es necesario ; si todo encaja en una línea, solo se imprime 1 línea.

• De forma predeterminada, la salida se ^Shrey en 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 opción breakLength para anular el límite de 60 caracteres; Si lo configura en Infinity , todo se imprime en una sola línea.

Si desea 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 module en el contexto global.
• Los métodos (funciones) NO se incluirán 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() opciones de util.inspect() (2do argumento):

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

Se puede pasar un objeto de opciones opcionales que altera ciertos aspectos de la cadena con formato:

• showHidden
  • si es true , entonces también se mostrarán las propiedades no enumerables del objeto [aquellas designadas para no aparecer cuando se usan for keys in obj o Object.keys(obj) ]. El valor predeterminado es false .
• depth
  • indica a inspeccionar cuántas veces se debe repetir mientras se formatea el objeto. Esto es útil para inspeccionar objetos grandes y complicados. El valor predeterminado es 2. Para hacer que se repita indefinidamente, pase null .
• colors
  • si es verdadero, entonces la salida tendrá un estilo con códigos de color ANSI. El valor predeterminado es false . Los colores son personalizables [... - ver enlace].
• customInspect
  • si es false , entonces no se inspect() funciones de inspect() 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)

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

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