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

lors du débogage en utilisant 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);

sorties:

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

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

577
demandé sur Michał Perłakowski 2012-05-24 03:29:28
la source

14 ответов

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

sorties

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

voir util.inspect() docs .

984
répondu 250R 2018-09-04 21:28:55
la source

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

464
répondu 2 revs, 2 users 92%user1106925 2013-07-07 10:28:13
la source

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.
156
répondu mklement0 2018-04-20 02:39:23
la source

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

console.log('connection : %j', myObject);
45
répondu niksmac 2014-01-15 20:05:42
la source

essayez ceci:

console.dir(myObject,{depth:null})
25
répondu hirra 2015-10-19 15:12:44
la source

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.

17
répondu Luke W 2014-03-02 05:27:02
la source

, Vous pouvez aussi le faire

console.log(JSON.stringify(myObject, null, 3));
17
répondu essaji 2016-03-09 05:27:13
la source

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);
14
répondu silverwind 2017-01-26 23:32:12
la source

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.

enter image description here

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.

11
répondu Ali 2017-04-17 14:43:23
la source

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));
6
répondu Erce 2018-01-11 16:16:26
la source

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

4
répondu harish2704 2015-11-25 09:27:54
la source

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);
3
répondu Chintan 2017-11-18 11:18:18
la source

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.

2
répondu Lloyd 2016-02-11 20:02:16
la source

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

-1
répondu shotex 2018-02-09 02:44:51
la source

Autres questions sur javascript node.js debugging console.log