जावास्क्रिप्ट में किसी फ़ंक्शन में "ऑब्जेक्ट" को कैसे परिवर्तित करें?

Question

जावास्क्रिप्ट कार्यों को ऑब्जेक्ट्स के रूप में माना जाने की अनुमति देता है - यदि आप पहले एक चर के रूप में चर को परिभाषित करते हैं, तो आप बाद में उस फ़ंक्शन में गुण जोड़ सकते हैं। आप रिवर्स कैसे करते हैं, और एक "ऑब्जेक्ट" में फ़ंक्शन जोड़ते हैं?

यह काम करता है:

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

इस बिंदु पर, foo() फ़ंक्शन को कॉल करने, और foo.baz मूल्य "qqqq" है।

हालांकि, यदि आप संपत्ति असाइनमेंट भाग पहले करते हैं, तो आप बाद में चर के लिए फ़ंक्शन कैसे निर्दिष्ट करते हैं?

var bar = { baz: "qqqq" }; 

मैं अब क्या करना मान "qqqq" औरbar() फ़ंक्शन को कॉल करने के लिए bar.baz के लिए व्यवस्था करने के लिए कर सकते हैं?

Answer 1

यहां भ्रमित होना आसान है, लेकिन आप नहीं कर सकते (आसानी से या स्पष्ट रूप से या जहां तक ​​मैं पता है) जो आप चाहते हैं करो। उम्मीद है कि इससे चीजों को स्पष्ट करने में मदद मिलेगी।

सबसे पहले, जावास्क्रिप्ट में प्रत्येक ऑब्जेक्ट ऑब्जेक्ट ऑब्जेक्ट से प्राप्त होता है।

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

दूसरा, काम करता है जावास्क्रिप्ट में वस्तुओं रहे हैं। विशेष रूप से, वे एक फंक्शन ऑब्जेक्ट हैं। ऑब्जेक्ट ऑब्जेक्ट से फ़ंक्शन ऑब्जेक्ट प्राप्त होता है। Function constructor

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

चेकआउट एक बार जब आप एक चर घोषित एक "ऑब्जेक्ट" होने के लिए आप नहीं कर सकते हैं (आसानी से या स्पष्ट रूप से या के रूप में तक मुझे पता है) एक समारोह वस्तु को परिवर्तित। आपको एक नया ऑब्जेक्ट ऑफ फ़ंक्शन (फ़ंक्शन कन्स्ट्रक्टर के साथ, एक वेरिएबल फ़ंक्शन इत्यादि को असाइन करना) घोषित करना होगा, और अपनी पुरानी ऑब्जेक्ट से विधियों के किसी भी गुण पर प्रतिलिपि बनाना होगा।

अंत में, एक संभावित प्रश्न की उम्मीद करते हुए, एक बार फ़ंक्शन के रूप में कुछ घोषित होने के बाद भी, आप (जहां तक ​​मुझे पता है) फ़ंक्शन बॉडी/स्रोत को बदल नहीं सकते हैं।

Answer 2

जावास्क्रिप्ट कार्यों वस्तुओं के रूप में इलाज होने की अनुमति देता है - आप एक समारोह के लिए एक संपत्ति जोड़ सकते हैं। आप रिवर्स कैसे करते हैं, और ऑब्जेक्ट में फ़ंक्शन जोड़ते हैं?

आप थोड़ा उलझन में दिखाई देते हैं। जावास्क्रिप्ट में कार्य, ऑब्जेक्ट्स हैं। और चर परिवर्तनीय हैं। आप इस काम करने की उम्मीद नहीं होता:

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

Answer 3

ऐसा करने का एक मानक तरीका प्रतीत नहीं होता है, लेकिन यह काम करता है।

हालांकि, सवाल क्यों है।

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 4

एक अस्थायी चर का उपयोग करें:

:

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

अंत में मूल चर करने के लिए पुराने गुणों के साथ नए कार्य को पुन: असाइन:

var xxx = function()... 

तो मूल वस्तु से सभी गुण कॉपी

bar = xxx; 

Answer 5

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 6

वस्तु प्रकार कार्य हैं और एक वस्तु अपने आप में एक समारोह इन्स्टेन्शियशन है।

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

प्रदर्शित करता है (फ़ायर्फ़ॉक्स में):

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() { [native code] } ध्यान दें, (एक पुनरावर्ती परिभाषा ही उपयोग करते हुए) एक आवर्ती संबंध के रूप में परिभाषित किया गया है।

यह भी ध्यान दें कि answer 124402#1244021[50]=5 के बारे में अपूर्ण है। यह किसी ऑब्जेक्ट को किसी ऑब्जेक्ट को असाइन करता है और मान्य जावास्क्रिप्ट है। ध्यान से देखें,

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

"ओवरलोडिंग" काफी वैध जावास्क्रिप्ट व्यायाम है और स्पष्ट रूप से prototyping की तरह तंत्र के साथ समर्थन किया है, हालांकि कोड कहानियो को एक खतरा हो सकता है।

अंतिम नोट:

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

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

Answer 7

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

Answer 8

एनबी: पोस्ट कैसे मैं समस्या हल हो जाती की शैली में लिखा। मुझे 100% यकीन नहीं है कि यह ओपी के मामले में प्रयोग योग्य है।

मुझे सर्वर पर बनाए गए ऑब्जेक्ट्स को कन्वर्ट करने के लिए एक तरीका ढूंढने और JSON/AJAX द्वारा क्लाइंट को वितरित करने के दौरान यह पोस्ट मिला।

ओपी के रूप में उसी स्थिति में मुझे प्रभावी ढंग से छोड़ दिया गया, एक वस्तु जिसे मैं एक समारोह में परिवर्तित करना चाहता था ताकि ग्राहक पर इसके उदाहरण पैदा कर सकें।

अंत में मैं इस के साथ आया था, जो काम कर रहा है (अब तक कम से कम):

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