Comment puis-je obtenir l'objet complet dans console.log () de Node.js, plutôt que «[Object]»?

895

Lors du débogage à l'aide de console.log(), comment puis-je obtenir l'objet complet?

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

Les sorties:

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

Mais je veux aussi voir le contenu de la propriété f.

Michał Perłakowski
la source

Réponses:

1461

Vous devez utiliser 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 */))

Les sorties

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

Voir les util.inspect()documents .

250R
la source
4
Belle solution. Bien qu'il ne soit pas nécessaire de spécifier {showHidden: false} tant qu'il est défini par défaut sur false.
ecdeveloper
36
Bon à savoir; Je ne sais pas quand il a été introduit, mais à partir du moins, le nœud s'applique v0.10.33 console.log() implicitementutil.inspect() à ses arguments, en supposant que le premier n'est pas une chaîne de format. Si vous êtes satisfait util.inspect()des options par défaut de, tout simplement console.log(myObject)fera l'affaire - pas besoin d'exiger util; console.dir()fait de même, mais n'accepte que `objet à inspecter; à partir d'au moins v0.11.14, vous pouvez passer l'objet options pour util.inspect()comme 2ème argument; ma réponse a plus de détails.
mklement0
4
@ mklement0 J'ai le noeud v5.3.0 et quand j'imprime console.log(obj)toujours [Object] pour les objets profondément imbriqués :( je souhaite vraiment qu'il se comporte comme vous le décrivez.
SSH Ce
47
@SSH: console.log()est invariablement limité à 2 niveaux (car il utilise util.inspect()la valeur par défaut sans vous permettre de la changer); console.dir()a la même limite par défaut, mais vous pouvez passer dans un choix objet que le 2ème argument de changer cette situation (qui est passé à travers à util.inspect(), noter que console.dir() ne peut jamais imprimer 1 . objet à la fois, cependant imprimer avec une profondeur illimité, console.dir(myObject, { depth: null }).
mklement0
13
console.dir(myObject, { depth: null })est du travail pour moi
Veck Hsiao
632

Vous pouvez utiliser JSON.stringifyet obtenir une belle indentation ainsi qu'une syntaxe peut-être plus facile à retenir.

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

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

Le troisième argument définit le niveau d'indentation, vous pouvez donc l'ajuster comme vous le souhaitez.

Plus de détails ici si nécessaire:

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

utilisateur1106925
la source
2
également +1 pour les sauts de ligne et l'indentation - presque toujours souhaité pour moi personnellement
toblerpwn
59
Notez que vous ne pouvez pas JSON.stringify objets avec des références circulaires . Comme cela se produirait avec des objets DOM, par exemple. Stringify lancera une "Erreur: Conversion de la structure circulaire en JSON".
Ignacio Lago
11
ce n'est pas l'objet complet. les objets contenant uniquement des fonctions seront {}. Bien sûr, cela peut être positif ou négatif selon ce que vous souhaitez imprimer.
Lawrence Weru
1
console.log(JSON.stringify(myObject, null, 4));plutôt cool! https://gist.github.com/xgqfrms-GitHub/92aa2b00249f15084d24aa2e0a5d0300
xgqfrms
1
Dans mon cas, j'obtiens cette erreur TypeError: Conversion d'une structure circulaire en JSON
Prem Sanil
313

Une compilation des nombreuses réponses utiles de (au moins) Node.js v0.10.33(stable) / v0.11.14(instable) vraisemblablement via (au moins) v7.7.4(la version actuelle à la dernière mise à jour de cette réponse). Pointe du chapeau à Rory O'Kane pour son aide.

tl; dr

Pour obtenir la sortie souhaitée pour l'exemple de la question, utilisez console.dir():

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

Pourquoi ne pas util.inspect()? Parce qu'il est déjà au cœur de la production de diagnostic: console.log()et console.dir()ainsi que le Node.js REPL utiliser util.inspect() implicitement . Il n'est généralement pas nécessaire d'require('util') appeler util.inspect()directement.

Détails ci-dessous.


  • console.log()(et son alias, console.info()):

    • Si le 1er argument n'est PAS une chaîne de format : util.inspect()est automatiquement appliqué à chaque argument:
      • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
      • Notez que vous ne pouvez pas passer des options par util.inspect()dans ce cas, ce qui implique 2 limitations notables:
        • La profondeur structurelle de la sortie est limitée à 2 niveaux (par défaut).
          • Comme vous ne pouvez pas changer cela avec console.log(), vous devez utiliser à la place console.dir(): des console.dir(myObject, { depth: null }impressions avec une profondeur illimitée ; voir ci-dessous.
        • Vous ne pouvez pas activer la coloration syntaxique.
    • Si le 1er argument EST une chaîne de format (voir ci-dessous): utilise util.format()pour imprimer les arguments restants basés sur la chaîne de format (voir ci-dessous); par exemple:
      • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
      • Remarque:
        • Il n'y a AUCUN espace réservé pour représenter les objets de util.inspect() style.
        • Le JSON généré avec %jn'est PAS assez imprimé.
  • console.dir():

    • Accepte seulement 1 argument pour inspecter , et applique toujours util.inspect()- essentiellement, une enveloppe pour util.inspect()sans options par défaut; par exemple:
      • 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 + : Le 2ème argument optionnel spécifie les options pourutil.inspect() - voir ci-dessous; par exemple:
      • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.
  • Le REPL : imprime implicitement la valeur de retour de toute expression util.inspect() avec une coloration syntaxique ;
    c'est-à-dire, le simple fait de taper le nom d'une variable et d'appuyer sur Entrée affichera une version inspectée de sa valeur; par exemple:
    • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()imprime automatiquement les représentations d' objets et de tableaux , mais ne produit une sortie multiligne qu'en cas de besoin .

  • Le comportement de jolie impression peut être contrôlé par la compactpropriété dans l' optionsargument facultatif ; falseutilise la sortie multi-lignes sans condition , tandis que truedésactive complètement la jolie impression; il peut également être défini sur un nombre (la valeur par défaut est 3) pour contrôler le comportement multiligne conditionnel - voir la documentation .

  • Par défaut, la sortie est emballée à environ 60 caractères merci, Shrey , que la sortie soit envoyée vers un fichier ou un terminal. En pratique, étant donné que les sauts de ligne ne se produisent qu'aux limites des propriétés , vous vous retrouverez souvent avec des lignes plus courtes, mais elles peuvent également être plus longues (par exemple, avec de longues valeurs de propriété).

  • Dans v6.3.0 +, vous pouvez utiliser l' breakLengthoption pour remplacer la limite de 60 caractères; si vous le définissez sur Infinity, tout est sorti sur une seule ligne.

Si vous voulez plus de contrôle sur la jolie impression, pensez à utiliser JSON.stringify()avec un troisième argument , mais notez ce qui suit:

  • Échoue avec les objets qui ont des références circulaires , comme moduledans le contexte global.
  • Les méthodes (fonctions) ne seront PAS incluses par conception.
  • Vous ne pouvez pas choisir d'afficher les propriétés cachées (non énumérables).
  • Exemple d'appel:
    • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect()objet options (2e argument):

Un objet d' options facultatif peut être transmis qui modifie certains aspects de la chaîne formatée; certaines des propriétés prises en charge sont:

Consultez les derniers documents Node.js pour la liste complète actuelle.

  • showHidden

    • si true, alors les propriétés non énumérables de l'objet [celles désignées pour ne pas apparaître lorsque vous utilisez for keys in objou Object.keys(obj)] seront également affichées. Par défaut à false.
  • depth

    • indique à inspecter combien de fois il doit récursivement tout en formatant l'objet. Ceci est utile pour inspecter de gros objets compliqués. Par défaut à 2. Pour le faire rentrer indéfiniment, passez null.
  • colors

    • si true, la sortie sera stylisée avec des codes de couleur ANSI. Par défaut à false. Les couleurs sont personnalisables [… - voir lien].
  • customInspect

    • si false, les inspect()fonctions personnalisées définies sur les objets inspectés ne seront pas appelées. Par défaut à true.

util.format()espaces réservés format-string (1er argument)

Certains des espaces réservés pris en charge sont les suivants:

Consultez les derniers documents Node.js pour la liste complète actuelle.

  • %s - Chaîne.
  • %d - Nombre (entier et flottant).
  • %j - JSON.
  • %%- signe de pourcentage unique ('%'). Cela ne consomme pas un argument.
mklement0
la source
1
Une façon de simplifier cela serait de faire une petite fonction nommée pour se passer de console.dir(...)toute la frappe: show = (v, depth=null)=> console.dir(v,{depth:depth})puis l'appeler comme ça show(variable)ou show(variable, depth=1).
loco.loop
56

Une autre méthode simple consiste à le convertir en json

console.log('connection : %j', myObject);
niksmac
la source
12
Belle astuce mais la sortie ne sera pas raffinée, ce qui rend la lecture difficile pour les gros objets (le point de la question).
Dan Dascalescu
2
toujours très utile, et plus rapide à copier et coller dans jsonlint.com que de l'exiger utils:)
SSH Ce
1
Je pense que celui-ci est génial lorsque vous avez un éditeur qui formatera json pour vous, mais vous avez juste besoin de le copier depuis REPL
jcollum
2
Ceci est très pratique et utile si l'objet est petit
Chinmay Samant
43

Essaye ça:

console.dir(myObject,{depth:null})
Hirra
la source
32

Depuis Node.js 6.4.0, cela peut être résolu avec élégance avec util.inspect.defaultOptions:

require("util").inspect.defaultOptions.depth = null;
console.log(myObject);
vent d'argent
la source
Comment le rendre permanent?
TheMaster
24

c'est peut console.dir- être tout ce dont vous avez besoin.

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

Utilise util.inspect sur obj et imprime la chaîne résultante sur stdout.

utilisez l'option util si vous avez besoin de plus de contrôle.

Luke W
la source
Depuis (au moins) v0.11.14, vous pouvez passer un objet options en tant que 2e argument, qui est passé à util.inspect().
mklement0
21

Vous pouvez aussi faire

console.log(JSON.stringify(myObject, null, 3));
Eesa
la source
19

Une bonne façon d'inspecter les objets consiste à utiliser l' option node --inspect avec Chrome DevTools for Node .

node.exe --inspect www.js

Ouvrez chrome://inspect/#devicesen chrome et cliquez sur Ouvrir des DevTools dédiés pour Node

Désormais, chaque objet enregistré est disponible dans l'inspecteur, comme JS ordinaire s'exécutant dans Chrome.

entrez la description de l'image ici

Il n'est pas nécessaire de rouvrir l'inspecteur, il se connecte automatiquement au nœud dès que le nœud démarre ou redémarre. Les deux --inspect et Chrome DevTools pour le nœud peuvent ne pas être disponibles dans les anciennes versions de nœud et Chrome.

Ali
la source
1
Un message pour moi: essayez ça -> node.exe --inspect index.js
Lonely
Cela devrait être au top. meilleure réponse. :)
princebillyGK
11

Ces deux usages peuvent être appliqués:

// 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));
Erce
la source
10

Je pense que cela pourrait vous être utile.

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

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

Comme mentionné dans cette réponse :

JSON.stringifyLe troisième paramètre de définit l'insertion d'espaces blancs pour la jolie impression. Il peut s'agir d'une chaîne ou d'un nombre (nombre d'espaces).

Nirav Sutariya
la source
4

Vous pouvez simplement ajouter une inspect()méthode à votre objet qui remplacera la représentation de l'objet dans les console.logmessages

par exemple:

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

ensuite, votre objet sera représenté comme requis dans console.log et shell de noeud

harish2704
la source
3

Une astuce simple serait d'utiliser un debugmodule pour ajouterDEBUG_DEPTH=null comme variable d'environnement lors de l'exécution du script

Ex.

DEBUG = * DEBUG_DEPTH = noeud nul index.js

Dans votre code

const debug = require('debug');
debug("%O", myObject);
Chintan
la source
@Bala Vous devrez installer le module "debug" dans votre projet "npm install debug --save"
Chintan
2

Le nœud REPL a une solution intégrée pour remplacer la façon dont les objets sont affichés, voir ici .

Le module REPL utilise en interne util.inspect(), lors de l'impression des valeurs. Cependant, util.inspectdélègue l'appel à la inspect() fonction de l'objet , s'il en a une.

Lloyd
la source
2

Option la plus simple:

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

Sunil Jamkatel
la source
Cela ne résout pas le problème de l'impression myObjectà une profondeur arbitraire
Gershom
0

JSON.stringify ()

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

Idéal pour une inspection approfondie des objets de données. Cette approche fonctionne sur les tableaux imbriqués et les objets imbriqués avec des tableaux.

Stephen Blum
la source