How to subtype Array so that Object.prototype.toString.call(subarray) returns a custom string and allow for custom methods.

Array.ByteArray.js

// create a fake Array subtype, eg ByteArray.
var oO = (function(){
    'use strict';

    var push = Array.prototype.push,
        id = '[object ByteArray]',
        uid = 0,
        storage = {},
        props = {
            // gets copied on our instances.
            __class__: id,
            position: function(pos){
                // example byte array pointer method
                if (typeof pos !== 'undefined'){
                    if (typeof this[pos] !== 'undefined')
                        storage[this._uid].position = pos;
                    else 
                        throw new Error('invalid position, no such index');
                    
                    return this;
                }
                else {
                    return storage[this._uid].position;
                }
            }
        },
        copy = function(){
            for (var k in props) {
                // add to object
                this[k] = props[k];
                
                try {
                    // hide iterables
                    Object.defineProperty(this, k, {
                        enumerable: false
                    });
                }catch(o_O){}
            }
            return this;
        };

    Object.prototype.toString.apply = function(that, args){
        return that.__class__ || Function.prototype.apply.call(this, that, []);
    };

    Object.prototype.toString.call = function(that){
          var args = [].slice.call(arguments, 1);
          return this.apply(that, args);
    };

    function ByteArray(/*arguments*/){
        var arr = [];
        arr._uid = uid++;
        storage[arr._uid] = {};

        try{
            Object.defineProperty(arr, '_uid', {
                writable: false,
                enumerable: false
            });
        }
        catch(o_O){};

        push.apply(copy.call(arr), arguments);
        
        // initial position
        arr.position(0);
        return arr;
    }

    ByteArray.toString = function(){ return 'ByteArray'; };

    return ByteArray;
}());

var A = new oO('1','2', 'three');

console.log(A.position());
A.position(1);
console.log(A.position());
console.log(typeof A);
console.log(Object.prototype.toString.call(A)); // [object ByteArray], ByteArray
console.log(A.toString()); // 1,2,three

console.log(A instanceof Array); // true


A.forEach(function(el){
    console.log(el); // 1, 2, 'three'
});

// caveats:
console.log('inheritance:', A instanceof oO); // false

// loop through props as object brings methods in on older browsers...
// shouldn't do this anyway.
for (var key in A){
    console.log(key + '=>' + A[key]);
}