String sequence in ES6

Question

Given an unique string that represents a sequence of characters, the class should implement three methods (getNextChar, getNextString and the genSequence generator).

How it works

1. We give a sequence of characters. For example: "abc"
2. We give a starting string. For example: "a"
3. The generator yields the following strings infinitely.

The next string of an existing string works like a dictionary, only the length doesn't change as long as there are still characters to fulfill.

a
b
c
aa
ab
ac
ba
..
cc
aaa
aab

This is not homework, but a user in Stack Overflow chat presented the challenge and I considered taking it to a higher level.

class SeqString {

    constructor (sequence) {

        this._sequence = sequence;
        this._first    = sequence[0];
        this._last     = sequence.slice(-1);

        return this;
    }

    getNextChar (char) {

        let seq   = this._sequence,
            index = (seq.indexOf(char) + 1) % seq.length;

        return seq[index];
    }

    getNextString (str) {

        let last = str.slice(-1),
            init = str.slice(0, str.length - 1),

            lastOfSeq  = this._last,
            firstOfSeq = this._first;

        // If it is overflowing
        if (last === lastOfSeq) {

            let trail = 1,
                i     = init.length;

            // Look for an index that won't overflow
            while (i-- && init[i] === lastOfSeq) ++trail;

            // If there is no such index, then the result is a new sequence
            // with an increased length
            if (i === -1) return firstOfSeq.repeat(trail + 1);

            // If there is, change the matching character at the index
            // and reset every character after that
            str = init.slice(0, i) + this.getNextChar(init[i]) +
                  firstOfSeq.repeat(trail);

            return str;

        }

        return init + this.getNextChar(last);
    }

    *genSequence (str) {

        let newStr = this.getNextString(str);

        yield newStr;
        yield* this.genSequence(newStr);    
    }

}

Specific questions

• How can I improve my class functions, while maintaining a balance between performance and readability?
• Tips on how I could make the code more readable for others.

Test cases

I have made a function test, to help debugging.

function test (sequence, startStr, times = 10) {

    let it = new SeqString(sequence).genSequence(startStr);

    while (times--)
        console.log(it.next().value);
}

Examples of output

Alphaset tests

const lowerAlpha = "abcdefghijklmnopqrstuvwxyz";
const alpha      = lowerAlpha + lowerAlpha.toUpperCase();

test(alpha, 'abc', 1); // abd 
test(alpha, 'BZZ', 1); // Caa
test(alpha, 'Z', 1); // aa 
test(alpha, 'ZZ', 1); // aaa

A long sequence for test(alpha, "Stack"): http://lpaste.net/137336

Other tests

test("pen", "p", 10);

e
n
pp
..
np

test("0123456789", "5", 10);

6
7
8
9
00
01
02
..

It should

• Use ES6 features
• Expose a generator
• Handle every kind of unique sequence
• Be readable

Answer 1

Well, to me it looks pretty good. I've made a few minor tweaks, mainly renaming variables, removing unneeded temp variables and renaming the class and methods, to make the code a little more self documenting.

There was one thing that struct me as odd. Your class only works with charSets which contain unique chars. "ppen" will output "p" ten times.

I would definitely add a pruning feature to remove any duplicates, that would make it a more robust class. Something like this first snippet below.

const CharStitcher = (function(){

    class CharStitcher {

        constructor (string) {
            string = CharStitcher.pruneChars(string);
            this._str = string;
            this._1st = string[0];
            this._last = string[ string.length -1 ];
            return this;
        }

        next (char) {
            return this._str[ ( this._str.indexOf(char) + 1 ) % this._str.length ];
        }

        genString (str) {

            let lastChar = str.slice(-1);
            let otherChars = str.slice(0, str.length - 1);

            if (lastChar === this._last) {
                let charAt = 1;
                let upTo = otherChars.length;
                while ( otherChars[upTo] === this._last && --upTo ) ++charAt;
                if ( upTo === -1 ) return this._1st.repeat( charAt + 1 );
                return otherChars.slice( 0, upTo ) + this.next( otherChars[upTo] ) + this._1st.repeat( charAt );
            }

            return otherChars + this.next(lastChar);
        }

        *stitch (str, newStr) {
            newStr = this.genString(str);
            yield newStr, yield* this.stitch(newStr);    
        }

    }

    CharStitcher.pruneChars = function (source, pruned){
      pruned = {}
      source.split('').forEach(function(char){
        if(!Object.prototype.hasOwnProperty.call(pruned, char)){
          pruned[char] = undefined;
        }
      })
      return Object.keys(pruned).join('');
    }

    return CharStitcher;

})();

Otherwise, I've removed all the comments, I feel it remains just as readable as your initial version.

class CharStitcher {

    constructor (string) {
        this._str = string;
        this._1st = string[0];
        this._last = string[ string.length -1 ];
        return this;
    }

    next (char) {
        return this._str[ ( this._str.indexOf(char) + 1 ) % this._str.length ];
    }

    genString (str) {

        let lastChar = str.slice(-1);
        let otherChars = str.slice(0, str.length - 1);

        if (lastChar === this._last) {
            let charAt = 1;
            let upTo = otherChars.length;
            while ( otherChars[upTo] === this._last && --upTo ) ++charAt;
            if ( upTo === -1 ) return this._1st.repeat( charAt + 1 );
            return otherChars.slice( 0, upTo ) + this.next( otherChars[upTo] ) + this._1st.repeat( charAt );
        }

        return otherChars + this.next(lastChar);
    }

    *stitch (str, newStr) {
        newStr = this.genString(str);
        yield newStr;
        yield* this.stitch(newStr);    
    }

}

I've also rewritten your test a little bit, also just minor tweaks.

function test (charSet, startStr, times = 10) {
    let progress = new CharStitcher(charSet).stitch(startStr);
    while ( times-- ) console.log(progress.next().value);
}

test("pen", "p", 10);

class CharStitcher {

    constructor (string) {
        this._str = string;
        this._1st = string[0];
        this._last = string[ string.length -1 ];
        return this;
    }

    next (char) {
        return this._str[ ( this._str.indexOf(char) + 1 ) % this._str.length ];
    }

    genString (str) {

        let lastChar = str.slice(-1);
        let otherChars = str.slice(0, str.length - 1);

        if (lastChar === this._last) {

            let charAt = 1;
            let upTo = otherChars.length;

            while ( otherChars[upTo] === this._last && upTo-- && ++charAt);

            if ( upTo === -1 ) return this._1st.repeat( charAt + 1 );
            
            return otherChars.slice( 0, upTo ) + this.next( otherChars[upTo] ) + this._1st.repeat( charAt );

        }

        return otherChars + this.next(lastChar);

    }

    *stitch (str, newStr) {

        newStr = this.genString(str);
        
        yield newStr;
        
        yield* this.stitch(newStr);    

    }

}


function test (charSet, startStr, times = 10) {
    let progress = new CharStitcher(charSet).stitch(startStr);
    while ( times-- ) console.log(progress.next().value);
}

test("pen", "p", 10);

Again, nothing major, hope my comments are helpful.

Answer 2

Why return this at the end of the constructor? I understand the point of doing it in other methods (e.g. to support chaining) but don't believe it is necessary to do so from a constructor.

---

It is advisable to use const for any value that doesn't need to be re-assigned - this avoid accidental re-assignment later. For example, in getNextChar(), seq and index are never re-assigned so they could be declared with const. And some people may argue that declaring those variables to only be used once or twice right before a return statement uses excess memory, which is perhaps why the suggested code in r10y's answer has them eliminated.