Вам нужно использовать 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 */))

Выходы

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

См. util.inspect() docs.

Вы можете использовать JSON.stringify и получить хороший отступ, а также, возможно, более легкий для запоминания синтаксис.

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

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

Третий аргумент устанавливает уровень отступа, поэтому вы можете настроить его по своему усмотрению.

Более подробно здесь, если необходимо:

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

^{Подборка множества полезных ответов от (как минимум) Node.js v0.10.33 (стабильный) / v0.11.14 (нестабильный), предположительно, до (как минимум) v7.7.4 (текущая версия на момент последнего обновления этого ответа). Совет перед Рори О'Кейну за его помощь.}

tl; dr

Чтобы получить желаемый результат для примера в вопросе, используйте console.dir():

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

Почему не util.inspect()? Потому что он уже лежит в основе диагностического вывода: console.log() и console.dir(), а также REPL для Node.js используют util.inspect() неявно. Обычно нет необходимости require('util') и напрямую звонить util.inspect().

Подробности ниже.

• console.log() (и его псевдоним _ 13_):

  • If the 1st argument is NOT a format string: util.inspect() is automatically applied to every argument:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • Note that you cannot pass options through util.inspect() in this case, which implies 2 notable limitations:
      • Structural depth of the output is limited to 2 levels (the default).
        • Since you cannot change this with console.log(), you must instead use console.dir(): console.dir(myObject, { depth: null } prints with unlimited depth; see below.
      • Вы не можете включить подсветку синтаксиса.
  • If the 1st argument IS a format string (see below): uses util.format() to print the remaining arguments based on the format string (see below); e.g.:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • Note:
      • There is NO placeholder for representing objects util.inspect()-style.
      • JSON, созданный с помощью %j, НЕ является красивым.

• console.dir():

  • Accepts only 1 argument to inspect, and always applies util.inspect() – essentially, a wrapper for util.inspect() without options by default; e.g.:
    • 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+: The optional 2nd argument specifies options for util.inspect() – see below; e.g.:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• The REPL: implicitly prints any expression's return value with util.inspect() with syntax coloring;
  i.e., just typing a variable's name and hitting Enter will print an inspected version of its value; e.g.:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect() автоматически распечатывает объект и массив представлений, но выводит многострочный вывод только при необходимости.

• Поведение красивой печати можно контролировать с помощью свойства compact в необязательном аргументе options; false использует многострочный вывод безусловно, тогда как true полностью отключает красивую печать; также можно установить число (по умолчанию 3) для управления условным многострочным поведением - см. документы.

• По умолчанию вывод упаковывается в примерно 60 символов < sup> спасибо, Shrey, независимо от того, отправляется ли вывод в файл или на терминал. На практике, поскольку разрывы строк происходят только на границах свойств, вы часто получаете более короткие строки, но они также могут быть длиннее (например, с длинными значениями свойств).

• В v6.3.0 + вы можете использовать параметр breakLength для отмены ограничения в 60 символов; если вы установите его на Infinity, все будет выводиться в виде одной строки.

Если вам нужен больший контроль над красивой печатью, рассмотрите возможность использования _ 40_ с третьим аргументом, но обратите внимание на следующее:

• Сбой с объектами, имеющими циклические ссылки, например module в глобальном контексте.
• Методы (функции) НЕ будут включены по замыслу.
• Вы не можете выбрать отображение скрытых (неперечислимых) свойств.
• Example call:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect() объект параметров (второй аргумент):

Может быть передан необязательный объект options, который изменяет определенные аспекты форматированной строки; некоторые поддерживаемые свойства:

^{Текущий полный список см. в последней документации по Node.js.}

• showHidden

  • if true, then the object's non-enumerable properties [those designated not to show up when you use for keys in obj or Object.keys(obj)] will be shown too. Defaults to false.

• depth

  • tells inspect how many times to recurse while formatting the object. This is useful for inspecting large complicated objects. Defaults to 2. To make it recurse indefinitely, pass null.

• colors

  • if true, then the output will be styled with ANSI color codes. Defaults to false. Colors are customizable [… – see link].

• customInspect

  • if false, then custom inspect() functions defined on the objects being inspected won't be called. Defaults to true.

util.format() заполнители строки формата (1-й аргумент)

Некоторые поддерживаемые заполнители:

^{Текущий полный список см. в последних документах по Node.js.}

• %s - Строка.
• %d - Число (как целое, так и с плавающей запятой).
• %j - JSON.
• %% - одинарный знак процента («%»). Это не требует аргументов.

Другой простой способ - преобразовать его в json.

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

Начиная с Node.js 6.4.0, эту проблему можно элегантно решить с помощью util.inspect.defaultOptions:

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

Попробуй это:

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

возможно console.dir - это все, что вам нужно.

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

Использует util.inspect для obj и выводит полученную строку на стандартный вывод.

используйте опцию util, если вам нужно больше контроля.

Могут быть применены оба этих использования:

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

Вы также можете сделать

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

Хороший способ проверки объектов - использовать параметр узла --inspect с Chrome DevTools for Node.

node.exe --inspect www.js

Откройте chrome://inspect/#devices в Chrome и нажмите Открыть выделенный DevTools для узла.

Теперь каждый зарегистрированный объект доступен в инспекторе, как обычный JS, запущенный в chrome.

Нет необходимости повторно открывать инспектор, он подключается к узлу автоматически, как только узел запускается или перезапускается. И --inspect, и Chrome DevTools for Node могут быть недоступны в старых версиях Node и Chrome.

Думаю, это может быть вам полезно.

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

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

Как упоминалось в этом ответе:

Третий параметр JSON.stringify определяет вставку пробелов для красивой печати. Это может быть строка или число (количество пробелов).

Вы можете просто добавить inspect() метод к своему объекту, который переопределит представление объекта в console.log сообщениях.

eg:

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

тогда ваш объект будет представлен как в console.log, так и в оболочке узла.

Обновлять:

object.inspect устарел (https://github.com/nodejs/node/issues/15549). Вместо этого используйте myObject [util.inspect.custom]:

const util = require('util')

var myObject = {
  /* nested properties not shown */
}

myObject[util.inspect.custom] = function(){ return JSON.stringify( this, null, 4 ); }


console.log(util.inspect(myObject))

Простым трюком будет использование модуля debug для добавления DEBUG_DEPTH=null в качестве переменной среды при запуске скрипта.

Ex.

DEBUG = * DEBUG_DEPTH = нулевой узел index.js

В вашем коде

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

Самый простой вариант:

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

JSON.stringify ()

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

Отлично подходит для глубокого изучения объектов данных. Этот подход работает с вложенными массивами и вложенными объектами с массивами.

Узел REPL имеет встроенное решение для переопределения способа отображения объектов, см. здесь.

Модуль REPL внутренне использует util.inspect() при печати значений. Однако util.inspect делегирует вызов функции inspect() объекта, если она есть.

Если вы ищете способ показать скрытые элементы в вашем массиве, вам нужно передать maxArrayLength: Infinity

console.log(util.inspect(value, { maxArrayLength: Infinity }));