Método Node.js util.inspect()

El módulo «util» proporciona funciones de «utilidad» que se utilizan con fines de depuración. Para acceder a esas funciones, debemos llamarlas con ‘require(‘util’)’.

El método util.inspect() (agregado en v0.3.0) es una interfaz de programación de aplicaciones incorporada del módulo util que está destinada a la depuración y devuelve una representación de string del objeto. El método util.inspect() no depende de la programación. Devuelve una salida que puede cambiar en cualquier momento para alterar el resultado. Se pueden pasar opciones complementarias (como showHidden, profundidad). Para el valor inspeccionado, utiliza el nombre del constructor o @@toStringTag para crear una etiqueta identificable.

Sintaxis:

const util = require('util');
util.inspect(object[, options])

Parámetros: esta función acepta dos parámetros, como se mencionó anteriormente y se describe a continuación:

• objeto <cualquiera> : cualquier clase, función, objeto o primitivo de JavaScript.

• options <Object> : Las opciones son del tipo ‘objeto’ que acepta la forma JSON de los datos.

  • showHidden <booleano> : de forma predeterminada, el valor del objeto se establece en ‘False’; si se establece en ‘true’, comienza a mostrar símbolos y propiedades ocultos no enumerables junto con entradas definidas por el usuario, WeakMap y WeakSet en el resultado formateado.
  • profundidad <número> : por defecto, el valor del objeto se establece en ‘2’. Especifica cuántas veces recursar y mientras se inspeccionan objetos grandes y el tamaño de la pila de llamadas se pasa a Infinito o nulo para repetir hasta el máximo.
  • colors <booleano> : De forma predeterminada, el valor del objeto se establece en ‘Falso’; si se establece en ‘verdadero’, la salida obtiene un estilo coloreado con códigos de color ANSI.
  • customInspect <booleano> : de forma predeterminada, el valor del objeto se establece en ‘verdadero’; si se establece en ‘falso’, las funciones [[util.inspect.custom](profundidad, opciones)] no se invocan.
  • showProxy <booleano> : de forma predeterminada, el valor del objeto se establece en ‘False’; si se establece en ‘true’, la inspección del proxy incluye los objetos de destino y controlador.
  • maxArrayLength <integer> : de forma predeterminada, el valor del objeto se establece en ‘100’. Si bien se especifica la longitud máxima del formateo, es decir, cuántos Arrays, WeakMaps y WeakSets se necesitan para incluir en el resultado formateado. Para mostrar (0) ningún elemento, establezca el valor en 0 o negativo y para mostrar todos los elementos, establezca el valor en Infinito o nulo.
  • maxStringLength <integer> :  de forma predeterminada, el valor del objeto se establece en ‘Infinito’. Mientras se formatea, se especifica la longitud máxima de caracteres, es decir, la longitud de caracteres que se incluirán en el resultado formateado. Para mostrar (”) sin caracteres, establezca el valor en 0 o negativo y para mostrar todos los elementos, establezca el valor en Infinito o nulo.
  • breakLength <integer> : De forma predeterminada, el valor del objeto se establece en ’80’. Al formatear, especifica la longitud máxima a la que los valores de entrada se dividen en varias líneas. Para formatear la entrada en una sola línea, configúrelo en Infinito.
  • ordenado <booleano> | <Función> : De forma predeterminada, el valor del objeto se establece en ‘falso’, si se establece en ‘verdadero’ o se pasa una función, todas las propiedades se ordenan en la string formateada. La ordenación predeterminada se usa si se establece en ‘verdadero’ y se usa como una función de comparación si se establece en una función.
  • captadores <booleano> | <string> : De forma predeterminada, el valor del objeto se establece en ‘falso’; si se establece en ‘verdadero’, se inspeccionarán los captadores. Si se establece en ‘obtener’, solo se inspeccionarán los captadores. Si se establece en ‘set’, solo se inspeccionarán los getters con un setter correspondiente. Este riesgo de efectos secundarios es alto dependiendo de la función getter.

Valor devuelto: <string> : Devuelve la string formateada que representa el objeto.

Ejemplo 1: Nombre de archivo: index.js

// Node.js syntax to demonstrate
// the util.inspect() method 
  
// Importing util library
const util = require('util');
  
// Object
const nestedObject = {};
nestedObject.a = [nestedObject];
nestedObject.b = [['a', ['b']], 'b', 'c', 'd'];
nestedObject.b = {};
nestedObject.b.inner = nestedObject.b;
nestedObject.b.obj = nestedObject;
  
// Inspect by basic method
console.log("1.>", util.inspect(nestedObject));
  
// Random class 
class geeksForGeeks { }
  
// Inspecting geeksForGeeks class 
console.log("2.>", util.inspect(new geeksForGeeks()));
  
