How to inherit and chain String without polluting String.prototype?

Question

What I want to be able to do is something like this:

var where = new Where();
where('a'); // returns a string 'WHERE a' that I can chain against

where('a').andWhere('b'); // reuturns 'WHERE a AND b' that is also chainable

where('a').andWhere('b').orWhere('c'); // 'WHERE a AND b OR c', and so on ...

The where methods should return what is for all intents and purposes a string, with all string like methods, but with the two custom andWhere and orWhere methods.

When I tried inheriting from Sting.prototype, my where methods returned an object, not a string. Of course, if I returned a string directly from the methods, they didn't have the andWhere and orWhere methods, so chaining broke.

The code below does what I want, but it does it by polluting the String.prototype. Is there a way to get the same behavior, but encapsulated in a custom object?

Object.defineProperty(String.prototype, "andWhere", {
  value: function _andWhere(clause) {
    return [this, 'AND', clause].join(' ');
  },
  configurable: true,
  enumerable: false,
  writeable: true
});

Object.defineProperty(String.prototype, "orWhere", {
  value: function _orWhere(clause) {
    return [this, 'OR', clause].join(' ');
  },
  configurable: true,
  enumerable: false,
  writeable: true
});


function where(clause){
  return ['WHERE', clause].join(' ');
}

where('a').andWhere('b').orWhere('c');
// => 'WHERE a AND b OR c'

Edit

I still want to have access to all the string methods off the object directly. In other words the returned object acts just like a string, but with a couple more methods. For example:

var whereStr = where('a').andWhere('b').orWhere('c');
whereStr.length; // => 18
whereStr.concat(' and so on'); // => 'WHERE a AND b OR c and so on'

If it makes any difference, this is primarily for Node, but ideally would work for any recent (ES5) javascript implementation. Again, this works perfectly if I'm bad and use String.prototype, I'm hoping there's a way to do a drop in replacement.

Answer 1

UPDATED Added in an example of creating the length property as a "getter".

function Where(conditional) {
    var thisObj = this;

    //Setup the length property's "getter"
    this.__defineGetter__( "length", function() {
        return thisObj.clause.length;
    });

    this.start( conditional );
}

Where.prototype = {
    AND_STR: " AND ",
    OR_STR: " OR ",
    add: function(conditional, prefix) {
        this.clause += prefix + conditional;
    },
    and: function(conditional) {
        this.add( conditional, this.AND_STR ); 
        return this;
    },
    or: function(conditional) { 
        this.add( conditional, this.OR_STR ); 
        return this;
    },
    start: function(conditional) {
        this.clause = "WHERE " + conditional;
    },
    toString: function() {
        return this.clause;
    }
}

//Use it like this (this shows the length of the where statement):
alert( new Where( "a" ).and( "b" ).or( "c" ).length );