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


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.


545
2018-05-23 23:29


origine


Réponses:


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

Les sorties

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

Voir util.inspect() docs.


930
2018-05-23 23:30



Vous pouvez utiliser JSON.stringify, et obtenir une bonne indentation ainsi que peut-être plus facile à retenir 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, vous pouvez donc ajuster cela 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


442
2017-12-17 20:57



Une compilation des nombreuses réponses utiles de (au moins) Node.js v0.10.33 (stable) / v0.11.14 (instable) probablement à travers (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 l'utilisation de REPL Node.js util.inspect()  implicitement, donc il n'est généralement pas nécessaire de require('util') et appel 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 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 peut pas passer d'options par util.inspect() dans ce cas, ce qui implique 2 limitations notables:
        • De construction profondeur de la sortie est limité à 2 les niveaux (le défaut).
          • Puisque vous ne pouvez pas changer cela avec console.log(), vous devez plutôt utiliser console.dir(): console.dir(myObject, { depth: null } imprime avec illimité profondeur; voir ci-dessous.
        • Vous ne pouvez pas activer la coloration syntaxique.
    • Si le 1er argument est une chaîne de format (voir ci-dessous): utilisations 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 objets  util.inspect()-style.
        • JSON généré avec %j n'est pas joli imprimé.
  • console.dir():

    • Accepte seulement 1 argument pour inspecteret s'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 second 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.
  • Le REPL: imprime implicitement la valeur de retour de toute expression avec util.inspect()  avec  coloration syntaxique;
    c'est-à-dire, en tapant simplement le nom d'une variable et en appuyant sur Entrée, vous imprimez 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) jolies impressions objet et tableau représentationsmais produit multiligne sortie seulement quand nécessaire - Si tout va sur 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, depuis les sauts de ligne ne se produisent qu'aux limites de la propriété, vous finirez souvent avec des lignes plus courtes, mais elles peuvent également être plus longues (par exemple, avec des valeurs de propriété longues).

  • Dans v6.3.0 +, vous pouvez utiliser le breakLength option pour remplacer la limite de 60 caractères; si vous le définissez Infinity, tout est sorti sur un unique ligne.

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

  • Échoue avec des objets qui ont références circulaires, tel que module dans le contexte mondial.
  • Méthodes (fonctions) ne sera pas inclus 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 (2ème argument):

la source: http://nodejs.org/api/util.html#util_util_format_format

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

  • showHidden
    • si true, puis 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 obj ou Object.keys(obj)] sera montré aussi. Par défaut à false.
  • depth
    • dit inspecter combien de fois recurse pendant le formatage de l'objet. Ceci est utile pour inspecter de grands objets compliqués. Par défaut à 2. Pour le faire recurse indéfiniment, passer null.
  • colors
    • si vrai, alors la sortie sera stylée avec des codes de couleurs ANSI. Par défaut à false. Les couleurs sont personnalisables [... - voir le lien].
  • customInspect
    • si false, puis personnalisé inspect() les fonctions définies sur les objets inspectés ne seront pas appelées. Par défaut à true.

util.format() des espaces réservés à la chaîne de format (1er argument)

la source: http://nodejs.org/api/util.html#util_util_format_format

  • %s - Chaîne.
  • %d - Nombre (entier et flottant).
  • %j - JSON.
  • % - signe de pourcentage unique ('%'). Cela ne consomme pas d'argument.

139
2018-01-15 16:05



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

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

43
2017-10-19 11:05



Essaye ça:

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

22
2018-03-02 01:27



peut être console.dir est 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.


16
2018-02-14 10:32



Vous pouvez aussi faire

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

16
2018-01-26 20:32



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

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

13
2018-04-17 11:37