Ao depurar usando console.log(), como posso obter o objeto completo?

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

Saídas:

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

Mas também quero ver o conteúdo da propriedade f.

Você precisa usar 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 */))

Saídas

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

Veja util.inspect()documentos .

Você pode usar JSON.stringifye obter um bom recuo, bem como, talvez, mais fácil de lembrar a sintaxe.

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

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

O terceiro argumento define o nível de indentação, para que você possa ajustá-lo conforme desejado.

Mais detalhes aqui, se necessário:

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

^{Uma compilação das muitas respostas úteis de (pelo menos) Node.js v0.10.33(estável) / v0.11.14(instável) presumivelmente através de (pelo menos) v7.7.4(a versão atual da última atualização desta resposta). Ponta do chapéu para Rory O'Kane por sua ajuda.}

tl; dr

Para obter a saída desejada para o exemplo na pergunta, use console.dir():

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

Por que não util.inspect()? Porque ele já está no coração da saída de diagnóstico: console.log()e console.dir()o REPL do Node.js. usa util.inspect() implicitamente . Geralmente, não é necessáriorequire('util') ligar e ligar util.inspect()diretamente.

Detalhes abaixo.

• console.log()(e seu apelido console.info()):

  • Se o 1º argumento NÃO for uma string de formato : util.inspect()será aplicada automaticamente a todos os argumentos:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • Note que você não pode passar opções através util.inspect(), neste caso, o que implica 2 limitações notáveis:
      • A profundidade estrutural da saída é limitada a 2 níveis (o padrão).
        • Como você não pode alterar isso console.log(), deve usar console.dir(): console.dir(myObject, { depth: null }imprime com profundidade ilimitada ; ver abaixo.
      • Você não pode ativar a coloração de sintaxe.
  • Se o 1º argumento for uma string de formato (veja abaixo): use util.format()para imprimir os argumentos restantes com base na string de formato (veja abaixo); por exemplo:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • Nota:
      • Não há espaço reservado para representar objetos - util.inspect() estilo.
      • JSON gerado com %jNÃO é muito impresso.

• console.dir():

  • Aceita apenas 1 argumento para inspecionar e sempre aplica util.inspect()- essencialmente, um wrapper para util.inspect()sem opções por padrão; por exemplo:
    • 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 + : O segundo argumento opcional especifica opções parautil.inspect() - veja abaixo; por exemplo:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• O REPL : imprime implicitamente o valor de retorno de qualquer expressão util.inspect() com cor de sintaxe ;
  ou seja, basta digitar o nome de uma variável e pressionar Enter para imprimir uma versão inspecionada de seu valor; por exemplo:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()imprime automaticamente representações de objetos e matrizes , mas produz saída de várias linhas somente quando necessário .

• O comportamento de impressão bonita pode ser controlado pela compactpropriedade no optionsargumento opcional ; falseusa saída de várias linhas incondicionalmente , enquanto truedesativa completamente a impressão; também pode ser definido como um número (o padrão é 3) para controlar o comportamento condicional de várias linhas - consulte os documentos .

• Por padrão, a saída é ajustada em cerca de 60 caracteres ^{, obrigado Shrey} , independentemente de a saída ser enviada para um arquivo ou um terminal. Na prática, como as quebras de linha acontecem apenas nos limites das propriedades , muitas vezes você acaba com linhas mais curtas, mas elas também podem ser mais longas (por exemplo, com valores de propriedades longos).

• Na v6.3.0 +, você pode usar a breakLengthopção para substituir o limite de 60 caracteres; se você configurá-lo como Infinity, tudo será emitido em uma única linha.

Se você deseja ter mais controle sobre a impressão bonita, considere usar JSON.stringify()com um terceiro argumento , mas observe o seguinte:

• Falha com objetos que possuem referências circulares , como moduleno contexto global.
• Métodos (funções) NÃO serão incluídos por design.
• Você não pode optar por mostrar propriedades ocultas (não enumeráveis).
• Chamada de exemplo:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect()objeto de opções (segundo argumento):

Um objeto de opções opcionais pode ser passado que altera certos aspectos da sequência formatada; algumas das propriedades suportadas são:

^{Consulte os documentos mais recentes do Node.js. para obter a lista completa e atual.}

• showHidden

  • se true, as propriedades não enumeráveis ​​do objeto [aquelas designadas para não aparecer quando você usa for keys in objou Object.keys(obj)] também serão mostradas. O padrão é false.

• depth

  • informa a inspeção quantas vezes se repetir durante a formatação do objeto. Isso é útil para inspecionar objetos grandes e complicados. O padrão é 2. Para fazê-lo recuar indefinidamente, passe null.

• colors

  • se verdadeiro, a saída será estilizada com códigos de cores ANSI. O padrão é false. As cores são personalizáveis ​​[… - veja o link].

• customInspect

  • se false, as inspect()funções personalizadas definidas nos objetos que estão sendo inspecionados não serão chamadas. O padrão é true.

util.format()espaços reservados de string de formato (1º argumento)

Alguns dos espaços reservados suportados são:

^{Consulte os documentos mais recentes do Node.js. para obter a lista completa e atual.}

• %s - Corda.
• %d - Número (inteiro e flutuante).
• %j - JSON.
• %%- sinal de porcentagem único ('%'). Isso não consome um argumento.

Outro método simples é convertê-lo para json

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

Tente o seguinte:

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

Desde o Node.js. 6.4.0, isso pode ser resolvido com elegância com util.inspect.defaultOptions:

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

talvez console.dirseja tudo que você precisa.

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

Usa util.inspect em obj e imprime a string resultante em stdout.

use a opção util se precisar de mais controle.

Você também pode fazer

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

Uma boa maneira de inspecionar objetos é usar a opção node --inspect com o Chrome DevTools for Node .

node.exe --inspect www.js

Abra chrome://inspect/#devicesno chrome e clique em Abrir DevTools dedicado para Node

Agora, todos os objetos registrados estão disponíveis no inspetor, como o JS normal, executando no chrome.

Não há necessidade de reabrir o inspetor, ele se conecta ao nó automaticamente assim que o nó é iniciado ou reiniciado. O --inspect e o DevTools do Chrome para Node podem não estar disponíveis em versões mais antigas do Node e do Chrome.

Ambos os usos podem ser aplicados:

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

Eu acho que isso poderia ser útil para você.

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

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

Como mencionado nesta resposta :

JSON.stringifyO terceiro parâmetro define a inserção de espaço em branco para uma impressão bonita. Pode ser uma sequência ou um número (número de espaços).

Você pode simplesmente adicionar um inspect()método ao seu objeto que substituirá a representação do objeto nas console.logmensagens

por exemplo:

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

então, seu objeto será representado conforme necessário no console.log e no shell do nó

Um truque simples seria usar o debugmódulo para adicionar DEBUG_DEPTH=nullcomo variável de ambiente ao executar o script

Ex.

DEBUG = * DEBUG_DEPTH = nó nulo index.js

No seu código

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

O nó REPL possui uma solução integrada para substituir como os objetos são exibidos, veja aqui .

O módulo REPL usa internamente util.inspect(), ao imprimir valores. No entanto, util.inspectdelega a chamada para a inspect() função do objeto , se houver uma.

Opção mais fácil:

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

JSON.stringify ()

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

Ótimo para inspeção profunda de objetos de dados. Essa abordagem funciona em matrizes aninhadas e objetos aninhados com matrizes.