භාවිතයෙන් නිදොස්කරණය කිරීමේදී console.log(), සම්පූර්ණ වස්තුව ලබා ගන්නේ කෙසේද?

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

නිමැවුම්:

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

නමුත් දේපලවල අන්තර්ගතය ද දැකීමට මට අවශ්‍යය f.

ඔබ භාවිතා කිරීමට අවශ්‍යයි 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()ලියකියවිලි බලන්න .

ඔබට භාවිතා කළ හැකි අතර 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()මෙන්ම Node.js repl භාවිතය util.inspect() නිසැකයෙන්ම . එය සාමාන්‍යයෙන් ඇමතීමට අවශ්‍ය නොවේrequire('util')util.inspect() කෙලින්ම .

විස්තර පහතින්.

• console.log()(සහ එහි අන්වර්ථය, console.info()):

  • 1 වන තර්කය ආකෘති නූලක් නොවේ නම් : util.inspect()සෑම තර්කයක් සඳහාම ස්වයංක්‍රීයව යොදනු ලැබේ:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log(o, [1,2,3]) // -> '{ one: 1, two: 'deux', foo: [Function] } [ 1, 2, 3 ]'
    • ඔබට විකල්ප හරහා යා නොහැකි බව සලකන්නutil.inspect() , මේ අවස්ථාවේ දී සැලකිය යුතු සීමාවන් 2 ගම්ය වන:
      • නිමැවුමේ ව්‍යුහාත්මක ගැඹුර මට්ටම් 2 කට සීමා වේ (පෙරනිමිය).
        • ඔබට මෙය වෙනස් කළ නොහැකි බැවින් console.log(), ඔබ ඒ වෙනුවට භාවිතා කළ යුතුය console.dir(): අසීමිත ගැඹුරකින් console.dir(myObject, { depth: null }මුද්‍රණය කිරීම ; පහත බලන්න.
      • ඔබට සින්ටැක්ස් වර්ණ ගැන්වීම සක්‍රිය කළ නොහැක.
  • 1 වන තර්කය ආකෘති නූලක් නම් (පහත බලන්න): util.format()ආකෘති නූල් මත පදනම්ව ඉතිරි තර්ක මුද්‍රණය කිරීමට භාවිතා කරයි (පහත බලන්න); උදා:
    • o = { one: 1, two: 'deux', foo: function(){} }; console.log('o as JSON: %j', o) // -> 'o as JSON: {"one":1,"two":"deux"}'
    • සටහන:
      • වස්තූන් නිරූපණය කිරීම සඳහා ස්ථානutil.inspect() දරන්නා නොමැත.
      • JSON සමඟ ජනනය කර %jඇත්තේ මුද්‍රණය කර නැත.

• console.dir():

  • පරීක්ෂා කිරීම සඳහා තර්ක 1 ක් පමණක් පිළිගන්නා අතර සෑම විටම අදාළ වේ util.inspect()- අත්‍යවශ්‍යයෙන්ම, util.inspect()පෙරනිමියෙන් විකල්ප නොමැතිව රැහැන් ඇදීම ; උදා:
    • 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 + : විකල්ප 2 වන තර්කය සඳහා විකල්පයන්util.inspect() නියම කරයි - පහත බලන්න; උදා:
    • console.dir({ one: 1, two: 'deux'}, { colors: true }); // Node 0.11+: Prints object representation with syntax coloring.

• මෙම repl : නිසැකයෙන්ම ඕනෑම ප්රකාශනයක් නැවත අගය මුද්රණය util.inspect() සමග කාරක රීති පාට ;
  එනම්, විචල්‍යයක නමක් ටයිප් කර Enter යතුර එබීමෙන් එහි වටිනාකම පරීක්ෂා කළ අනුවාදයක් මුද්‍රණය වේ; උදා:
  • o = { one: 1, two: 'deux', foo: function(){} } // The REPL echoes the object definition with syntax coloring.

util.inspect()වස්තුව සහ අරාව නිරූපණයන් ස්වයංක්‍රීයව මුද්‍රණය කරයි , නමුත් අවශ්‍ය විටදී පමණක් බහු ප්‍රතිදානය නිපදවයි .

• ලස්සන මුද්‍රණ හැසිරීම compactවිකල්ප optionsතර්කයේ ඇති දේපල මගින් පාලනය කළ හැකිය ; falseබහු-රේඛීය ප්‍රතිදානය කොන්දේසි විරහිතව භාවිතා කරන අතර trueලස්සන මුද්‍රණය සම්පූර්ණයෙන්ම අක්‍රීය කරයි; කොන්දේසි සහිත බහු-රේඛීය හැසිරීම පාලනය කිරීම සඳහා එය අංකයකට සැකසිය හැකිය (පෙරනිමිය 3) - ලියකියවිලි බලන්න .

• පෙරනිමියෙන්, ප්‍රතිදානය ගොනුවකට හෝ පර්යන්තයකට යවනු ලැබුවද, ^{ස්තුතියි, ෂ්‍රේ} , අක්ෂර 60 ක් පමණ එති . ප්‍රායෝගිකව, රේඛා බිඳීම් සිදුවන්නේ දේපල මායිම්වල පමණක් බැවින් , ඔබ බොහෝ විට කෙටි රේඛා සමඟ අවසන් වනු ඇත, නමුත් ඒවා ද දිගු විය හැකිය (උදා: දිගු දේපල වටිනාකම් සහිත).

• V6.3.0 + හි ඔබට breakLengthඅක්ෂර 60 සීමාව ඉක්මවා යාම සඳහා විකල්පය භාවිතා කළ හැකිය; ඔබ එය Infinityසකසන්නේ නම්, සියල්ල තනි පේළියක ප්‍රතිදානය වේ .

ලස්සන මුද්‍රණය පිළිබඳ වැඩි පාලනයක් ඔබට අවශ්‍ය නම්JSON.stringify() , 3 වන තර්කය සමඟ භාවිතා කිරීම ගැන සලකා බලන්න , නමුත් පහත සඳහන් කරුණු සටහන් කරන්න:

• වැනි රවුම් යොමු ඇති වස්තූන් සමඟ අසමත් වේmoduleගෝලීය සන්දර්භය වේ.
• ක්‍රමසැලසුම් ( ) සැලසුම් අනුව ඇතුළත් නොවේ.
• සැඟවුණු (ගණන් කළ නොහැකි) ගුණාංග පෙන්වීමට ඔබට තෝරා ගත නොහැක.
• උදාහරණ ඇමතුම:
  • JSON.stringify({ one: 1, two: 'deux', three: true}, undefined, 2); // creates a pretty-printed multiline JSON representation indented with 2 spaces

util.inspect() විකල්ප වස්තුව (2 වන තර්කය):

ආකෘතිගත කරන ලද නූලෙහි ඇතැම් අංග වෙනස් කරන විකල්ප විකල්ප වස්තුවක් සම්මත කළ හැකිය; ඇතැම්සහාය දක්වන ගුණාංග:

^{වත්මන්, සම්පූර්ණ ලැයිස්තුව සඳහා නවතම Node.js ලියකියවිලි බලන්න .}

• showHidden

  • එසේ නම් true, වස්තුවෙහි ගණන් කළ නොහැකි ගුණාංග [ඔබ භාවිතා කරන විට නොපෙන්වන ලෙස නම් කර ඇති for keys in objහෝ Object.keys(obj)ඒවා ද පෙන්වනු ලැබේ. පෙරනිමි false.

• depth

  • වස්තුව සංයුති කිරීමේදී කොපමණ වාරයක් ආපසු යා යුතුදැයි පරීක්ෂා කිරීමට කියයි. විශාල සංකීර්ණ වස්තු පරීක්ෂා කිරීම සඳහා මෙය ප්රයෝජනවත් වේ. පෙරනිමි 2 දක්වා. එය දින නියමයක් නොමැතිව නැවත ලබා ගැනීමට නම් සමත් වන්න null.

• colors

  • සත්‍ය නම්, ප්‍රතිදානය ANSI වර්ණ කේත සමඟ හැඩගස්වනු ඇත. පෙරනිමි false. වර්ණ අභිරුචිකරණය කළ හැකිය [… - සබැඳිය බලන්න].

• customInspect

  • එසේ නම් false, inspect()පරීක්ෂා කරනු ලබන වස්තූන් මත අර්ථ දක්වා ඇති අභිරුචි කාර්යයන් කැඳවනු නොලැබේ. පෙරනිමි true.

util.format()format-string placeholders (1 වන තර්කය)

ඇතැම්සහාය දක්වන දරන්නන්:

^{වත්මන්, සම්පූර්ණ ලැයිස්තුව සඳහා නවතම Node.js ලියකියවිලි බලන්න .}

• %s - නූල්.
• %d - අංකය (නිඛිල හා පාවෙන).
• %j - JSON.
• %%- තනි ප්‍රතිශත ලකුණ ('%'). මෙය තර්කයක් පරිභෝජනය නොකරයි.

තවත් සරල ක්‍රමයක් වන්නේ එය json බවට පරිවර්තනය කිරීමයි

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

මේක උත්සාහ කරන්න:

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

Node.js 6.4.0 සිට, මෙය අලංකාර ලෙස විසඳා ගත හැක්කේ util.inspect.defaultOptions:

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

සමහර විට console.dir ඔබට අවශ්‍ය වන්නේ එයයි.

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

Stjout වෙත ප්‍රති string ලයක් ලෙස obj සහ මුද්‍රණ පිළිබඳ util.inspect භාවිතා කරයි.

ඔබට වැඩි පාලනයක් අවශ්‍ය නම් උපයෝගීතා විකල්පය භාවිතා කරන්න.

ඔබටත් කළ හැකිය

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

වස්තූන් පරීක්ෂා කිරීම සඳහා හොඳ ක්‍රමයක් වන්නේ Node සඳහා Chrome DevTools සමඟ node --inspect විකල්පය භාවිතා කිරීමයි .

node.exe --inspect www.js

chrome://inspect/#devicesක්‍රෝම් වලින් විවෘත කර ක්ලික් කරන්න node එකක් මතම ඊට අදාල සඳහා විවෘත කැප DevTools

දැන් ලොග් වී ඇති සෑම වස්තුවක්ම ක්‍රෝම් වල ධාවනය වන සාමාන්‍ය JS වැනි පරීක්ෂක තුළ ඇත.

පරීක්ෂක නැවත විවෘත කිරීමේ අවශ්‍යතාවයක් නොමැත, එය නෝඩ් ආරම්භ වූ වහාම හෝ නැවත ආරම්භ වූ වහාම ස්වයංක්‍රීයව නෝඩයට සම්බන්ධ වේ. Node සඳහා --inspect සහ Chrome DevTools යන දෙකම Node සහ Chrome හි පැරණි අනුවාද වල නොතිබිය හැකිය.

මෙම භාවිතයන් දෙකම යෙදිය හැකිය:

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

මම හිතන්නේ මෙය ඔබට ප්‍රයෝජනවත් වේවි.

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පණිවිඩවල ඇති වස්තුව නියෝජනය කිරීම අභිබවා යයි

උදා:

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 සහ node shell දෙකෙහිම අවශ්‍ය පරිදි නිරූපණය කෙරේ

ස්ක්‍රිප්ට් ධාවනය කිරීමේදී පරිසර විචල්‍යයක් ලෙස debugඑක් කිරීමට මොඩියුලය භාවිතා කිරීම සරල උපක්‍රමයක් වනු ඇතDEBUG_DEPTH=null

උදා.

DEBUG = * DEBUG_DEPTH = ශුන්‍ය නෝඩ් දර්ශකය. Js

ඔබ කේතයේ

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

වස්තූන් දර්ශනය වන ආකාරය අභිබවා යාම සඳහා REPL නෝඩයට බිල්ට් විසඳුමක් ඇත, මෙහි බලන්න .

util.inspect()අගයන් මුද්‍රණය කිරීමේදී REPL මොඩියුලය අභ්‍යන්තරව භාවිතා කරයි . කෙසේ වෙතත්, util.inspectඇමතුම වස්තුවක inspect() ශ්‍රිතයට ඇත්නම් එය පවරයි .

පහසුම විකල්පය:

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

JSON.stringify ()

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

දත්ත වස්තු ගැඹුරින් පරීක්ෂා කිරීම සඳහා විශිෂ්ටයි. මෙම ප්රවේශය අරා සහිත කැදැලි අරා සහ කැදැලි වස්තු මත ක්රියා කරයි.

ඔබගේ අරාවෙහි සැඟවුණු අයිතම පෙන්වීමට ඔබ ක්‍රමයක් සොයන්නේ නම්, ඔබට සමත් විය යුතුය maxArrayLength: Infinity

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