Related
I have this object:
const myObject = {
"a":"a",
"b":{
"c":"c",
"d":{
"e":"e",
"f":{
"g":"g",
"h":{
"i":"i"
}
}
}
}
};
But when I try to show it using console.log(myObject), I receive this output:
{ a: 'a', b: { c: 'c', d: { e: 'e', f: [Object] } } }
How can I get the full object, including the content of property f?
You need to use util.inspect():
const util = require('util')
console.log(util.inspect(myObject, {showHidden: false, depth: null, colors: true}))
// alternative shortcut
console.log(util.inspect(myObject, false, null, true /* enable colors */))
Outputs
{ a: 'a', b: { c: 'c', d: { e: 'e', f: { g: 'g', h: { i: 'i' } } } } }
You can use JSON.stringify, and get some nice indentation as well as perhaps easier to remember syntax.
console.log(JSON.stringify(myObject, null, 4));
{
"a": "a",
"b": {
"c": "c",
"d": {
"e": "e",
"f": {
"g": "g",
"h": {
"i": "i"
}
}
}
}
}
The third argument sets the indentation level, so you can adjust that as desired.
More detail here in JSON stringify MDN docs if needed.
A compilation of the many useful answers from (at least) Node.js v0.10.33 (stable) / v0.11.14 (unstable) presumably through (at least) v7.7.4 (the version current as of the latest update to this answer). Tip of the hat to Rory O'Kane for his help.
tl;dr
To get the desired output for the example in the question, use console.dir():
console.dir(myObject, { depth: null }); // `depth: null` ensures unlimited recursion
Why not util.inspect()? Because it’s already at the heart of diagnostic output: console.log() and console.dir() as well as the Node.js REPL use util.inspect() implicitly. It’s generally not necessary to require('util') and call util.inspect() directly.
Details below.
console.log() (and its alias, console.info()):
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.
You can’t turn syntax coloring on.
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 generated with %j is NOT pretty-printed.
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() automatically pretty-prints object and array representations, but produces multiline output only when needed.
The pretty-printing behavior can be controlled by the compact property in the optional options argument; false uses multi-line output unconditionally, whereas true disables pretty-printing altogether; it can also be set to a number (the default is 3) to control the conditional multi-line behavior – see the docs.
By default, output is wrapped at around 60 characters thanks, Shrey
, regardless of whether the output is sent to a file or a terminal. In practice, since line breaks only happen at property boundaries, you will often end up with shorter lines, but they can also be longer (e.g., with long property values).
In v6.3.0+ you can use the breakLength option to override the 60-character limit; if you set it to Infinity, everything is output on a single line.
If you want more control over pretty-printing, consider using JSON.stringify() with a 3rd argument, but note the following:
Fails with objects that have circular references, such as module in the global context.
Methods (functions) will by design NOT be included.
You can't opt into showing hidden (non-enumerable) properties.
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 object (2nd argument):
An optional options object may be passed that alters certain aspects of the formatted string; some of the properties supported are:
See the latest Node.js docs for the current, full list.
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() format-string placeholders (1st argument)
Some of the supported placeholders are:
See the latest Node.js docs for the current, full list.
%s – String.
%d – Number (both integer and float).
%j – JSON.
%% – single percent sign (‘%’). This does not consume an argument.
Another simple method is to convert it to json
console.log('connection : %j', myObject);
Since Node.js 6.4.0, this can be elegantly solved with util.inspect.defaultOptions:
require("util").inspect.defaultOptions.depth = null;
console.log(myObject);
Try this:
console.dir(myObject,{depth:null})
Both of these usages can be applied:
// 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));
perhaps console.dir is all you need.
http://nodejs.org/api/console.html#console_console_dir_obj
Uses util.inspect on obj and prints resulting string to stdout.
use util option if you need more control.
A good way to inspect objects is to use node --inspect option with Chrome DevTools for Node.
node.exe --inspect www.js
Open chrome://inspect/#devices in chrome and click Open dedicated DevTools for Node
Now every logged object is available in inspector like regular JS running in chrome.
There is no need to reopen inspector, it connects to node automatically as soon as node starts or restarts. Both --inspect and Chrome DevTools for Node may not be available in older versions of Node and Chrome.
You can also do
console.log(JSON.stringify(myObject, null, 3));
I think this could be useful for you.
const myObject = {
"a":"a",
"b":{
"c":"c",
"d":{
"e":"e",
"f":{
"g":"g",
"h":{
"i":"i"
}
}
}
}
};
console.log(JSON.stringify(myObject, null, '\t'));
As mentioned in this answer:
JSON.stringify's third parameter defines white-space insertion for
pretty-printing. It can be a string or a number (number of spaces).
JSON.stringify()
let myVar = {a: {b: {c: 1}}};
console.log(JSON.stringify( myVar, null, 4 ))
Great for deep inspection of data objects. This approach works on nested arrays and nested objects with arrays.
You can simply add an inspect() method to your object which will override the representation of object in console.log messages
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, ' ' ); }
then, your object will be represented as required in both console.log and node shell
Update:
object.inspect has been deprecated ( https://github.com/nodejs/node/issues/15549). Use myObject[util.inspect.custom] instead:
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))
Use a logger
Don't try to reinvent the wheel
util.inspect(), JSON.stringify() and console.dir() are useful tools for logging an object while playing in the browser console.
If you are serious about Node.js development, you should definitely use a logger. Using it you can add all the logs you want for debugging and monitoring your application. Then just change the logging level of your logger to keep only the production logs visible.
Additionaly they have already solved all the annoying issues related to logging, like: circular objects, formatting, log levels, multiple outputs and performance.
Use a modern logger
pino is a fast and modern logger for Node.js that has sane defaults to handle circular object/references like depthLimit and edgeLimit. It supports child loggers, transports and a pretty printed output.
Moreover, it has 8 default logging levels that you can customize using the customLevels option:
fatal
error
warn
info
debug
trace
silent
Install it
npm install pino
Use it
const logger = require('pino')()
logger.info('hello world')
Configure it
const logger = pino({
depthLimit: 10,
edgeLimit: 200,
customLevels: {
foo: 35
}
});
logger.foo('hi')
A simple trick would be use debug module to add DEBUG_DEPTH=null as environment variable when running the script
Ex.
DEBUG=* DEBUG_DEPTH=null node index.js
In you code
const debug = require('debug');
debug("%O", myObject);
If you're looking for a way to show the hidden items in you array, you got to pass maxArrayLength: Infinity
console.log(util.inspect(value, { maxArrayLength: Infinity }));
The node REPL has a built-in solution for overriding how objects are displayed, see here.
The REPL module internally uses util.inspect(), when printing values.
However, util.inspect delegates the call to the object's inspect()
function, if it has one.
Easiest option:
console.log('%O', myObject);
const myObject = {
"a":"a",
"b":{
"c":"c",
"d":{
"e":"e",
"f":{
"g":"g",
"h":{
"i":"i"
}
}
}
}
};
console.log(JSON.stringify(myObject));
Output:
{"a":"a","b":{"c":"c","d":{"e":"e","f":{"g":"g","h":{"i":"i"}}}}}
I need to get a attribute with the total number of pages that an API returns so I can control the loop to get all pages. It's small so I created a LookUp activity I must inside a JSON file but the Field names have special chars on it (":") so I have fields like "soapenv:Envelope". Code like this will not work:
#activity('LookupTest').output.value[0].value.soapenv:Envelope.soapenv:Header.hdr:paginacao.hdr:totalPaginas
It Bring me an error.
{"code":"BadRequest","message":null,"target":"pipeline//runid/28573e28-b5ef-41a6-9f8d-2655696193e1","details":null,"error":null}
How can I access it?
The output of LookUp Activity:
{
"count": 1,
"value": [
{
"soapenv:Envelope": {
"soapenv:Header": {
"mh:messageHeader": {
"mh:codigoPerfilAgente": 3801,
"mh:transactionId": "d6080aa1-80c2-4743-85e3-a6550a22adda"
},
"hdr:paginacao": {
"hdr:numero": 2,
"hdr:quantidadeItens": 30,
"hdr:totalPaginas": 2,
"hdr:quantidadeTotalItens": 48
}
},
"soapenv:Body": {
...
I managed to solve converting to string replacing the ":" to "_":
#string(json(replace(replace(string(activity('LookupTest').output.value[0]), 'soapenv:', 'soapenv_'), 'hdr:', 'hdr_')).soapenv_Envelope.soapenv_Header.hdr_paginacao.hdr_totalPaginas)
Does anyone have a more elegant solution?
I expect that there is no missing value when i serialize and parse, but protoc version 3.9.2 have a problem.
the protofile is show below:
syntax = "proto3";
package example;
message person {
int32 id = 1;
string name = 2;
}
message all_person {
repeated person Per = 1;
}
when i set id=0, name='hello' , i expect to show the "id": 0,
but after SerializeToString and parseToString, it returns
{
"Per": [
{
"name": "hello"
}
]
}
but if i set id=1,name='hello', it returns
{
"Per": [
{
"id": 1,
"name": "hello"
}
]
}
Zero is the default value for numerics (similarly, strings default to empty, booleans to false). See here for more details.
For efficiency, Protobuf relies on these default value. In our system (using FastRTPS and Protobuf for pub/sub), default values are not transmitted across the wire. Based on what you're seeing, it doesn't worry about them for serialisation either.
However, this is only the default behaviour and may be changeable. For example, if you're using MessageToJson, you can simply set an optional parameter including_default_value_fields to True, stating you want the defaults output as well:
jsonStr = MessageToJson(myMsg, True)
I'm currently working on fetching customer data from cdon, it's an e-commerce platform. They have their API documentation here:
CDON Api Docu
First let me show you my code:
myToken = '<token here>'
myUrl = 'https://admin.marketplace.cdon.com/api/reports/d8578ef8-723d-46cb-bb08-af8c9b5cca4c'
head = {'Authorization': 'token {}'.format(myToken),
'Status':'Online',
'format':'json'}
filters = '?filter={"Status":["Online"],"format": ["json"] }}'
response = requests.get(myUrl + filters, headers=head)
report = response.json()
print(report.products)
This is returning only the parameters. like for example at at this JSON: CDON Github
Status has a value Online this online is a group of itemsthat I only want to get.
What I'm trying to get is a response like this:
{
"Products": [
{
"SKU": "322352",
"Title": "Fabric Cover",
"GTIN": "532523626",
"ManufacturerArticleNumber": "",
"StatusCDON": "Online",
"ExposeStatusCDON": "Buyable",
"InStock": 0,
"InStockCDON": 0,
"CurrentPriceSE": null,
"OrdinaryPriceSE": null,
"CurrentPriceCDONSE": 299.0000,
"OrdinaryPriceCDONSE": null,
"CurrentPriceDK": null,
"OrdinaryPriceDK": null,
"CurrentPriceCDONDK": null,
"OrdinaryPriceCDONDK": null,
"CurrentPriceNO": null,
"OrdinaryPriceNO": null,
"CurrentPriceCDONNO": null,
"OrdinaryPriceCDONNO": null,
"CurrentPriceFI": null,
"OrdinaryPriceFI": null,
"CurrentPriceCDONFI": null,
"OrdinaryPriceCDONFI": null
},
Which means the full list of the items that are Online
How should I put this... among all the API's I tried this one is very confusing, is this even RestFul? If I can achieve the python equivalent of this C# sample code:
public string Post(Guid repordId, string path)
{
var filter = new JavaScriptSerializer().Serialize(new
{
States = new[] { "0" } // Pending state
});
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair("ReportId", repordId.ToString()),
new KeyValuePair("format", "json"),
new KeyValuePair("filter", filter)
});
var httpClient = new HttpClient() { BaseAddress = new Uri("https://admin.marketplace.cdon.com/") };
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("api", ApiKey);
var response = httpClient.PostAsync(path, content).Result;
response.EnsureSuccessStatusCode();
return response.Content.ReadAsStringAsync().Result;
}
I may be able to undestand how this API works, the response that I got was taken manually from their report function in JSON format.
Image
I made many attempts and at that code ( my code ) I stopped, being on this for 4 hours made me give up and ask. Trust that I have searched as many references as I could. It's really confusing.
How do I get the response that I want? Filtering via url? or via header? is this even restful? Help T_T
The documentation states in the first line, emphasis mine:
In order to generate a report you perform a POST call to the reports API with the parameters you wish to use for the report.
Your Python code does not make a POST request, you are trying a GET request. The documentation goes on
[...] to filter on Swedish orders you set the CountryCodes
attribute to “Sweden” and to get returned and cancelled orders you set
the States attribute to 2 and 3. So in the end the filter would look
like this:
{
"CountryCodes": [ "Sweden" ],
"States": ["2", "3"]
}
So you need to prepare a filter object (a dictionary in Python) with the filters you want. Luckily the Python syntax for dictionaries is equivalent (Python is flexible and also allows single-quoted strings):
filter = {
'CountryCodes': [ 'Sweden' ],
'States': [ '0' ]
}
The documentation goes on
You then post the parameters as form data (content-type:
application/x-www-form-urlencoded) so the request body would look like
this:
ReportId=d4ea173d-bfbc-48f5-b121-60f1a5d35a34&format=json&filter={"CountryCodes":["Sweden"],"States":["2","3"]}
application/x-www-form-urlencoded is the default for HTTP post, the requests module knows that and does this for you automatically. All you need to do is to prepare a data dict which will contain the data you want to post.
data = {
'ReportId': 'd4ea173d-bfbc-48f5-b121-60f1a5d35a34',
'format': 'json'
'filter': json.dumps(filter)
}
The filter parameter is supposed to be in JSON format. You must encode that yourself via json.dumps().
import json
head = { ... as above }
filter = { ... as above }
data = { ... as above }
response = requests.post(url, data, header=head)
I'll leave figuring out setting the Authorization header properly as an exercise for you. Partly because it isn't hard, partly because I have no intention of creating an API key with this website just for testing this and partly because it's entirely possible that your current header already works.
I have this object:
const myObject = {
"a":"a",
"b":{
"c":"c",
"d":{
"e":"e",
"f":{
"g":"g",
"h":{
"i":"i"
}
}
}
}
};
But when I try to show it using console.log(myObject), I receive this output:
{ a: 'a', b: { c: 'c', d: { e: 'e', f: [Object] } } }
How can I get the full object, including the content of property f?
You need to use util.inspect():
const util = require('util')
console.log(util.inspect(myObject, {showHidden: false, depth: null, colors: true}))
// alternative shortcut
console.log(util.inspect(myObject, false, null, true /* enable colors */))
Outputs
{ a: 'a', b: { c: 'c', d: { e: 'e', f: { g: 'g', h: { i: 'i' } } } } }
You can use JSON.stringify, and get some nice indentation as well as perhaps easier to remember syntax.
console.log(JSON.stringify(myObject, null, 4));
{
"a": "a",
"b": {
"c": "c",
"d": {
"e": "e",
"f": {
"g": "g",
"h": {
"i": "i"
}
}
}
}
}
The third argument sets the indentation level, so you can adjust that as desired.
More detail here in JSON stringify MDN docs if needed.
A compilation of the many useful answers from (at least) Node.js v0.10.33 (stable) / v0.11.14 (unstable) presumably through (at least) v7.7.4 (the version current as of the latest update to this answer). Tip of the hat to Rory O'Kane for his help.
tl;dr
To get the desired output for the example in the question, use console.dir():
console.dir(myObject, { depth: null }); // `depth: null` ensures unlimited recursion
Why not util.inspect()? Because it’s already at the heart of diagnostic output: console.log() and console.dir() as well as the Node.js REPL use util.inspect() implicitly. It’s generally not necessary to require('util') and call util.inspect() directly.
Details below.
console.log() (and its alias, console.info()):
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.
You can’t turn syntax coloring on.
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 generated with %j is NOT pretty-printed.
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() automatically pretty-prints object and array representations, but produces multiline output only when needed.
The pretty-printing behavior can be controlled by the compact property in the optional options argument; false uses multi-line output unconditionally, whereas true disables pretty-printing altogether; it can also be set to a number (the default is 3) to control the conditional multi-line behavior – see the docs.
By default, output is wrapped at around 60 characters thanks, Shrey
, regardless of whether the output is sent to a file or a terminal. In practice, since line breaks only happen at property boundaries, you will often end up with shorter lines, but they can also be longer (e.g., with long property values).
In v6.3.0+ you can use the breakLength option to override the 60-character limit; if you set it to Infinity, everything is output on a single line.
If you want more control over pretty-printing, consider using JSON.stringify() with a 3rd argument, but note the following:
Fails with objects that have circular references, such as module in the global context.
Methods (functions) will by design NOT be included.
You can't opt into showing hidden (non-enumerable) properties.
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 object (2nd argument):
An optional options object may be passed that alters certain aspects of the formatted string; some of the properties supported are:
See the latest Node.js docs for the current, full list.
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() format-string placeholders (1st argument)
Some of the supported placeholders are:
See the latest Node.js docs for the current, full list.
%s – String.
%d – Number (both integer and float).
%j – JSON.
%% – single percent sign (‘%’). This does not consume an argument.
Another simple method is to convert it to json
console.log('connection : %j', myObject);
Since Node.js 6.4.0, this can be elegantly solved with util.inspect.defaultOptions:
require("util").inspect.defaultOptions.depth = null;
console.log(myObject);
Try this:
console.dir(myObject,{depth:null})
Both of these usages can be applied:
// 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));
perhaps console.dir is all you need.
http://nodejs.org/api/console.html#console_console_dir_obj
Uses util.inspect on obj and prints resulting string to stdout.
use util option if you need more control.
A good way to inspect objects is to use node --inspect option with Chrome DevTools for Node.
node.exe --inspect www.js
Open chrome://inspect/#devices in chrome and click Open dedicated DevTools for Node
Now every logged object is available in inspector like regular JS running in chrome.
There is no need to reopen inspector, it connects to node automatically as soon as node starts or restarts. Both --inspect and Chrome DevTools for Node may not be available in older versions of Node and Chrome.
You can also do
console.log(JSON.stringify(myObject, null, 3));
I think this could be useful for you.
const myObject = {
"a":"a",
"b":{
"c":"c",
"d":{
"e":"e",
"f":{
"g":"g",
"h":{
"i":"i"
}
}
}
}
};
console.log(JSON.stringify(myObject, null, '\t'));
As mentioned in this answer:
JSON.stringify's third parameter defines white-space insertion for
pretty-printing. It can be a string or a number (number of spaces).
JSON.stringify()
let myVar = {a: {b: {c: 1}}};
console.log(JSON.stringify( myVar, null, 4 ))
Great for deep inspection of data objects. This approach works on nested arrays and nested objects with arrays.
You can simply add an inspect() method to your object which will override the representation of object in console.log messages
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, ' ' ); }
then, your object will be represented as required in both console.log and node shell
Update:
object.inspect has been deprecated ( https://github.com/nodejs/node/issues/15549). Use myObject[util.inspect.custom] instead:
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))
Use a logger
Don't try to reinvent the wheel
util.inspect(), JSON.stringify() and console.dir() are useful tools for logging an object while playing in the browser console.
If you are serious about Node.js development, you should definitely use a logger. Using it you can add all the logs you want for debugging and monitoring your application. Then just change the logging level of your logger to keep only the production logs visible.
Additionaly they have already solved all the annoying issues related to logging, like: circular objects, formatting, log levels, multiple outputs and performance.
Use a modern logger
pino is a fast and modern logger for Node.js that has sane defaults to handle circular object/references like depthLimit and edgeLimit. It supports child loggers, transports and a pretty printed output.
Moreover, it has 8 default logging levels that you can customize using the customLevels option:
fatal
error
warn
info
debug
trace
silent
Install it
npm install pino
Use it
const logger = require('pino')()
logger.info('hello world')
Configure it
const logger = pino({
depthLimit: 10,
edgeLimit: 200,
customLevels: {
foo: 35
}
});
logger.foo('hi')
A simple trick would be use debug module to add DEBUG_DEPTH=null as environment variable when running the script
Ex.
DEBUG=* DEBUG_DEPTH=null node index.js
In you code
const debug = require('debug');
debug("%O", myObject);
If you're looking for a way to show the hidden items in you array, you got to pass maxArrayLength: Infinity
console.log(util.inspect(value, { maxArrayLength: Infinity }));
The node REPL has a built-in solution for overriding how objects are displayed, see here.
The REPL module internally uses util.inspect(), when printing values.
However, util.inspect delegates the call to the object's inspect()
function, if it has one.
Easiest option:
console.log('%O', myObject);
const myObject = {
"a":"a",
"b":{
"c":"c",
"d":{
"e":"e",
"f":{
"g":"g",
"h":{
"i":"i"
}
}
}
}
};
console.log(JSON.stringify(myObject));
Output:
{"a":"a","b":{"c":"c","d":{"e":"e","f":{"g":"g","h":{"i":"i"}}}}}