posicion - pasar variable blade a javascript
¿Cómo convertir un "objeto" en una función en JavaScript? (8)
JavaScript permite que las funciones se traten como objetos; puede agregar una propiedad a una función. ¿Cómo se hace al revés y se agrega una función a un objeto?
Parece estar un poco confundido. Las funciones, en JavaScript, son objetos. Y las variables son variables No esperarías que esto funcione:
var three = 3;
three = 4;
assert(three === 3);
... entonces, ¿por qué esperar que la asignación de una función a su variable de alguna manera conservaría su valor anterior? Quizás algunas anotaciones le aclararán las cosas:
// assigns an anonymous function to the variable "foo"
var foo = function() { return 1; };
// assigns a string to the property "baz" on the object
// referenced by "foo" (which, in this case, happens to be a function)
foo.baz = "qqqq";
JavaScript permite que las funciones se traten como objetos: si primero define una variable como una función, puede agregar posteriormente propiedades a esa función. ¿Cómo se hace al revés y se agrega una función a un "objeto"?
Esto funciona:
var foo = function() { return 1; };
foo.baz = "qqqq";
En este punto, foo() llama a la función y foo.baz tiene el valor "qqqq".
Sin embargo, si primero hace la parte de asignación de propiedad, ¿cómo asigna posteriormente una función a la variable?
var bar = { baz: "qqqq" };
¿Qué puedo hacer ahora para organizar que bar.baz tenga el valor "qqqq" y bar() para llamar a la función?
Es fácil confundirse aquí, pero no puedes (fácil o claramente o, por lo que sé) hacer lo que quieras. Espero que esto ayude a aclarar las cosas.
En primer lugar, todos los objetos en Javascript heredan del objeto Object.
//these do the same thing
var foo = new Object();
var bar = {};
En segundo lugar, las funciones SON objetos en Javascript. Específicamente, son un objeto Function. El objeto Function hereda del objeto Object. Pagar el constructor de la función
var foo = new Function();
var bar = function(){};
function baz(){};
Una vez que declaras que una variable es un "Objeto", no puedes (fácil o claramente, o hasta donde yo sé) convertirla en un objeto Function. Debería declarar un nuevo objeto de tipo Función (con el constructor de función, asignando a una variable una función anónima, etc.) y copiar las propiedades de los métodos de su antiguo objeto.
Finalmente, anticipando una posible pregunta, incluso una vez que algo se declara como una función, no se puede (hasta donde yo sé) cambiar la función Cuerpo / fuente.
No parece haber una forma estándar de hacerlo, pero esto funciona.
¿POR QUÉ sin embargo, es la pregunta.
function functionize( obj , func )
{
out = func;
for( i in obj ){ out[i] = obj[i]; } ;
return out;
}
x = { a: 1, b: 2 };
x = functionize( x , function(){ return "hello world"; } );
x() ==> "hello world"
Simplemente no hay otra manera de lograr esto, haciendo
x={}
x()
VOLVERÁ un "error de tipo". porque "x" es un "objeto" y no puedes cambiarlo. es casi tan sensato como tratar de hacer
x = 1
x[50] = 5
print x[50]
no funcionará 1 es un número entero. los enteros no tienen métodos de matriz. no puedes hacerlo
Use una variable temporal:
var xxx = function()...
luego copie todas las propiedades del objeto original:
for (var p in bar) { xxx[p] = bar[p]; }
finalmente reasignar la nueva función con las propiedades antiguas a la variable original:
bar = xxx;
var bar = {
baz: "qqqq",
runFunc: function() {
return 1;
}
};
alert(bar.baz); // should produce qqqq
alert(bar.runFunc()); // should produce 1
Creo que estás buscando esto.
también se puede escribir así:
function Bar() {
this.baz = "qqqq";
this.runFunc = function() {
return 1;
}
}
nBar = new Bar();
alert(nBar.baz); // should produce qqqq
alert(nBar.runFunc()); // should produce 1
var A = function(foo) {
var B = function() {
return A.prototype.constructor.apply(B, arguments);
};
B.prototype = A.prototype;
return B;
};
NB: Publicación escrita en el estilo de cómo resolví el problema. No estoy 100% seguro de que sea utilizable en el caso del OP.
Encontré esta publicación mientras buscaba una forma de convertir objetos creados en el servidor y entregados al cliente por JSON / ajax.
Lo que efectivamente me dejó en la misma situación que el OP, un objeto que quería convertir en una función para poder crear instancias de él en el cliente.
Al final se me ocurrió esto, que funciona (al menos hasta ahora):
var parentObj = {}
parentObj.createFunc = function (model)
{
// allow it to be instantiated
parentObj[model._type] = function()
{
return (function (model)
{
// jQuery used to clone the model
var that = $.extend(true, null, model);
return that;
})(model);
}
}
Que luego puede usarse como:
var data = { _type: "Example", foo: "bar" };
parentObject.createFunc(data);
var instance = new parentObject.Example();
En mi caso, en realidad quería tener funciones asociadas a las instancias de objetos resultantes, y también poder pasar los parámetros en el momento de crear instancias.
Entonces mi código era:
var parentObj = {};
// base model contains client only stuff
parentObj.baseModel =
{
parameter1: null,
parameter2: null,
parameterN: null,
func1: function ()
{
return this.parameter2;
},
func2: function (inParams)
{
return this._variable2;
}
}
// create a troop type
parentObj.createModel = function (data)
{
var model = $.extend({}, parentObj.baseModel, data);
// allow it to be instantiated
parentObj[model._type] = function(parameter1, parameter2, parameterN)
{
return (function (model)
{
var that = $.extend(true, null, model);
that.parameter1 = parameter1;
that.parameter2 = parameter2;
that.parameterN = parameterN;
return that;
})(model);
}
}
Y fue llamado así:
// models received from an AJAX call
var models = [
{ _type="Foo", _variable1: "FooVal", _variable2: "FooVal" },
{ _type="Bar", _variable1: "BarVal", _variable2: "BarVal" },
{ _type="FooBar", _variable1: "FooBarVal", _variable2: "FooBarVal" }
];
for(var i = 0; i < models.length; i++)
{
parentObj.createFunc(models[i]);
}
Y luego pueden ser utilizados:
var test1 = new parentObj.Foo(1,2,3);
var test2 = new parentObj.Bar("a","b","c");
var test3 = new parentObj.FooBar("x","y","z");
// test1.parameter1 == 1
// test1._variable1 == "FooVal"
// test1.func1() == 2
// test2.parameter2 == "a"
// test2._variable2 == "BarVal"
// test2.func2() == "BarVal"
// etc
Los tipos de objetos son funciones y un objeto en sí es una creación de instancias de funciones.
javascript:alert([Array, Boolean, Date, Function,
Number, Object, RegExp, String].join(''/n/n''))
pantallas (en Firefox):
function Array() {
[native code]
}
function Boolean() {
[native code]
}
function Date() {
[native code]
}
function Function() {
[native code]
}
function Number() {
[native code]
}
function Object() {
[native code]
}
function RegExp() {
[native code]
}
function String() {
[native code]
}
En particular, tenga en cuenta que un objeto Function, function Function() { [native code] } , se define como una relación de recurrencia (una definición recursiva que se usa a sí misma).
Además, tenga en cuenta que la respuesta 124402 # 124402 es incompleta con respecto a 1[50]=5 . Esto SÍ asigna una propiedad a un objeto Number y ES un Javascript válido. Observar,
javascript:
alert([ [].prop="a", true.sna="fu", (new Date()).tar="fu",
function(){}.fu="bar", 123[40]=4, {}.forty=2,
/(?:)/.forty2="life", "abc".def="ghi" ].join("/t"))
muestra
a fu fu bar 4 2 life ghi
interpretar y ejecutar correctamente de acuerdo con las "Reglas de compromiso" de Javascript.
Por supuesto, siempre hay una arruga y se manifiesta por = . Un objeto a menudo se "cortocircuita" a su valor en lugar de una entidad de pleno derecho cuando se asigna a una variable. Este es un problema con los objetos booleanos y los valores booleanos.
La identificación explícita de objetos resuelve este problema.
javascript: x=new Number(1); x[50]=5; alert(x[50]);
La "sobrecarga" es un ejercicio bastante legítimo de Javascript y está respaldado explícitamente con mecanismos como la prototyping aunque la ofuscación del código puede ser un peligro.
Nota final:
javascript: alert( 123 . x = "not" );
javascript: alert( (123). x = "Yes!" ); /* ()''s elevate to full object status */