Comment puis-je obtenir l'objet complet dans le noeud.js console.log (), plutot que '[Object]'?

vous pouvez utiliser JSON.stringify , et obtenir une belle indentation ainsi que peut-être plus facile à se rappeler la syntaxe.

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, de sorte que vous pouvez ajuster cela comme désiré.

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 du (au moins) noeud.js v0.10.33 (stable) / v0.11.14 (instable) probablement par (au moins) v7.7.4 (la version actuelle de la dernière mise à jour de cette réponse).}

tl; dr

util.inspect() est au cœur de la sortie de diagnostic: console.log() et console.dir() ainsi que le noeud.JS REPL use util.inspect() implicitement , il N'est donc généralement pas nécessaire de require('util') et d'appeler util.inspect() directement .

pour obtenir la sortie désirée pour l'exemple dans la question:

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

détails ci-dessous.

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

  • si le premier argument N'est pas une chaîne de format : util.inspect() s'applique automatiquement à 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 peut pas passer les options à util.inspect() dans ce cas, ce qui implique 2 limites notables:
      • Structurelle profondeur de la production est limitée 2 niveaux (valeur par défaut).
        • puisque vous ne pouvez pas changer cela avec console.log() , vous devez plutôt utiliser console.dir() : console.dir(myObject, { depth: null } gravures avec illimité profondeur ; voir ci-dessous.
      • vous ne pouvez pas activer la coloration syntaxique.
  • si le premier 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"}'
    • Note:
      • il n'y a pas d'espace réservé pour représenter objets util.inspect() - style.
      • JSON généré avec %j n'est PAS joli-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.
  • nœud.js v0.11.14+ : le le deuxième argument optionnel spécifie les options pour util.inspect() - voir ci-dessous; par exemple:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // node 0.11+: Prints object representation with syntax coloring.

• la réponse : imprime implicitement la valeur de retour de toute expression avec util.inspect() avec coloration de la syntaxe ;
  
  i.e., il suffit de taper le nom d'une variable et le fait de frapper Enter permet d'imprimer une version inspectée de sa valeur; par exemple::
  • o = { one: 1, two: 'deux', foo: function(){} } // echoes the object definition with syntax coloring.

util.inspect() automatiquement (et invariablement) pretty-imprime object et array representations , mais produit multiligne sortie seulement si nécessaire - si tout correspond à une ligne, une seule ligne est imprimée.

• par défaut, la sortie est enveloppée à environ 60 caractères ^{merci, Shrey} , que la sortie soit envoyée à un fichier ou à un terminal. En pratique, puisque les ruptures de ligne ne se produisent qu'aux limites de propriété , vous vous retrouverez souvent avec des lignes plus courtes, mais elles peuvent aussi être plus longues (par exemple, avec de longues propriétés valeur.)

• In v6.3.0 + Vous pouvez utiliser l'option breakLength pour outrepasser la limite de 60 caractères; si vous la définissez à Infinity , tout est sorti sur une ligne simple .

si vous voulez plus de contrôle sur le pretty-printing, envisagez d'utiliser JSON.stringify() avec un 3ème argument , mais notez ce qui suit:

• échoue avec des objets qui ont des références circulaires , comme module dans le contexte global.
• Méthodes (fonctions) de par leur conception ne PAS être inclus.
• vous ne pouvez pas choisir de montrer des propriétés cachées (non-dénombrables).
• 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):

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

un objet optionnel options peut être passé qui modifie certains aspects de la chaîne formatée:

• showHidden
  • si true , alors les propriétés non-dénombrables de l'objet [ceux désignés pour ne pas apparaître lorsque vous utilisez for keys in obj ou Object.keys(obj) ] seront également affichés. Par défaut, false .
• depth
  • indique inspecter combien de fois pour revenir en formatage de l'objet. Ceci est utile pour inspecter de grands objets compliqués. Valeur par défaut est 2. Pour le faire réapparaître indéfiniment, passez null .
• colors
  • si elle est vraie, alors la sortie sera stylisée avec des codes de couleur ANSI. Par défaut, false . Les couleurs sont personnalisables [... - voir le lien].
• customInspect
  • si false , alors les fonctions personnalisées inspect() définies sur les objets inspectés ne seront pas appelées. Par défaut, true .

util.format() format - chaîne placeholders (1er argument)

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

• %s - Chaîne de caractères.
• %d - nombre (entier et flottant).
• %j - JSON.
• % - signe à un pour cent ('%'). Ce ne consomme pas un argument.

une autre méthode simple est de le convertir en json

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

essayez ceci:

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

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

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

utilise util.inspecter sur obj et imprime la chaîne résultante à stdout.

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

, Vous pouvez aussi le faire

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

Depuis Noeud.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);

une bonne façon d'inspecter les objets est d'utiliser le noeud --inspecter option avec Chrome DevTools pour le noeud .

node.exe --inspect www.js

ouvrir chrome://inspect/#devices dans chrome et cliquez sur ouvrir DevTools dédiés pour le noeud

maintenant chaque objet connecté est disponible dans inspector comme les js réguliers fonctionnant dans chrome.

il n'est pas nécessaire de rouvrir inspector, il se connecte au noeud automatiquement dès que le noeud démarre ou redémarre. Les deux --inspecter et Chrome DevTools pour Noeud peut ne pas être disponible dans les anciennes versions de noeud et Chrome.

ces deux usages peuvent s'appliquer

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

vous pouvez simplement ajouter une méthode inspect() à votre objet qui va outrepasser la représentation de l'objet dans console.log messages

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

alors, votre objet sera représenté comme requis dans les deux consoles.le journal et le nœud shell

une astuce simple serait d'utiliser debug module pour ajouter DEBUG_DEPTH=null comme variable d'environnement lors de l'exécution du script

ex.

DEBUG=* DEBUG_DEPTH = null node index.js

dans votre code

const debug = require('debug');
debug("%O", myObject);

le noeud REPL a une solution intégrée pour modifier 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.inspect délègue l'appel à l'objet inspect() fonction, si elle en a un.

essayez cette fonction d'aide

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

Utilisation:

l(obj1,obj2...)

vous pouvez également l'utiliser dans d'autres environnements javascript comme PhantomJs par exemple