Les moyens d'étendre la Matrice de l'objet en javascript

ES6

class SubArray extends Array {
    constructor(...args) { 
        super(...args); 
    }
    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

---

À l'aide de __proto__

(ancienne réponse, n'est pas recommandé, peut causer des les problèmes de performances)

function SubArray() {
  var arr = [ ];
  arr.push.apply(arr, arguments);
  arr.__proto__ = SubArray.prototype;
  return arr;
}
SubArray.prototype = new Array;

Maintenant, vous pouvez ajouter à vos méthodes de SubArray

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

Initialiser comme des Tableaux normaux

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

Se comporte comme des Tableaux normaux

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

Il y a un moment, j'ai lu le livre Javascript Ninja écrit par John Resig, le créateur de jQuery.
Il a proposé une façon d'imiter tableau des méthodes de type avec un simple JS objet. En gros, seulement length est nécessaire.

var obj = {
    length: 0, //only length is required to mimic an Array
    add: function(elem){
        Array.prototype.push.call(this, elem);
    },
    filter: function(callback) {
        return Array.prototype.filter.call(this, callback); //or provide your own implemetation
    }
};

obj.add('a');
obj.add('b');
console.log(obj.length); //2
console.log(obj[0], obj[1]); //'a', 'b'

Je ne veux pas dire qu'il est bon ou mauvais. C'est une façon originale de faire Array opérations. L'avantage est que vous n'étendez pas le Array prototype.
Gardez à l'esprit que obj est une plaine object, ce n'est pas une Array. Donc obj instanceof Array sera de retour false. Pensez obj comme un façade.

Si ce code est d'intérêt pour vous, lire l'extrait Listing 4.10 Simulant le tableau des méthodes de type.

Vous NE pouvez pas étendre l'Objet de Tableau en JavaScript.

Au lieu de cela, ce que vous pouvez faire est de définir un objet qui contiendra une liste de fonctions qui effectuent sur le Tableau, et d'injecter ces fonctions dans ce Tableau d'instance et le rendement de cette nouvelle instance de l'objet Array. Ce que vous ne devriez pas faire est de changer le Array.prototype pour inclure vos fonctions personnalisées sur la liste.

Exemple:

function MyArray() {
  var tmp_array = Object.create(Array.prototype);
  tmp_array = (Array.apply(tmp_array, arguments) || tmp_array);
  //Now extend tmp_array
  for( var meth in MyArray.prototype )
    if(MyArray.prototype.hasOwnProperty(meth))
      tmp_array[meth] = MyArray.prototype[meth];
  return (tmp_array);
}
//Now define the prototype chain.
MyArray.prototype = {
  customFunction: function() { return "blah blah"; },
  customMetaData: "Blah Blah",
}

Juste un exemple de code, vous pouvez le modifier et l'utiliser comme vous le souhaitez. Mais le concept sous-jacent je vous conseille de suivre reste la même.

var SubArray = function() {                                           
    var arrInst = new Array(...arguments); //spread arguments object
    /* Object.getPrototypeOf(arrInst) === Array.prototype */
    Object.setPrototypeOf(arrInst, SubArray.prototype);     //redirectionA
    return arrInst; //now instanceof SubArray
};

SubArray.prototype = {
    //SubArray.prototype.constructor = SubArray;
    constructor: SubArray,

    //methods avilable for all instances of SubArray
    add: function(element){return this.push(element);},
    ...
};

Object.setPrototypeOf(SubArray.prototype, Array.prototype); //redirectionB

var subArr = new SubArray(1, 2);
subArr.add(3); subArr[2]; //3

La réponse est un compact solution qui fonctionne comme prévu dans l'ensemble des justificatifs des navigateurs.