utiliza - tablas en javascript ejemplos

¿Cómo heredo las funciones de JavaScript?

Question

// Don''t break the function prototype.
// pd - https://github.com/Raynos/pd
var proto = Object.create(Function.prototype, pd({
  "prop": 42
}));

var f = function() { return "is a function"; };
f.__proto__ = proto;

console.log(f.hasOwnProperty("prop")); // false
console.log(f.prop); // 42
console.log(f()); // "is a function"

.__proto__ no es estándar y está obsoleto.

¿Cómo se supone que heredé la creación prototípica de un objeto pero teniendo ese objeto como una función?

Object.create devuelve un objeto, no una función.

new Constructor devuelve un objeto, no una función.

Motivación: - Un finherit navegadores

var finherit = function (parent, child) {
    var f = function() { 
        parent.apply(this, arguments);
        child.apply(this, arguments);
    };
    f.__proto__ = parent;
    Object.keys(child).forEach(function _copy(key) {
        f[key] = child[key];
    });
    return f;
};

No creo que esto sea posible, por lo que probablemente deberíamos proponer una Function.create a la lista de correo es-discuss

/*
  Creates a new function whose prototype is proto.
  The function body is the same as the function fbody.
  The hash of propertydescriptors props is passed to defineproperties just like
  Object.create does.
*/
Function.create = (function() {
  var functionBody = function _getFunctionBody(f) {
    return f.toString().replace(/.+/{/, "").replace(//}$/, "");
  };
  var letters = "abcdefghijklmnopqrstuvwxyz".split("");

  return function _create(proto, fbody, props) {
    var parameters = letters.slice(0, fbody.length);
    parameters.push(functionBody(fbody));
    var f = Function.apply(this, parameters);
    f.__proto__ = proto;
    Object.defineProperties(f, props);
    return f;
  };
})();

Correo relacionado es-discuss

Como se menciona en el hilo es-discuss, existe un ES: strawman <| prototipo de operador que permitiría esto.

Veamos cómo se vería usando <|

var f1 = function () {
  console.log("do things");
};

f1.method = function() { return 42; };

var f2 = f1 <| function () {
  super();
  console.log("do more things");
}
console.log(f1.isPrototypeOf(f2)); // true
console.log(f2()); // do things do more things
console.log(f2.hasOwnProperty("method")); // false
console.log(f2.method()); // 42

Answer 1

Con ES6 es posible heredar de la Function , ver (duplicar) la pregunta

clase javascript hereda de la clase Function

default export Attribute extends Function {
...
}

Answer 2

Espero que entiendo esto bien.

Creo que quieres un functor que sea a la vez un ejemplo de un prototipo predefinido (sí, una clase, simplemente no una clase clásica), así como directamente ejecutable. ¿Derecha? Si es así, entonces tiene mucho sentido y es muy potente y flexible (especialmente en un entorno altamente asíncrono como JavaScript). Lamentablemente, no hay forma de hacerlo elegantemente en JavaScript sin manipular __proto__ . Puede hacerlo descompensando una función anónima y copiando todas las referencias a todos los métodos (que parece ser la dirección hacia la que se dirigía) para actuar como una clase proxy. Las desventajas de esto son ...

1. Es muy costoso en términos de tiempo de ejecución.
2. (functorObj instanceof MyClass) nunca será true .
3. Las propiedades no serán accesibles directamente (si todas fueron asignadas por referencia, esta sería una historia diferente, pero las primitivas se asignan por valor). Esto se puede resolver con defineProperty través de defineProperty o simplemente con el nombre de métodos de acceso si es necesario (parece que eso es lo que estás buscando, simplemente agrega todas las propiedades al functor con defineProperty través de getters / setters en lugar de solo funciones si no lo haces necesita compatibilidad con motor cruzado / compatibilidad hacia atrás).
4. Es probable que se encuentre con casos extremos en los que los prototipos nativos finales (como Object.prototype o Array.prototype [si lo está heredando]) pueden no funcionar como se esperaba.
5. Llamar a functorObj(someArg) siempre hará que this contexto sea el objeto, independientemente de si se llama functorObj.call(someOtherObj, someArg) (este no es el caso para las llamadas a métodos)
6. Debido a que el objeto del functor se crea en el momento de la solicitud, se bloqueará en el tiempo y la manipulación del prototipo inicial no afectará a los objetos del functor asignados como un objeto normal se vería afectado (la modificación de MyClass.prototype no afectará a ningún objeto del functor y el reverso cierto también).

Si lo usas suavemente, nada de esto debería ser un gran problema.

En tu prototipo de tu clase, define algo como ...

// This is you''re emulated "overloaded" call() operator.
MyClass.prototype.execute = function() {
   alert(''I have been called like a function but have (semi-)proper access to this!'');
};

MyClass.prototype.asFunctor = function(/* templateFunction */) {
   if ((typeof arguments[0] !== ''function'') && (typeof this.execute !== ''function''))
      throw new TypeError(''You really should define the calling operator for a functor shouldn/'t you?'');
   // This is both the resulting functor proxy object as well as the proxy call function
   var res = function() {
      var ret;
      if (res.templateFunction !== null)
         // the this context here could be res.asObject, or res, or whatever your goal is here
         ret = res.templateFunction.call(this, arguments);
      if (typeof res.asObject.execute === ''function'')
         ret = res.asObject.execute.apply(res.asObject, arguments);
      return ret;
   };
   res.asObject = this;
   res.templateFunction = (typeof arguments[0] === ''function'') ? arguments[0] : null;
   for (var k in this) {
      if (typeof this[k] === ''function'') {
         res[k] = (function(reference) {
            var m = function() {
               return m.proxyReference.apply((this === res) ? res.asObject : this, arguments);
            };
            m.proxyReference = reference;
            return m;
         })(this.asObject[k]);
      }
   }
   return res;
};

El uso resultante se vería como ...

var aobj = new MyClass();
var afunctor = aobj.asFunctor();
aobj.someMethodOfMine(); // << works
afunctor.someMethodOfMine(); // << works exactly like the previous call (including the this context).
afunctor(''hello''); // << works by calling aobj.execute(''hello'');

(aobj instanceof MyClass) // << true
(afunctor instanceof MyClass) // << false
(afunctor.asObject === aobj) // << true

// to bind with a previous function...
var afunctor = (new MyClass()).asFunctor(function() { alert(''I am the original call''); });
afunctor() // << first calls the original, then execute();
// To simply wrap a previous function, don''t define execute() in the prototype.

Incluso podría encadenar innumerables otros objetos / funciones / etc. hasta que las vacas llegaran a casa. Simplemente refactorice la llamada proxy un poco.

Espero que ayude. Ah, y por supuesto, podría cambiar el flujo de la fábrica para que un constructor llamado sin el new operador instancia un nuevo objeto y devuelva el objeto del functor. Como prefiera (seguramente también podría hacerlo de otras formas).

Finalmente, para que cualquier función se convierta en el operador de ejecución de un functor de una manera un poco más elegante, simplemente haz que la función proxy sea un método de Function.prototype y pásalo para que se ajuste si quieres hacer algo como (lo harías tiene que cambiar templateFunction con this y this con el argumento por supuesto) ...

var functor = (function() { /* something */ }).asFunctor(aobj);