ES6

class SubArray extends Array {
    last() {
        return this[this.length - 1];
    }
}
var sub = new SubArray(1, 2, 3);
sub // [1, 2, 3]
sub instanceof SubArray; // true
sub instanceof Array; // true

New Approach: (Highly efficient and recommended)

Referencing the concepts from a article discussed in the accepted answer for further understanding

Using ES6 Inheritance

function SubArray() {
  let arr = [ ];
  arr.push.apply(arr, arguments);
  Object.setPrototypeOf(arr, SubArray.prototype);
  return arr;
}
SubArray.prototype = Object.create(Array.prototype);

You can now define custom methods for SubArray

SubArray.prototype.last = function() {
  return this[this.length - 1];
};

Initialization similar to standard Arrays

let sub = new SubArray(1, 2, 3);

Operates like regular Arrays

sub instanceof SubArray; // true
sub instanceof Array; // true

Attempting this type of task in the past has proven to be challenging, as it rarely yields successful results. However, one can potentially simulate the desired outcome by internally utilizing Array.prototype methods. This unique CustomArray class, which has only been tested in Chrome thus far, incorporates both the standard push method and a custom method called last. (Interestingly, I never thought of using this approach before xD)

function CustomArray() {
    this.push = function () {
        Array.prototype.push.apply(this, arguments);
    }
    this.last = function () {
        return this[this.length - 1];
    }
    this.push.apply(this, arguments); // implement "new CustomArray(1,2,3)"
}
a = new CustomArray(1,2,3);
alert(a.last()); // 3
a.push(4);
alert(a.last()); // 4

If you wish to incorporate any other Array methods into your customized implementation, they will need to be manually added. Using loops could be a clever workaround, considering that the logic within our custom push function is quite generic.

Check out this code snippet. It functions properly in all browsers that support the use of '__proto__'.

var getPrototypeOf = Object.getPrototypeOf || function(o){
    return o.__proto__;
};
var setPrototypeOf = Object.setPrototypeOf || function(o, p){
    o.__proto__ = p;
    return o;
};

var CustomArray = function CustomArray() {
    var array;
    var isNew = this instanceof CustomArray;
    var proto = isNew ? getPrototypeOf(this) : CustomArray.prototype;
    switch ( arguments.length ) {
        case 0: array = []; break;
        case 1: array = isNew ? new Array(arguments[0]) : Array(arguments[0]); break;
        case 2: array = [arguments[0], arguments[1]]; break;
        case 3: array = [arguments[0], arguments[1], arguments[2]]; break;
        default: array = new (Array.bind.apply(Array, [null].concat([].slice.call(arguments))));
    }
    return setPrototypeOf(array, proto);
};

CustomArray.prototype = Object.create(Array.prototype, { constructor: { value: CustomArray } });
CustomArray.prototype.append = function(var_args) {
    var_args = this.concat.apply([], arguments);        
    this.push.apply(this, var_args);

    return this;
};
CustomArray.prototype.prepend = function(var_args) {
    var_args = this.concat.apply([], arguments);
    this.unshift.apply(this, var_args);

    return this;
};
["concat", "reverse", "slice", "splice", "sort", "filter", "map"].forEach(function(name) {
    var _Array_func = this[name];
    CustomArray.prototype[name] = function() {
        var result = _Array_func.apply(this, arguments);
        return setPrototypeOf(result, getPrototypeOf(this));
    }
}, Array.prototype);

var array = new CustomArray(1, 2, 3);
console.log(array.length, array[2]);//3, 3
array.length = 2;
console.log(array.length, array[2]);//2, undefined
array[9] = 'qwe';
console.log(array.length, array[9]);//10, 'qwe'
console.log(array+"", array instanceof Array, array instanceof CustomArray);//'1,2,,,,,,,,qwe', true, true

array.append(4);
console.log(array.join(""), array.length);//'12qwe4', 11

Here is a comprehensive example that is compatible with ie9 and newer versions. For older versions like <=ie8, alternative implementations of Array.from, Array.isArray, etc., would be required. The following example demonstrates:

• Placing the Array subclass in its own closure (or Namespace) to prevent conflicts and namespace pollution.
• Inheriting all prototypes and properties from the native Array class.
• Showcasing how to define additional properties and prototype methods.

If you have access to ES6, it is recommended to use the class SubArray extends Array method as suggested by laggingreflex.

Below are the essentials for subclassing and inheriting from Arrays. Following this snippet is the complete example.

///Collections functions as a namespace.     
///_NativeArray to avoid naming conflicts. All references to Array within this closure refer to the Array function declared inside.     
var Collections = (function (_NativeArray) {
    //__proto__ is deprecated but Object.xxxPrototypeOf isn't as widely supported. '
    var setProtoOf = (Object.setPrototypeOf || function (ob, proto) { ob.__proto__ = proto; return ob; });
    var getProtoOf = (Object.getPrototypeOf || function (ob) { return ob.__proto__; });

    function Array() {          
        var arr = new (Function.prototype.bind.apply(_NativeArray, [null].concat([].slice.call(arguments))))();
        setProtoOf(arr, getProtoOf(this));     
        return arr;
    }

    Array.prototype = Object.create(_NativeArray.prototype, { constructor: { value: Array } });
    Array.from = _NativeArray.from; 
    Array.of = _NativeArray.of; 
    Array.isArray = _NativeArray.isArray;

    return { //Methods exposed externally
        Array: Array
    };
})(Array);

