object-treeify

What is object-treeify?

The object-treeify npm package is designed to convert JavaScript objects into tree-like string representations. This can be particularly useful for visualizing hierarchical data structures, debugging, or logging purposes. It allows developers to easily generate a textual representation of an object's structure, making it more readable and understandable.

What are object-treeify's main functionalities?

Basic tree generation

This feature allows you to generate a basic tree structure from a JavaScript object. The code sample demonstrates how to convert a nested object into a tree-like string representation, categorizing items under 'fruits' and 'vegetables'.

const treeify = require('object-treeify');

const data = {
  fruits: {
    apple: {},
    banana: {},
    cherry: {}
  },
  vegetables: {
    tomato: {},
    cucumber: {},
    carrot: {}
  }
};

console.log(treeify(data));

Customizing options

This feature demonstrates how to customize the appearance of the tree structure using various options. The code sample shows how to adjust the spacing, joining character, and the prefixes used for keys to alter how the tree is displayed.

const treeify = require('object-treeify');

const data = {
  animals: {
    mammals: {
      dog: {},
      cat: {}
    },
    birds: {
      parrot: {},
      sparrow: {}
    }
  }
};

const options = {
  join: '\n',
  spacerNoNeighbour: '  ',
  spacerNeighbour: '│ ',
  keyNoNeighbour: '└─ ',
  keyNeighbour: '├─ '
};

console.log(treeify(data, options));

Other packages similar to object-treeify

archy

Archy is a package that also allows for the visualization of hierarchical data as a tree structure in the console. Compared to object-treeify, archy focuses more on simplicity and ease of use but might not offer the same level of customization for the tree representation.

treeify

Treeify is another npm package that converts objects into tree structures. While it shares a similar purpose with object-treeify, its approach and customization options may differ, offering users an alternative way to visualize their object hierarchies.

README

object-treeify

Stringify Object as tree structure

{
    oranges: {
        'mandarin': {                                          ├─ apples,
            clementine: null,                                  │  ├─ gala
            tangerine: 'so cheap and juicy!'        -=>        │  └─ pink lady
        }                                                      └─ oranges
    },                                                           └─ mandarin
    apples: {                                                       ├─ clementine
        'gala': null,                                               └─ tangerine: so cheap and juicy!
        'pink lady': null
    }
}

Project was inspired by treeify and works almost identical. However the algorithm is much shorter and faster, works without recursion and is very memory efficient. Furthermore the output can be sorted using a custom comparator function.

Install

$ npm install --save object-treeify

Usage

const treeify = require('object-treeify');

treeify({
  oranges: {
    mandarin: {
      clementine: null,
      tangerine: 'so cheap and juicy!'
    }
  },
  apples: {
    gala: null,
    'pink lady': null
  }
}, {/* options */});

// =>
// ├─ apples
// │  ├─ gala
// │  └─ pink lady
// └─ oranges
//   └─ mandarin
//      ├─ clementine
//      └─ tangerine: so cheap and juicy!

Features

• Output is sorted alphabetically as one would expect
• Very fast and memory efficient implementation
• Input traversed exactly once
• Dependency free and small in size
• Tests to verify correctness

Options

joined

Type: boolean
Default: true

By default a single string is returned. Can be set to false to instead return an array containing lines.

spacerNoNeighbour

Type: string
Default:

Prefix for depth level when no further neighbour is present.

spacerNeighbour

Type: string
Default: │

Prefix for depth level when a further neighbour is present.

keyNoNeighbour

Type: string
Default: └─

Prefix for key when no further neighbour is present.

keyNeighbour

Type: string
Default: ├─

Prefix for key when a further neighbour is present.

sortFn

Type: function
Default: (a, b) => a.localeCompare(b)

Function that defines the key sort order.

Examples

More examples can be found in the tests.