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

Za pomocą __proto__

(stara odpowiedź, niezalecana, może powodować problemy z wydajnością)

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

Teraz możesz dodać swoje metody do SubArray

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

Inicjalizacja jak normalne Tablice

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

Zachowuje się jak normalne Tablice

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

W trzecim przykładzie tworzysz nową właściwość o nazwie prototype dla obiektu Array3. Kiedy wykonujesz new Array3, które powinno być new Array3(), tworzysz instancję tego obiektu do zmiennej list3. Dlatego metoda Add nie będzie działać, ponieważ this, który jest danym obiektem, nie ma poprawnej metody push. Mam nadzieję, że rozumiesz.

Edit: Sprawdź zrozumienie kontekstu JavaScript aby dowiedzieć się więcej o this.

Jakiś czas temu przeczytałem książkę Javascript Ninja napisaną przez Johna Resiga , twórcę jQuery . Zaproponował sposób naśladowania metod typu array za pomocą zwykłego obiektu JS. Zasadniczo wymagane jest tylko length.

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śli ten kod Cię interesuje, przeczytaj fragment Listing 4.10 Simulating array-like methods .

Czy próbujesz zrobić coś bardziej skomplikowanego, a następnie dodać alias dla " push "o nazwie "Add"?

Jeśli nie, prawdopodobnie najlepiej byłoby tego uniknąć. Powodem, dla którego sugeruję, że jest to zły pomysł, jest to, że ponieważ tablica jest wbudowanym typem javascript, jego modyfikacja spowoduje, że wszystkie typy tablicy skryptów będą miały nową metodę "Add". Potencjał kolizji nazw z inną stroną trzecią jest wysoki i może spowodować, że skrypt strony trzeciej straci swoją metodę na rzecz Twojej.

My ogólną zasadą jest, aby funkcja pomocnicza działała na tablicy, jeśli już gdzieś nie istnieje i rozszerza tablicę tylko wtedy, gdy jest bardzo potrzebna.

Nie można rozszerzyć obiektu Array w JavaScript.

Zamiast tego, możesz zdefiniować obiekt, który będzie zawierał listę funkcji, które wykonują się w tablicy, i wstrzyknąć te funkcje do tej instancji tablicy i zwrócić tę nową instancję tablicy. Nie powinieneś zmieniać Array.prototype, aby włączyć swoje niestandardowe funkcje na liście.

Przykład:

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",
}

Tylko przykładowy kod, możesz go modyfikować i używać jak chcesz. Ale podstawowa koncepcja I polecam do naśladowania pozostaje taka sama.

Możesz również użyć tego sposobu w ES6:

Object.assign(Array.prototype, {
    unique() {
      return this.filter((value, index, array) => {
        return array.indexOf(value) === index;
      });
    }
});

Wynik:

let x = [0,1,2,3,2,3];
let y = x.unique();
console.log(y); // => [0,1,2,3]

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

Odpowiedzią jest kompaktowe obejście, które działa zgodnie z przeznaczeniem we wszystkich obsługiwanych przeglądarkach.