Как преобразовать «объект» в функцию в JavaScript?

Question

JavaScript позволяет обрабатывать функции как объекты - если вы сначала определите переменную как функцию, вы можете впоследствии добавить свойства к этой функции. Как сделать обратное и добавить функцию к «объекту»?

Это работает:

var foo = function() { return 1; };
foo.baz = "qqqq";

В этот момент foo() вызывает функцию, а foo.baz имеет значение "qqqq".

Однако, если вы сначала выполните часть назначения свойства, как впоследствии вы назначите функцию переменной?

var bar = { baz: "qqqq" };

Что я могу теперь сделать, чтобы bar.baz имел значение "qqqq" и bar() для вызова функции?

Answer 1

Здесь легко запутаться, но вы не можете (легко или четко или, насколько я знаю) делать то, что вы хотите. Надеюсь, это поможет прояснить ситуацию.

Во-первых, каждый объект в Javascript наследуется от объекта Object.

//these do the same thing
var foo = new Object();
var bar = {};

Во-вторых, функции ARE объекты в Javascript. В частности, это объект Function. Объект Function наследуется от объекта Object. Оформить заказ на конструктор функции

var foo = new Function();
var bar = function(){};
function baz(){};

Как только вы объявите переменную как «Объект», вы не сможете (легко, ясно или насколько я знаю) преобразовать ее в объект Function. Вам нужно объявить новый объект типа Function (с конструктором функции, назначить переменную анонимной функцией и т. Д.) И скопировать любые свойства методов из вашего старого объекта.

Наконец, предвидя возможный вопрос, даже если что-то объявлено как функция, вы не можете (насколько я знаю) изменить functionBody / source.

Answer 2

Кажется, нет стандартного способа сделать это, но это работает.

ПОЧЕМУ, однако, вопрос.

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" 

Нет другого способа добиться этого, делает

x={}
x() 

возвратит «ошибку типа». потому что «х» является «объектом», и вы не можете изменить его. это примерно так же разумно, как пытаться сделать

 x = 1
 x[50] = 5
 print x[50] 

это не сработает. 1 является целым числом целые числа не имеют методов массива. Вы не можете сделать это.

Answer 3

Типы объектов являются функциями, а сам объект является экземпляром функции.

  javascript:alert([Array, Boolean, Date, Function,
                       Number, Object, RegExp, String].join('\n\n'))

отображает (в 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]
}

В частности, обратите внимание, что объект Function, function Function() { [native code] }, определен как рекуррентное отношение (рекурсивное определение с использованием самого себя).

Также обратите внимание, что ответ 124402 # 124402 является неполным в отношении 1[50]=5. Это НЕ присваивает свойство объекту Number и является действительным Javascript. Обратите внимание,

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"))

показывает

a   fu  fu  bar 4   2   life    ghi

интерпретировать и выполнять правильно в соответствии с «Правилами участия» Javascript.

Конечно, всегда есть морщина и манифест =. Объект часто «замыкается» на свое значение, а не на полноценный объект при назначении переменной. Это проблема с логическими объектами и логическими значениями.

Явная идентификация объекта решает эту проблему.

javascript: x=new Number(1);  x[50]=5;  alert(x[50]);

«Перегрузка» является вполне законным Javascript-упражнением и явно поддерживается такими механизмами, как prototyping, хотя обфускация кода может быть опасной.

Конечная нота:

javascript: alert(  123 . x = "not"  );

javascript: alert( (123). x = "Yes!" );  /* ()'s elevate to full object status */

Answer 4

var A = function(foo) {                                                                                                      
  var B = function() {                                                                                                       
    return A.prototype.constructor.apply(B, arguments);
  };
  B.prototype = A.prototype;                                                                                                 
  return B;                                                                                                                  
}; 

Answer 5

Использовать временную переменную:

var xxx = function()...

затем скопируйте все свойства из исходного объекта:

for (var p in bar) { xxx[p] = bar[p]; }

наконец переназначить новую функцию со старыми свойствами исходной переменной:

bar = xxx;

Answer 6

NB: пост написан в стиле того, как я решил проблему. Я не уверен на 100%, что его можно использовать в случае ОП.

Я нашел этот пост, когда искал способ конвертировать объекты, созданные на сервере и доставленные клиенту с помощью JSON / ajax.

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

В конце концов я придумал это, которое работает (пока, по крайней мере):

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);
    }
}

Который затем можно использовать как:

var data = { _type: "Example", foo: "bar" };
parentObject.createFunc(data);
var instance = new parentObject.Example();

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

Итак, мой код был:

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);
    }
}

И был назван так:

// 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]);
}

И тогда их можно использовать:

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

Answer 7

var bar = { 
    baz: "qqqq",
    runFunc: function() {
        return 1;
    }
};

alert(bar.baz); // should produce qqqq
alert(bar.runFunc()); // should produce 1

Я думаю, вы ищете это.

также можно записать так:

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

Answer 8

JavaScript позволяет функциям быть рассматриваются как объекты - вы можете добавить свойство к функции. Как дела наоборот, и добавить функцию к объект

Вы, кажется, немного смущены. Функции, в JavaScript, являются объектами. И переменные являются переменными . Вы не ожидаете, что это сработает:

var three = 3;
three = 4;
assert(three === 3);

... так почему вы ожидаете, что назначение функции вашей переменной каким-то образом сохранит ее предыдущее значение? Возможно, некоторые аннотации прояснят для вас вещи:

// 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";