I super metodi in JavaScript sono limitati all'ereditarietà funzionale, come nel libro di Crockford?

var coolcat = function(spec) {
    var that = cat(spec),
        super_get_name = that.superior('get_name');

    that.get_name = function (n) {
        return 'like ' + super_get_name() + ' baby';
    };

    return that;
};

var cat = coolcat({ ... });

Può anche essere fatto con i prototipi

var CoolCat = {
    constructor: function () {
        Cat.constructor.apply(this, arguments);
        return this;
    },
    getName: function () {
        return 'like ' + Cat.getName() + ' baby';
    }
};

var cat = Object.create(CoolCat).constructor({ ... });

Ovviamente la differenza principale qui è che non stai creando due nuove funzioni ogni volta che invochi coolcat . coolcat crea una nuova funzione per get_name e una nuova funzione per super_get_name e fondamentalmente spreca la memoria a sinistra ea destra.

Si potrebbe obiettare che coolcat ha privacy ma non perché qualcuno possa chiamare cat({}).superior('get_name'); e ottenere il tuo metodo "privato".

Ovviamente se si desidera la privacy e i prototipi che sono perfettamente possibili , utilizzando klass macro come mostrato nell'articolo

var Cat = klass(function (privates) {
    return {
        constructor: function (name) {
            privates(this).name = name; 
        },
        getName: function () {
            return privates(this).name;
        }
    };
});

var CoolCat = klass(Cat, function (privates, $super) {
    return {
        constructor: function () {
            $super.constructor.apply(this, arguments);
        },
        getName: function () {
            return 'like ' + $super.getName.call(this) + ' baby';
        }
    };  
});

var cat = new CoolCat("someName");
console.log(cat.getName());

Esempio dal vivo

Qui otteniamo sia l'ereditarietà della privacy che quella super class in modo "elegante".

In questo modo elegante non si ha il sovraccarico di chiusura di più funzioni per oggetto (aggiungiamo ancora una singola chiusura per oggetto per la funzione privates ) e anche il normale OO prototipo per solo funziona.

È una grande domanda su un grande libro. Il libro prende un paio di letture per essere completamente digerito. Mi sono imbattuto in questa domanda, mentre ricercavo alcune sottigliezze di javascript basate sul libro. Fondamentalmente ho avuto la stessa domanda, ma dopo aver riflettuto, penso che entrambe le risposte di kindohm e Raynos siano incomplete.

Penso che kindohm abbia ragione che il motivo sia legato alla privacy e all'accesso, ma non è perché il metodo super è privato dell'approccio funzionale, come giustamente fa notare Raynos.

D'altra parte la risposta di Raynos sembra quasi che ci sia un errore nel libro, dato che Raynos offre una soluzione diversa da quella che il libro dà.

Ma penso che la soluzione fornita nel libro abbia ancora il suo posto. Penso che il motivo / giustificazione principale sia nel paragrafo che precede il codice per il metodo "superiore":

The function will invoke the original method even if the property is changed

Questo è la differenza tra l'approccio funzionale e l'approccio pseudo-classico che viene fornito come esempio nella domanda originale.

Non è una privacy perfetta ma offre un ulteriore livello di isolamento.

La risposta è pubblica o privata. Con l'approccio funzionale, i super metodi possono essere mantenuti privati dell'oggetto. Il secondo esempio (utilizzando il prototipo) espone pubblicamente il metodo super.