Имена методов должны быть строчными. Прототип не должен изменяться в конструкторе.

function Array3() { };
Array3.prototype = new Array;
Array3.prototype.add = Array3.prototype.push

в кофескрипте

class Array3 extends Array
   add: (item)->
     @push(item) 

Если вам не нравится этот синтаксис, и вы ДОЛЖНЫ расширить его из конструктора, ваш единственный вариант:

// define this once somewhere
// you can also change this to accept multiple arguments 
function extend(x, y){
    for(var key in y) {
        if (y.hasOwnProperty(key)) {
            x[key] = y[key];
        }
    }
    return x;
}


function Array3() { 
   extend(this, Array.prototype);
   extend(this, {
      Add: function(item) {
        return this.push(item)
      }

   });
};

Вы также можете сделать это

ArrayExtenstions = {
   Add: function() {

   }
}
extend(ArrayExtenstions, Array.prototype);



function Array3() { }
Array3.prototype = ArrayExtenstions;

Раньше в prototype.js использовался метод Class.create. Вы можете обернуть все это таким методом

var Array3 = Class.create(Array, {
    construct: function() {

    },    
    Add: function() {

    }
});

Для получения дополнительной информации об этом и о том, как реализовать, посмотрите исходный код прототипа.js

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

Использование __proto__

(старый ответ, не рекомендуется, может вызвать проблемы с производительностью)

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

Теперь вы можете добавлять свои методы в SubArray

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

Инициализировать как обычные массивы

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

ведет себя как обычные массивы

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

Недавно я прочитал книгу Javascript Ninja, написанную Джоном Резигом, создателем jQuery. Он предложил способ имитировать методы, подобные массивам, с помощью простого объекта JS. По сути, требуется только 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'

Я не имею в виду, хорошо это или плохо. Это оригинальный способ выполнения Array операций. Преимущество в том, что вы не расширяете Array prototype. Имейте в виду, что obj — это просто object, а не Array. Поэтому obj instanceof Array вернет false. Воспринимайте obj как фасад.

Если вам интересен этот код, прочитайте отрывок Листинг 4.10. Моделирование методов, подобных массиву.

В третьем примере вы просто создаете новое свойство с именем prototype для объекта Array3. Когда вы делаете new Array3, который должен быть new Array3(), вы создаете экземпляр этого объекта в переменной list3. Следовательно, метод Add не будет работать, поскольку this, который является рассматриваемым объектом, не имеет допустимого метода push. Надеюсь, вы понимаете.

Изменить: ознакомьтесь с Понимание контекста JavaScript чтобы узнать больше о this.

Вы пытаетесь сделать что-то более сложное, чем просто добавить псевдоним для «push» под названием «Add»?

Если нет, то, вероятно, лучше этого не делать. Причина, по которой я полагаю, что это плохая идея, заключается в том, что, поскольку Array является встроенным типом javascript, его изменение приведет к тому, что все сценарии типа Array будут иметь ваш новый метод «Добавить». Потенциал конфликтов имен с другим третьим лицом высок и может привести к тому, что сторонний скрипт потеряет свой метод в пользу вашего.

Мое общее правило состоит в том, чтобы сделать вспомогательную функцию для работы с массивом, если она еще где-то не существует, и только расширять массив, если это крайне необходимо.

Вы НЕ МОЖЕТЕ расширить объект Array в JavaScript.

Вместо этого вы можете определить объект, который будет содержать список функций, выполняемых над массивом, и внедрить эти функции в этот экземпляр массива и вернуть этот новый экземпляр массива. Чего вам не следует делать, так это изменять Array.prototype, чтобы включить ваши пользовательские функции в список.

Пример:

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

Просто пример кода, вы можете изменить его и использовать по своему усмотрению. Но основная концепция, которой я рекомендую вам следовать, остается прежней.

Вы также можете использовать этот способ в ES6:

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

Результат:

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

Ответ — это компактный обходной путь, который работает, как задумано, во всех поддерживаемых браузерах.