Constructor para objeto invocable en JavaScript

Question

¿Cómo puedo crear un constructor para un objeto llamable en JavaScript?

He intentado varias formas, como seguir. El ejemplo es un ejemplo abreviado de objeto real.

function CallablePoint(x, y) { 
    function point() { 
     // Complex calculations at this point 
     return point 
    } 
    point.x = x 
    point.y = y 
    return point 
} 

Esto funciona en un primer momento, pero el objeto que crea no es instancia de CallablePoint, por lo que no copia las propiedades de CallablePoint.prototype y dice false en instanceof CallablePoint. ¿Es posible hacer un constructor que funcione para un objeto llamable?

Answer 1

Resulta que en realidad es posible. Cuando se crea la función, ya sea utilizando la sintaxis function o el constructor Function, obtiene la propiedad interna [[Call]]. No es una propiedad de la función en sí misma, sino propiedad que cualquier función obtiene cuando se construye.

Mientras que sólo significa que cualquier cosa con [[Call]] podría ser solamente Function cuando se construyó (bueno, hay una excepción – Function.prototype sí que no hereda de Function), eso no quiere decir que no puede convertirse en algo más tarde, preservando la propiedad [[Call]]. Bueno, siempre que su navegador no sea IE < 11.

Lo que permite cambiar la magia sería __proto__ de ES6, ya implementado en muchos navegadores. __proto__ es una propiedad mágica que contiene el prototipo actual. Al cambiarlo, puedo hacer que la función herede de algo que no es Function.

function CallablePoint(x, y) { 
    function point() { 
     // Complex calculations at this point 
     return point 
    } 
    point.__proto__ = CallablePoint.prototype 
    point.x = x 
    point.y = y 
    return point 
} 
// CallablePoint should inherit from Function, just so you could use 
// various function methods. This is not a requirement, but it's 
// useful. 
CallablePoint.prototype = Object.create(Function.prototype) 

En primer lugar, el constructor de CallablePoint hace un Function (sólo Function s se les permite comenzar con [[Call]] propiedad. A continuación, cambie su prototipo, por lo que heredarían CallablePoint. En este punto, tengo una función que doesn 't heredan de Function (especie de confuso).

Después he definido constructor para CallablePoint s, he de poner el prototipo de CallablePoint a Function, así que tengo CallablePoint que hereda de Function.

De esta forma, las instancias CallablePoint tienen una cadena de prototipo: CallablePoint -> Function -> Object, aunque siguen siendo invocables. Además, como el objeto es invocable, tiene según la especificación typeof igual a 'function'.

Answer 2

Si desea que el constructor CallablePoint() para devolver un objeto de tipo CallablePoint, a continuación, puede hacer algo como esto, donde el objeto CallablePoint contiene un punto como una propiedad del objeto, pero sigue siendo un objeto CallablePoint:

function CallablePoint(x, y) { 
    this.point = {}; 
    this.point.x = x 
    this.point.y = y 
} 

o, si lo que realmente está tratando de hacer es hacer una función que devuelve un objeto de CallablePoint, a continuación, puede crear una función de factor:

function CallablePoint(x, y) { 
    this.point = {}; 
    this.point.x = x 
    this.point.y = y 
} 

function makeCallablePoint(x, y) { 
    return new CallablePoint(x,y); 
} 

Answer 3

no estoy seguro de si estás consciente de que su objeto solo será una instancia de CallablePoint si usa la palabra clave new. Al denominarlo "invocable", me haces pensar que no desea querer para usar new. De todos modos, hay una manera de forzar una instancia para ser devuelto (gracias por la punta, Resig):

function CallablePoint(x, y) { 
    if (this instanceof CallablePoint) { 
     // Your "constructor" code goes here. 
     // And don't return from here. 
    } else { 
     return new CallablePoint(x, y); 
    } 
} 

Esto devolverá una instancia de CallablePoint independientemente de cómo se llamaba:

var obj1 = CallablePoint(1,2); 
console.log(obj1 instanceof CallablePoint); // true 

var obj2 = new CallablePoint(1,2); 
console.log(obj2 instanceof CallablePoint); // true 

Answer 4

Escribiré mi respuesta asumiendo que estaba después de la funcionalidad __call__ disponible en Python y a menudo denominado "objeto invocable". El "objeto invocable" suena extraño en el contexto de JavaScript.

He intentado varios motores de JavaScript, pero ninguno de los que he probado le permite llamar a objetos, incluso si hereda de Function. Por ejemplo:

function Callable(x) { 
...  "use strict"; 
...  this.__proto__ = Function.prototype; 
...  this.toString = function() { return x; }; 
... } 
undefined 
> var c = new Callable(42); 
var c = new Callable(42); 
undefined 
> c; 
c; 
{ toString: [function] } 
> c(42); 
c(42); 
TypeError: Property 'c' of object #<Object> is not a function 
    at repl:1:1 
    at REPLServer.eval (repl.js:80:21) 
    at repl.js:190:20 
    at REPLServer.eval (repl.js:87:5) 
    at Interface.<anonymous> (repl.js:182:12) 
    at Interface.emit (events.js:67:17) 
    at Interface._onLine (readline.js:162:10) 
    at Interface._line (readline.js:426:8) 
    at Interface._ttyWrite (readline.js:603:14) 
    at ReadStream.<anonymous> (readline.js:82:12) 
> c instanceof Function; 
c instanceof Function; 
true 
c.apply(null, [43]); 
TypeError: Function.prototype.apply was called on 43, which is a object and not a function 
    at Function.APPLY_PREPARE (native) 
    at repl:1:3 
    at REPLServer.eval (repl.js:80:21) 
    at repl.js:190:20 
    at REPLServer.eval (repl.js:87:5) 
    at Interface.<anonymous> (repl.js:182:12) 
    at Interface.emit (events.js:67:17) 
    at Interface._onLine (readline.js:162:10) 
    at Interface._line (readline.js:426:8) 
    at Interface._ttyWrite (readline.js:603:14) 
> 

Esto es V8 (Node.js). Es decir. puede tener un objeto, que hereda formalmente de la función, pero no se puede llamar, y no pude encontrar una manera de convencer al tiempo de ejecución de que se llame. Obtuve resultados similares en la implementación de JavaScrip de Mozilla, así que creo que debe ser universal.

Sin embargo, el rol de los tipos personalizados en JavaScript es muy pequeño, así que no creo que de todos modos te lo pierda. Pero, como ya había descubierto, puede crear propiedades en las funciones, de la misma manera que puede hacerlo en los objetos. Entonces, puedes hacerlo, solo de una manera menos conveniente.