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.

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 .

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

^{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.

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

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

Essaye ça:

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

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

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.

Vous pouvez aussi faire

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

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.

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.

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

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

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

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

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.

Option la plus simple:

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

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.