array-of-arrays-into-ast1.9.50

turns an array of arrays of data into a nested tree of plain objects

§ Quick Take

import { strict as assert } from "assert";
import generateAst from "array-of-arrays-into-ast";

assert.deepEqual(
  generateAst([[1, 2, 3], [1, 2], [5]]),
  {
    1: [
      {
        2: [
          {
            3: [null],
          },
          null,
        ],
      },
    ],
    5: [null],
  }
);

§ Purpose

It consumes array of arrays and produces a trie opens in a new tab-like AST from them. This library was a piece of a one experimental code generator of ours.

§ API

generateAst (input, [opts])

§ API - Input

Input argumentTypeObligatory?Description
inputArray of zero or more arraysyesSource of data to put into an AST
otpsPlain objectnoAn Optional Options Object. See its API below.

§ An Optional Options Object

Type: object - an Optional Options Object.

options object's keyTypeDefaultDescription
dedupeBooleantrueSkip duplicates

Here are all defaults in one place for copying:

{
dedupe: true,
}

When unused, Optional Options Object can also be passed as a null or undefined value.

§ API - Output

TypeDescription
Plain objectAST of the input

§ opts.dedupe

If you generate the AST with default settings, dedupe setting will be active and duplicate paths won't be created:

import generateAst from "array-of-arrays-into-ast";
const res = generateAst([[1], [1], [1]]);
console.log(
`${`\u001b[${33}m${`res`}\u001b[${39}m`} = ${JSON.stringify(res, null, 4)}`
);
// res = {
// 1: [null]
// }

Now, see what happens when you turn off opts.dedupe:

import generateAst from "array-of-arrays-into-ast";
const res = generateAst([[1], [1], [1]], { dedupe: false });
console.log(
`${`\u001b[${33}m${`res`}\u001b[${39}m`} = ${JSON.stringify(res, null, 4)}`
);
// res = {
// 1: [null, null, null]
// }
}

Notice how entries for each branch were created.

Generally, we don't see the reason why you'd want duplicates, but the setting is there if you ever need it. 👍🏻

§ Principles

Every object's key will have a value of array.

  • null inside that array means it's the tip of the branch.

  • An object inside that array means the branch continues.

Simples.

§ Compared vs. datastructures-js

There are libraries that produce and manage trie data structures, for example, datastructures-js opens in a new tab. In particular case, the problem is, the data structure is abstracted behind the let trie = ds.trie(); and you can't access it directly, traversing the nested tree of arrays and objects.

datastructures-js opens in a new tab trie would limit to search(), traverse() and count() methods. However, we need to recursively traverse every node and look up and down, what's around it.

Here's where this library comes in. It doesn't abstract the data it's producing - you get a nested plain object which you can traverse and further process any way you like, using a vast ocean of object- processing libraries.

§ Licence

MIT opens in a new tab

Copyright © 2010–2020 Roy Revelt and other contributors

Related packages:

📦 array-pull-all-with-glob 4.12.72
pullAllWithGlob - like _.pullAll but pulling stronger, with globs
📦 array-group-str-omit-num-char 2.1.48
Groups array of strings by omitting number characters
📦 array-of-arrays-sort-by-col 2.12.13
sort array of arrays by column, rippling the sorting outwards from that column
📦 array-includes-with-glob 2.12.42
like _.includes but with wildcards
📦 arrayiffy-if-string 3.11.38
Put non-empty strings into arrays, turn empty-ones into empty arrays. Bypass everything else.