Saat debugging menggunakan console.log(), bagaimana saya bisa mendapatkan objek lengkap?

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

Output:

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

Tapi saya ingin juga melihat konten properti f.

Anda perlu menggunakan 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 */))

Keluaran

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

Lihat util.inspect()dokumen .

Anda dapat menggunakan JSON.stringify, dan mendapatkan beberapa lekukan yang bagus serta mungkin lebih mudah untuk diingat sintaks.

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

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

Argumen ketiga menetapkan tingkat indentasi, sehingga Anda dapat menyesuaikannya sesuai keinginan.

Lebih detail di sini jika diperlukan:

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

^{Kompilasi dari banyak jawaban yang berguna dari (setidaknya) Node.js v0.10.33(stable) / v0.11.14(tidak stabil) mungkin melalui (setidaknya) v7.7.4(versi saat ini pada pembaruan terbaru untuk jawaban ini). Ujung topi untuk Rory O'Kane atas bantuannya.}

tl; dr

Untuk mendapatkan hasil yang diinginkan untuk contoh dalam pertanyaan, gunakan console.dir():

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

Mengapa tidak util.inspect()? Karena sudah di jantung keluaran diagnostik: console.log()dan console.dir()juga REPL Node.js digunakan util.inspect() secara implisit . Biasanya tidak perlurequire('util') dan menelepon util.inspect()langsung.

Detail di bawah.

• console.log()(dan aliasnya console.info()):

  • Jika argumen 1 BUKAN string format : util.inspect()diterapkan secara otomatis ke setiap argumen:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • Perhatikan bahwa Anda tidak bisa lewat pilihan melalui util.inspect()dalam hal ini, yang berarti 2 keterbatasan penting:
      • Kedalaman struktural dari output terbatas pada 2 level (standar).
        • Karena Anda tidak dapat mengubah ini dengan console.log(), Anda harus menggunakan console.dir(): console.dir(myObject, { depth: null }cetakan dengan kedalaman tak terbatas ; Lihat di bawah.
      • Anda tidak dapat mengaktifkan pewarnaan sintaks.
  • Jika argumen 1 IS string format (lihat di bawah): digunakan util.format()untuk mencetak argumen yang tersisa berdasarkan string format (lihat di bawah); misalnya:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • catatan:
      • Tidak ada placeholder untuk mewakili objek- util.inspect() gaya.
      • JSON yang dihasilkan dengan %jBUKAN dicetak dengan cantik.

• console.dir():

  • Hanya menerima 1 argumen untuk memeriksa , dan selalu berlaku util.inspect()- pada dasarnya, pembungkus util.inspect()tanpa opsi secara default; misalnya:
    • 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 + : Argumen ke-2 opsional menetapkan opsi untukutil.inspect() - lihat di bawah; misalnya:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• REPL : secara implisit mencetak nilai pengembalian ekspresi util.inspect() dengan pewarnaan sintaks ;
  yaitu, hanya mengetik nama variabel dan menekan Enter akan mencetak versi yang diperiksa nilainya; misalnya:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()secara otomatis mencetak objek dan representasi array , tetapi menghasilkan output multiline hanya jika diperlukan .

• Perilaku pencetakan cantik dapat dikontrol oleh compactproperti dalam optionsargumen opsional ; falsemenggunakan multi-line output tanpa syarat , sedangkan truemenonaktifkan pencetakan-cantik sama sekali; itu juga dapat diatur ke angka (standarnya adalah 3) untuk mengontrol perilaku multi-line bersyarat - lihat dokumen .

• Secara default, output dibungkus sekitar 60 karakter ^{terima kasih, Shrey} , terlepas dari apakah output dikirim ke file atau terminal. Dalam praktiknya, karena jeda baris hanya terjadi pada batas properti , Anda akan sering berakhir dengan garis yang lebih pendek, tetapi garis tersebut juga bisa lebih panjang (misalnya, dengan nilai properti yang panjang).

• Di v6.3.0 + Anda dapat menggunakan breakLengthopsi untuk mengganti batas 60 karakter; jika Anda mengaturnya Infinity, semuanya adalah output pada satu baris.

Jika Anda ingin lebih mengontrol pencetakan cantik, pertimbangkan untuk menggunakan JSON.stringify()argumen ke-3 , tetapi perhatikan hal berikut:

• Gagal dengan objek yang memiliki referensi melingkar , seperti moduledalam konteks global.
• Metode (fungsi) dengan desain TIDAK akan dimasukkan.
• Anda tidak dapat ikut serta dalam memperlihatkan properti yang tersembunyi (tidak dapat dihitung).
• Contoh panggilan:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect()objek pilihan (argumen 2):

Objek opsi opsional dapat diberikan yang mengubah aspek tertentu dari string yang diformat; beberapa properti yang didukung adalah:

^{Lihat dokumen Node.js terbaru untuk daftar lengkap saat ini.}

• showHidden

  • jika true, maka properti non-enumerable objek [yang ditunjuk untuk tidak muncul ketika Anda menggunakan for keys in objatau Object.keys(obj)] akan ditampilkan juga. Default ke false.

• depth

  • memberitahu memeriksa berapa kali untuk berulang saat memformat objek. Ini berguna untuk memeriksa benda rumit yang besar. Default ke 2. Untuk membuatnya berulang tanpa batas, lewati null.

• colors

  • jika benar, maka output akan ditata dengan kode warna ANSI. Default ke false. Warna dapat disesuaikan [... - lihat tautan].

• customInspect

  • jika false, maka inspect()fungsi khusus yang didefinisikan pada objek yang sedang diperiksa tidak akan dipanggil. Default ke true.

util.format()penampung format-string (argumen 1)

Beberapa placeholder yang didukung adalah:

^{Lihat dokumen Node.js terbaru untuk daftar lengkap saat ini.}

• %s - Tali.
• %d - Nomor (bilangan bulat dan mengambang).
• %j - JSON.
• %%- tanda persen tunggal ('%'). Ini tidak menggunakan argumen.

Metode sederhana lain adalah dengan mengubahnya menjadi json

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

Coba ini:

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

Sejak Node.js 6.4.0, ini dapat diselesaikan dengan elegan dengan util.inspect.defaultOptions:

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

mungkin console.diritu yang kamu butuhkan.

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

Menggunakan util.inspect pada obj dan mencetak string yang dihasilkan ke stdout.

gunakan opsi util jika Anda membutuhkan lebih banyak kontrol.

Anda juga bisa melakukannya

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

Cara yang baik untuk memeriksa objek adalah dengan menggunakan opsi node --inspect dengan Chrome DevTools untuk Node .

node.exe --inspect www.js

Buka chrome://inspect/#devicesdi chrome dan klik Buka DevTools khusus untuk Node

Sekarang setiap objek yang dicatat tersedia di inspektur seperti JS biasa yang berjalan di chrome.

Tidak perlu membuka kembali inspektur, itu terhubung ke simpul secara otomatis segera setelah simpul mulai atau restart. Baik --inspect dan Chrome DevTools untuk Node mungkin tidak tersedia dalam versi Node dan Chrome yang lebih lama.

Kedua penggunaan ini dapat diterapkan:

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

Saya pikir ini bisa bermanfaat bagi Anda.

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

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

Sebagaimana disebutkan dalam jawaban ini :

JSON.stringifyParameter ketiga mendefinisikan penyisipan white-space untuk pencetakan cantik. Ini bisa berupa string atau angka (jumlah spasi).

Anda cukup menambahkan inspect()metode ke objek Anda yang akan menimpa representasi objek dalam console.logpesan

misalnya:

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

kemudian, objek Anda akan direpresentasikan seperti yang diperlukan di console.log dan node shell

Trik sederhana akan menggunakan debugmodul untuk menambahkan DEBUG_DEPTH=nullvariabel lingkungan saat menjalankan skrip

Ex.

DEBUG = * DEBUG_DEPTH = null node index.js

Dalam kode Anda

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

Node REPL memiliki solusi bawaan untuk mengganti cara objek ditampilkan, lihat di sini .

Modul REPL digunakan secara internal util.inspect(), saat mencetak nilai. Namun, util.inspectdelegasikan panggilan ke inspect() fungsi objek, jika ada.

Opsi termudah:

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

JSON.stringify ()

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

Bagus untuk pemeriksaan mendalam terhadap objek data. Pendekatan ini bekerja pada array bersarang dan objek bersarang dengan array.