// Inspect by passing options to method
console.log("3.>", util.inspect(
        nestedObject, true, 0, false));
  
// Inspect by calling option name
console.log("4.>", util.inspect(nestedObject,
    showHidden = false, depth = 0, colorize = true));
  
// Inspect by passing in JSON format 
console.log("5.>", util.inspect(nestedObject,
    { showHidden: false, depth: 0, colorize: true }));
  
// Inspect by directly calling inspect from 'util'
const { inspect } = require('util');
  
// Directly calling inspect method
// with single property
console.log("6.>", inspect(nestedObject),
        { colorize: true });
  
// Directly passing the JSON data
console.log("7.>", util.inspect([
    { name: "Amit", city: "Ayodhya" },
    { name: "Satyam", city: "Lucknow" },
    { name: "Sahai", city: "Lucknow" }],
    false, 3, true));
  
// Directly calling inspect method with single property
console.log("8.>", inspect(nestedObject), { depth: 0 });

Ejecute el archivo index.js con el siguiente comando:

node index.js

Producción:

1.> <ref *1> {
  a: [ [Circular *1] ],
  b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
}
2.> geeksForGeeks {}
3.> { a: [Array], b: [Object] }
4.> { a: [Array], b: [Object] }
5.> { a: [Array], b: [Object] }
6.> <ref *1> {
  a: [ [Circular *1] ],
  b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
} { colorize: true }
7.> [
  { name: 'Amit', city: 'Ayodhya' },
  { name: 'Satyam', city: 'Lucknow' },
  { name: 'Sahai', city: 'Lucknow' }
]
8.> <ref *1> {
  a: [ [Circular *1] ],
  b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
} { depth: 0 }

Ejemplo 2: Nombre de archivo: index.js

// Node.js syntax to demonstrate the 
// util.inspect() method 
  
// Import the util module 
const util = require('util');
const { inspect } = require('util');
  
// Importing http module
var http = require('http');
  
// Inspecting http module
console.log("1.>", util.inspect(http, {
    showHidden: false,
    depth: 0, showProxy: false
}));
  
// Inspecting console module
console.log("2.>", util.inspect(
    console, showHidden = false,
    depth = 0, showProxy = true));
  
// Creating array filled with default value 1
const inspectArray = Array(108).fill(1);
  
// Prints the truncated array
console.log("3.>", inspectArray);
util.inspect.defaultOptions.maxArrayLength = null;
  
// Prints the full array
console.log("4.>", inspectArray);
  
const object = {
    amit: [1, 2, [[
        'alfa_romeo, spp___, sahai_harshit ' +
        'Annapurna, chai paratha.',
        'chota',
        'bong']], 55],
    vikas: new Map([
        ['alfa', 1], ['romeo', 'data']])
};
  
// Returns the compact view output.
console.log("5.>", util.inspect(object, {
    compact: true, depth: 5,
    breakLength: 80
}));
  
// Returns the output more reader friendly.
console.log("6.>", util.inspect(object, {
    compact: false, depth: 5,
    breakLength: 80
}));
  
const object1 = { alfa: 10 };
const object2 = { beta: 20 };
  
// Creating weakSet
const inspectingWeakset = 
    new WeakSet([object1, object2]);
  
console.log("7.>", inspect(
    inspectingWeakset, { showHidden: true }));
// Output { { alfa: 10 }, { beta: 20 } }
  
object2[util.inspect.custom] = (depth) => {
    return { alfaa: 'romeo' };
};
  
console.log("8.>", util.inspect(object2));
// Prints: "{ alfaa: 'romeo' }"

Ejecute el archivo index.js con el siguiente comando:

node index.js

Producción:

1.> { _connectionListener: [Función: connectionListener], …. globalAgent: [Getter/Setter]}
2.> { log: [Función: llamada a consola enlazada], …..[Símbolo(kFormatForStderr)]: [Función: enlazada]}
3.> [ 1, 1, 1, 1, 1 , 1, ………1, 1, 1, 1, 1, … 8 elementos más]
4.> [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, … .1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
5.> { amit: [ 1, 2, [ [ ‘alfa_romeo, spp___, sahai_harshit Annapurna, chai paratha.’ ,
‘chota’, ‘bong’ ] ], 55 ], vikas: Map(2) { ‘alfa’ => 1, ‘romeo’ => ‘data’ } }
6.> devuelve el resultado más fácil de leer.
7.> Conjunto débil { { alfa: 10 }, { beta: 20 } }
8.> { alfaa: ‘romeo’ }

El método util.format(format[, …])   también da el mismo resultado junto con una string formateada usando el primer argumento como un formato similar a printf.

Referencia: https://nodejs.org/api/util.html#util_util_inspect_object_options