Package Exports

recursive-iterator

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (recursive-iterator) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Recursive Iterator

About

Iterates javascript object recursively. Works in ES5 and ES6 environments. Supports ES6 iteration protocols. Compatible with for...of cycle.

Required

ES5 Object.keys(), Array.prototype.indexOf()

Syntax

var iterator = new RecursiveIterator(
    root /*{Object|Array}*/,
    [bypassMode=0] /*{Number}*/,
    [ignoreCircular=false] /*{Boolean}*/,
    [maxDeep=100] /*{Number}*/
);

var item = iterator.next();
var state = item.value; // descriptor of state
var done = item.done; // true if end of the loop

var parent = state.parent; // parent object
var node = state.node; // current node
var key = state.key; // key of node
var path = state.path; // path to node
var deep = state.deep; // current deep

Tree traverse methods

By default method bypass of tree is vertical bypassMode=0:

var root = {
    object: {
        number: 1
    },
    string: 'foo'
};

var iterator = new RecursiveIterator(root);
for(var item = iterator.next(); !item.done; item = iterator.next()) {
    var state = item.value;
    console.log(state.path.join('.'), state.node);
}

// object    Object {number: 1}
// object.number    1
// string    foo

You can change it on horizontal by passing the bypassMode=1:

var root = {
    object: {
        number: 1
    },
    string: 'foo'
};

for(var item = iterator.next(); !item.done; item = iterator.next()) {
    var state = item.value;
    console.log(state.path.join('.'), state.node);
}

// object    Object {number: 1}
// string    foo
// object.number    1

Circular references

By default, if detected circular reference then will throw an exception:

var root = {
    number: 1,
    object: undefined,
    string: 'foo'
};
root.object = root;

var iterator = new RecursiveIterator(root);
for(var item = iterator.next(); !item.done; item = iterator.next()) {
    var state = item.value;
    console.log(state.path.join('.'), state.node);
}

// number    1
// Uncaught Error: Circular reference

You can change this behaviour by passing ignoreCircular=true:

var root = {
    number: 1,
    object: undefined,
    string: 'foo'
};
root.object = root;

var iterator = new RecursiveIterator(root, 0, true);
for(var item = iterator.next(); !item.done; item = iterator.next()) {
    var state = item.value;
    console.log(state.path.join('.'), state.node);
}

// number    1
// string    foo

Max deep

You can control the depth of dives of the iterator. By default maxDeepis 100. Minimum depth is 1. Each like cycle:

var root = {
    object: {
        number: 1
    },
    string: 'foo'
};

var iterator = new RecursiveIterator(root, 0, false, 1);
for(var item = iterator.next(); !item.done; item = iterator.next()) {
    var state = item.value;
    console.log(state.path.join('.'), state.node);
}

// object    Object {number: 1}
// string    foo

Methods

next()

Returns the state described of iteration protocol.

isLeaf(node)

Returns true if node is leaf. Leaf is all primitive types and objects whose keys.length === 0.

var iterator = new RecursiveIterator(root);
var item = iterator.next();

iterator.isLeaf(item.node);

isCircular(object)

Returns true if object is circular reference.

var iterator = new RecursiveIterator(root);
var item = iterator.next();

iterator.isCircular(item.node);

destroy()

Clears the cache and queue. It calls automatically at the end of the loop.

Callbacks

onStepInto(object)

It calls for each object. If returns false object will be skipped:

var root = {
    object: {
        number: 1
    },
    string: 'foo'
};

var iterator = new RecursiveIterator(root);
iterator.onStepInto = function(object) {
    // prevent step into object
    return false;
};

for(var item = iterator.next(); !item.done; item = iterator.next()) {
    var state = item.value;
    console.log(state.path.join('.'), state.node);
}

// object    Object {number: 1}
// string    foo

ES6 example: for...of loop

var root = {
    object: {
        number: 1
    },
    string: 'foo'
};

for(let item of new RecursiveIterator(root)) {
    console.log(item.path.join('.'), item.node);
}

// or

for(let {parent, node, key, path, deep} of new RecursiveIterator(root)) {
    console.log(path.join('.'), node);
}

// or

for(let {node, path} of new RecursiveIterator(root, 1)) {
    console.log(path.join('.'), node);
}