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

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

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

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

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

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

var bar = { baz: "qqqq" };

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

ОТВЕТЫ

Ответ 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.

Ответ 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" является "объектом", и вы не можете его изменить. его так же разумно, как пытаться сделать

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

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

Ответ 3

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

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. Обратите внимание,

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 "Правилами взаимодействия".

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

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

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

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

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

alert(  123 . x = "not"  );

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

Ответ 4

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

var xxx = function()...

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

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

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

bar = xxx;

Ответ 5

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

Ответ 6

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

Ответ 7

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

Я нашел этот пост, ища способ конвертировать объекты, созданные на сервере, и доставлял клиенту 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

Ответ 8

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