Complete example:

///Collections functions as a namespace.     
///_NativeArray to prevent naming conflicts. All references to Array in this closure point to the Array function declared inside.     
var Collections = (function (_NativeArray) {
    //__proto__ is deprecated but Object.xxxPrototypeOf isn't as widely supported.
    var setProtoOf = (Object.setPrototypeOf || function (ob, proto) { ob.__proto__ = proto; return ob; });
    var getProtoOf = (Object.getPrototypeOf || function (ob) { return ob.__proto__; });        

    function Array() {          
        var arr = new (Function.prototype.bind.apply(_NativeArray, [null].concat([].slice.call(arguments))))();           
        setProtoOf(arr, getProtoOf(this));
        return arr;
    }

    Array.prototype = Object.create(_NativeArray.prototype, { constructor: { value: Array } });
    Array.from = _NativeArray.from; 
    Array.of = _NativeArray.of; 
    Array.isArray = _NativeArray.isArray;

    //Add some convenient properties.
    Object.defineProperty(Array.prototype, "count", { get: function () { return this.length - 1; } });
    Object.defineProperty(Array.prototype, "last", { get: function () { return this[this.count]; }, set: function (value) { return this[this.count] = value; } });

    //Add some convenient Methods.    
    Array.prototype.insert = function (idx) {
        this.splice.apply(this, [idx, 0].concat(Array.prototype.slice.call(arguments, 1)));
        return this;
    };
    Array.prototype.insertArr = function (idx) {
        idx = Math.min(idx, this.length);
        arguments.length > 1 && this.splice.apply(this, [idx, 0].concat([].pop.call(arguments))) && this.insert.apply(this, arguments);
        return this;
    };
    Array.prototype.removeAt = function (idx) {
        var args = Array.from(arguments);
        for (var i = 0; i < args.length; i++) { this.splice(+args[i], 1); }
        return this;
    };
    Array.prototype.remove = function (items) {
        var args = Array.from(arguments);
        for (var i = 0; i < args.length; i++) {
            var idx = this.indexOf(args[i]);
            while (idx !== -1) {
                this.splice(idx, 1);
                idx = this.indexOf(args[i]);
            }
        }
        return this;
    };

    return { //Methods exposed externally
        Array: Array
    };
})(Array);

Below are some usage examples and tests.

var colarr = new Collections.Array("foo", "bar", "baz", "lorem", "ipsum", "lol", "cat");
var colfrom = Collections.Array.from(colarr.reverse().concat(["yo", "bro", "dog", "rofl", "heyyyy", "pepe"]));
var colmoded = Collections.Array.from(colfrom).insertArr(0, ["tryin", "it", "out"]).insert(0, "Just").insert(4, "seems", 2, "work.").remove('cat','baz','ipsum','lorem','bar','foo');

colmoded; //["Just", "tryin", "it", "out", "seems", 2, "work.", "lol", "yo", "bro", "dog", "rofl", "heyyyy", "pepe"]

colmoded instanceof Array; //true

Implementing a Custom Constructor with ES6

If you're looking to customize the constructor in an ES6 class, there are some considerations to keep in mind, especially when it comes to maintaining old methods.

By following the guidance provided at: How can I extend the Array class and retain its implementations we can achieve the following:

#!/usr/bin/env node

const assert = require('assert');

class MyArray extends Array {
  constructor(elements, number) {
    super(...elements);
    this.number = number;
  }

  static get [Symbol.species]() {
    return Object.assign(function (...items) {
      return new MyArray(new Array(...items))
    }, MyArray);
  }

  increment() { return this.number + 1; }
}

const customArray = new MyArray([2, 3, 5], 9);
assert(customArray[0] === 2);
assert(customArray[1] === 3);
assert(customArray[2] === 5);

assert(customArray.number === 9);

assert(customArray.increment() === 10);

assert(customArray.toString() === '2,3,5');

slicedArray = customArray.slice(1, 2);
assert(slicedArray[0] === 3);
assert(slicedArray.constructor === MyArray);

For a method to simulate index notation [] without using Array, refer to: Implementing Array-like behavior in JavaScript without relying on Array

This code was tested in Node.js v10.15.1.

Check out my new NPM module called inherit-array, designed to simplify this process. Here's a brief overview of what it does:

To create a subclass of an array:
function toArraySubClassFactory(ArraySubClass) {
  ArraySubClass.prototype = Object.assign(Object.create(Array.prototype),
                                          ArraySubClass.prototype);

  return function () {
    var arr = [ ];
    arr.__proto__ = ArraySubClass.prototype; 

    ArraySubClass.apply(arr, arguments);

    return arr;
  };
};

Once you have your own SubArray class ready, inherit from the Array using the following code snippet:

var SubArrayFactory = toArraySubClassFactory(SubArray);

var mySubArrayInstance = SubArrayFactory(/*whatever SubArray constructor takes*/)