दिलचस्प पोस्ट
ViewModel फॉर्म को कैसे बंद करना चाहिए? यूनिकोडएनकोड त्रुटि: 'charmap' कोडेक सांकेतिक शब्दों में बदलना नहीं कर सकते हैं – वर्णों को <undefined> के लिए प्रिंट, प्रिंट फ़ंक्शन ऑटो इंप्रेशन आईडी हाइबरनेट करें स्टैक वैरिएबल जीसीसी __डेटाइट __ (गठबंधन (एक्स)) द्वारा गठबंधन कर रहे हैं? क्यों जावास्क्रिप्ट में बहसें। Calere.caller संपत्ति नापसंद थी? रेजर एक्शनलिंक autogenerating? लंबाई = 7 यूआरएल में? कैसे PHP में कोड इंजेक्शन हमलों को रोकने के लिए? जब फ्लेक्सबॉक्स आइटम कॉलम मोड में लपेटते हैं, कंटेनर इसकी चौड़ाई नहीं बढ़ता स्ट्रिंग में वर्णों की एक सूची को निकालना के लिए AppDelegate क्या है और मुझे यह कैसे पता चल जाएगा कि इसका उपयोग कब किया जाए? AngularJS का उपयोग करते हुए नई विंडो में लिंक खोलें एक पाठ फ़ाइल पढ़ना और इसे अजगर में एकल शब्दों में विभाजित करना एक छवि दृश्य के एक प्रदर्शन के आकार को प्राप्त करने की कोशिश कर रहा है Generic.xaml के बारे में इतना खास क्या है? सी में बिट-फ़ील्ड का उपयोग कब करना है?

जावास्क्रिप्ट प्रोटोटाइप ऑपरेटर प्रदर्शन: स्मृति बचाता है, लेकिन क्या यह तेज़ है?

मैं जावास्क्रिप्ट कक्षाओं के तरीकों को जोड़ने के लिए प्रोटोटाइप ऑपरेटर का उपयोग करके यहां (डगलस क्रॉकफोर्ड) पढ़ता हूं, स्मृति भी बचाता है

फिर मैंने इस जॉन रेसग के लेख में पढ़ा "प्रोटोटाइप प्रॉपर्टी का गुच्छा बहुत तेजी से, बहुत तेजी से " एक समारोह को इंस्टेंटिएट करते हैं , लेकिन क्या वह मानक तरीके से प्रोटोटाइप का प्रयोग कर रहा है, या क्या वह अपने लेख में अपने विशिष्ट उदाहरण के बारे में बात कर रहा है?

उदाहरण के लिए, यह ऑब्जेक्ट बना रहा है:

function Class1() { this.showMsg = function(string) { alert(string); } } var c = new Class1(); c.showMsg(); 

इस ऑब्जेक्ट को बनाने से धीमी है , तो?

 function Class1() {} Class1.prototype.showMsg = function(string) { alert(string); } var c = new Class1(); c.showMsg(); 

पुनश्च

मुझे पता है कि प्रोटोटाइप का इस्तेमाल विरासत और सिंगलटन ऑब्जेक्ट आदि बनाने के लिए किया जाता है। लेकिन इस प्रश्न के साथ इन विषयों के साथ कुछ भी करने की आवश्यकता नहीं है।


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

वेब के समाधान से एकत्रित समाधान "जावास्क्रिप्ट प्रोटोटाइप ऑपरेटर प्रदर्शन: स्मृति बचाता है, लेकिन क्या यह तेज़ है?"

यह एक दिलचस्प सवाल था, इसलिए मैंने कुछ सरल परीक्षण चलाया (मुझे अपने ब्राउज़र को स्मृति को साफ करने के लिए पुनरारंभ करना चाहिए था, लेकिन मैंने नहीं किया, यह इसके लायक के लिए लेना)। यह सफारी और फ़ायरफ़ॉक्स पर कम से कम दिखता है, prototype काफी तेजी से चलाता है [संपादित करें: 20x जैसा पहले कहा गया है] मुझे यकीन है कि पूरी तरह से विशेषताओं वाले वस्तुओं के साथ एक वास्तविक दुनिया का परीक्षण बेहतर तुलना होगा। मैंने जो कोड चलाया था वह (यह परीक्षण कई बार अलग-अलग था):

 var X,Y, x,y, i, intNow; X = function() {}; X.prototype.message = function(s) { var mymessage = s + "";} X.prototype.addition = function(i,j) { return (i *2 + j * 2) / 2; } Y = function() { this.message = function(s) { var mymessage = s + "";} this.addition = function(i,j) { return (i *2 + j * 2) / 2; } }; intNow = (new Date()).getTime(); for (i = 0; i < 1000000; i++) { y = new Y(); y.message('hi'); y.addition(i,2) } console.log((new Date()).getTime() - intNow); //FF=5206ms; Safari=1554 intNow = (new Date()).getTime(); for (i = 0; i < 1000000; i++) { x = new X(); x.message('hi'); x.addition(i,2) } console.log((new Date()).getTime() - intNow);//FF=3894ms;Safari=606 

यह एक वास्तविक शर्मिंदा है, क्योंकि मैं वास्तव में prototype का उपयोग करने से नफरत करता हूं। मुझे अपना ऑब्जेक्ट कोड स्व-encapsulated होना पसंद है, और बहाव करने की अनुमति नहीं है मुझे लगता है कि जब गति मायने रखती है, हालांकि, मेरे पास कोई विकल्प नहीं है। अरे।

[संपादित करें] केविन के लिए बहुत धन्यवाद मेरे पिछले कोड की ओर इशारा करते हुए गलत था, prototype विधि की रिपोर्ट की गति को बहुत बड़ा बढ़ावा दिया। फिक्सिंग के बाद, प्रोटोटाइप अभी भी काफी तेज है, लेकिन अंतर इतना बड़ा नहीं है।

मुझे लगता होगा कि यह वस्तु के प्रकार पर निर्भर करता है जिसे आप बनाना चाहते हैं। मैं एंड्रयू के समान परीक्षण चलाया, लेकिन एक स्थिर वस्तु के साथ, और स्थिर ऑब्जेक्ट नीचे हाथ मिला यहां परीक्षा है:

 var X,Y,Z,x,y,z; X = function() {}; X.prototype.message = function(s) { var mymessage = s + "";} X.prototype.addition = function(i,j) { return (i *2 + j * 2) / 2; } Y = function() { this.message = function(s) { var mymessage = s + "";} this.addition = function(i,j) { return (i *2 + j * 2) / 2; } }; Z = { message: function(s) { var mymessage = s + "";} ,addition: function(i,j) { return (i *2 + j * 2) / 2; } } function TestPerformance() { var closureStartDateTime = new Date(); for (var i = 0; i < 100000; i++) { y = new Y(); y.message('hi'); y.addition(i,2); } var closureEndDateTime = new Date(); var prototypeStartDateTime = new Date(); for (var i = 0; i < 100000; i++) { x = new X(); x.message('hi'); x.addition(i,2); } var prototypeEndDateTime = new Date(); var staticObjectStartDateTime = new Date(); for (var i = 0; i < 100000; i++) { z = Z; // obviously you don't really need this z.message('hi'); z.addition(i,2); } var staticObjectEndDateTime = new Date(); var closureTime = closureEndDateTime.getTime() - closureStartDateTime.getTime(); var prototypeTime = prototypeEndDateTime.getTime() - prototypeStartDateTime.getTime(); var staticTime = staticObjectEndDateTime.getTime() - staticObjectStartDateTime.getTime(); console.log("Closure time: " + closureTime + ", prototype time: " + prototypeTime + ", static object time: " + staticTime); } TestPerformance(); 

यह परीक्षा कोड का एक संशोधन है जिसे मैंने पाया:

http://blogs.msdn.com/b/kristoffer/archive/2007/02/13/javascript-prototype-versus-closure-execution-speed.aspx

परिणाम:

आईई 6: बंद करने का समय: 1062, प्रोटोटाइप का समय: 766, स्थैतिक ऑब्जेक्ट टाइम: 406

IE8: समापन समय: 781, प्रोटोटाइप समय: 406, स्थैतिक वस्तु समय: 188

एफएफ: समापन समय: 233, प्रोटोटाइप समय: 141, स्थैतिक वस्तु समय: 94

सफारी: समापन समय: 152, प्रोटोटाइप समय: 12, स्थिर वस्तु समय: 6

क्रोम: समापन समय: 13, प्रोटोटाइप समय: 8, स्थैतिक वस्तु समय: 3

यह सबक सीखा है कि यदि आपको एक ही कक्षा में कई अलग-अलग ऑब्जेक्ट्स को इन्स्तांत करने की ज़रूरत नहीं है, तो इसे एक स्थिर ऑब्जेक्ट के रूप में बनाना, हाथ नीचे जीत जाता है तो ध्यान से सोचें कि आप किस प्रकार की कक्षा चाहते हैं?

इसलिए मैंने यह भी परीक्षण करने का निर्णय लिया। मैंने सृजन का समय, निष्पादन का समय और मेमोरी का उपयोग किया था। मैंने नोडजेज़ v0.8.12 का उपयोग किया और विंडोज 7 में बूट किए गए मैक बुक प्रो पर चलने वाला मोचा परीक्षण ढांचा। 'फास्ट' परिणाम प्रोटोटाइप का उपयोग कर रहे हैं और 'धीमी' मॉड्यूल पैटर्न का उपयोग कर रहे हैं मैंने प्रत्येक प्रकार के ऑब्जेक्ट का 1 मिलियन बनाया और फिर प्रत्येक वस्तु में 4 तरीकों तक पहुंचा। यहां परिणाम दिए गए हैं:

 c:\ABoxAbove>mocha test/test_andrew.js Fast Allocation took:170 msec ·Fast Access took:826 msec state[0] = First0 Free Memory:5006495744 ·Slow Allocation took:999 msec ·Slow Access took:599 msec state[0] = First0 Free Memory:4639649792 Mem diff:358248k Mem overhead per obj:366.845952bytes ? 4 tests complete (2.6 seconds) 

कोड निम्नानुसार है:

 var assert = require("assert"), os = require('os'); function Fast (){} Fast.prototype = { state:"", getState:function (){return this.state;}, setState:function (_state){this.state = _state;}, name:"", getName:function (){return this.name;}, setName:function (_name){this.name = _name;} }; function Slow (){ var state, name; return{ getState:function (){return this.state;}, setState:function (_state){this.state = _state;}, getName:function (){return this.name;}, setName:function (_name){this.name = _name;} }; } describe('test supposed fast prototype', function(){ var count = 1000000, i, objs = [count], state = "First", name="Test"; var ts, diff, mem; it ('should allocate a bunch of objects quickly', function (done){ ts = Date.now (); for (i = 0; i < count; ++i){objs[i] = new Fast ();} diff = Date.now () - ts; console.log ("Fast Allocation took:%d msec", diff); done (); }); it ('should access a bunch of objects quickly', function (done){ ts = Date.now (); for (i = 0; i < count; ++i){ objs[i].setState (state + i); assert (objs[i].getState () === state + i, "States should be equal"); objs[i].setName (name + i); assert (objs[i].getName () === name + i, "Names should be equal"); } diff = Date.now() - ts; console.log ("Fast Access took:%d msec", diff); console.log ("state[0] = " + objs[0].getState ()); mem = os.freemem(); console.log ("Free Memory:" + mem + "\n"); done (); }); it ('should allocate a bunch of objects slowly', function (done){ ts = Date.now (); for (i = 0; i < count; ++i){objs[i] = Slow ();} diff = Date.now() - ts; console.log ("Slow Allocation took:%d msec", diff); done (); }); it ('should access a bunch of objects slowly', function (done){ ts = Date.now (); for (i = 0; i < count; ++i){ objs[i].setState (state + i); assert (objs[i].getState () === state + i, "States should be equal"); objs[i].setName (name + i); assert (objs[i].getName () === name + i, "Names should be equal"); } diff = Date.now() - ts; console.log ("Slow Access took:%d msec", diff); console.log ("state[0] = " + objs[0].getState ()); var mem2 = os.freemem(); console.log ("Free Memory:" + mem2 + "\n"); console.log ("Mem diff:" + (mem - mem2) / 1024 + "k"); console.log ("Mem overhead per obj:" + (mem - mem2) / count + 'bytes'); done (); }); }); 

निष्कर्ष: यह इस पोस्ट में जो अन्य लोगों ने पाया है, उनका समर्थन करता है। यदि आप लगातार वस्तुओं बना रहे हैं तो प्रोटोटाइप तंत्र स्पष्ट रूप से तेज है। यदि आपका कोड अधिक समय तक वस्तुओं का उपयोग करता है तो मॉड्यूल पैटर्न तेजी से होता है यदि आप स्मृति उपयोग के बारे में संवेदनशील हैं, प्रोटोटाइप तंत्र ~ 360 बाइट प्रति ऑब्जेक्ट का उपयोग करता है।

सहजता से, ऐसा प्रतीत होता है कि यह प्रोटोटाइप पर फ़ंक्शन बनाने के लिए अधिक मेमोरी-कुशल और तेज़ होगा: फ़ंक्शन केवल एक बार बनाया जाता है, हर बार कोई नया इंस्टेंस नहीं बनाया जाता है।

हालांकि, समारोह का उपयोग करने के लिए समय होने पर थोड़ी सी अंतर होगा। जब c.showMsg संदर्भित होता है, तो JavaScript रनटाइम पहली बार संपत्ति पर c लिए चेक करता है यदि यह नहीं मिला है, तो c प्रोटोटाइप की जांच की जाती है।

इसलिए, इस उदाहरण पर संपत्ति का निर्माण थोड़ा तेज पहुंच समय का परिणाम होगा – लेकिन यह केवल एक बहुत ही गहरी प्रोटोटाइप पदानुक्रम के लिए एक समस्या हो सकता है।

मैंने अपना परीक्षण चलाया

पहला निष्कर्ष यह है, कि स्थिर पहुंच वास्तविक प्रोटोटाइप से वास्तव में धीमी है। दिलचस्प है कि इस परीक्षण के संस्करण 23 में एक दोषपूर्ण प्रोटोटाइप (वेरिएबल एक्स) है, जो अभी पूरी तरह से ओवरराइड प्रोटोटाइप ऑब्जेक्ट देता है और जब मैं अपना परीक्षण बना रहा था, तो यह प्रोटोटाइप मेरे "वास्तविक प्रोटोटाइप" की तुलना में धीमी थी परीक्षा।

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

यह ब्याज का हो सकता है कि मैंने प्रोटोटाइप ऑब्जेक्ट को jQuery के साथ विस्तार किया। इसके बीच में विस्तार और यह उसी गति के बारे में था, जो प्रत्यक्ष काम के रूप में था। विस्तार परीक्षण के बाहर ही था, निश्चित रूप से। कम से कम यह कष्टप्रद ".prototype।" लिखने में नाकाम करने का एक तरीका है- सभी समय के हिस्सों पर।

उच्च रिज़ॉल्यूशन ब्राउज़र प्रदर्शन एपीआई टेस्ट

यहां पर कोई भी परीक्षण उच्च संकल्प परीक्षण के लिए प्रदर्शन एपीआई का लाभ ले रहा है, इसलिए मैंने ऐसा लिखा जो कि कई अलग-अलग परिदृश्यों के लिए सबसे तेज़ परिणाम दिखाएगा जिसमें 2 सबसे अधिक रनों पर अन्य किसी भी उत्तर की तुलना में तेज़ है।

प्रत्येक श्रेणी में उपवास (10,000 पुनरावृत्तियों)

  • केवल संपत्ति का उपयोग (~ 0.5 एमएमएस) : { __proto__: Type }
  • प्रॉपर्टी एक्सेस (<3ms) के साथ ऑब्जेक्ट ऑब्जेक्ट को लूपिंग करना: ऑब्जेक्ट। Object.create(Type)

कोड शुद्धिकरण सुनिश्चित करने के लिए बैबल ट्रांसपॉलेशन के बिना ES6 का उपयोग करता है। यह वर्तमान क्रोम में काम करता है ब्रेकडाउन देखने के लिए नीचे परीक्षण चलाएं।

 function profile () { function test ( name , define , construct , { index = 0 , count = 10000 , ordinals = [ 0, 1 ] , constructPrior = false } = {} ) { performance.clearMarks() performance.clearMeasures() const symbols = { type: Symbol('type') } const marks = ( { __proto__: null , start: `${name}_start` , define: `${name}_define` , construct: `${name}_construct` , end: `${name}_end` } ) performance.mark(marks.start) let Type = define() performance.mark(marks.define) let obj = constructPrior ? construct(Type) : null do { if(!constructPrior) obj = construct(Type) if(index === 0) performance.mark(marks.construct) const measureOrdinal = ordinals.includes(index) if(measureOrdinal) performance.mark(`${name}_ordinal_${index}_pre`) obj.message('hi') obj.addition(index, 2) if(measureOrdinal) performance.mark(`${name}_ordinal_${index}_post`) } while (++index < count) performance.mark(marks.end) const measureMarks = Object.assign ( { [`${name}_define`]: [ marks.start, marks.define ] , [`${name}_construct`]: [ marks.define, marks.construct ] , [`${name}_loop`]: [ marks.construct, marks.end ] , [`${name}_total`]: [ marks.start, marks.end ] } , ordinals.reduce((reduction, i) => Object.assign(reduction, { [`${name}_ordinal_${i}`]: [ `${name}_ordinal_${i}_pre`, `${name}_ordinal_${i}_post` ] }), {}) ) Object.keys(measureMarks).forEach((key) => performance.measure(key, ...measureMarks[key])) const measures = performance.getEntriesByType('measure').map(x => Object.assign(x, { endTime: x.startTime + x.duration })) measures.sort((a, b) => a.endTime - b.endTime) const durations = measures.reduce((reduction, measure) => Object.assign(reduction, { [measure.name]: measure.duration }), {}) return ( { [symbols.type]: 'profile' , profile: name , duration: durations[`${name}_total`] , durations , measures } ) } const refs = ( { __proto__: null , message: function(s) { var mymessage = s + '' } , addition: function(i, j) { return (i *2 + j * 2) / 2 } } ) const testArgs = [ [ 'constructor' , function define() { return function Type () { this.message = refs.message this.addition = refs.addition } } , function construct(Type) { return new Type() } ] , [ 'prototype' , function define() { function Type () { } Type.prototype.message = refs.message Type.prototype.addition = refs.addition return Type } , function construct(Type) { return new Type() } ] , [ 'Object.create' , function define() { return ( { __proto__: null , message: refs.message , addition: refs.addition } ) } , function construct(Type) { return Object.create(Type) } ] , [ 'proto' , function define() { return ( { __proto__: null , message: refs.message , addition: refs.addition } ) } , function construct(Type) { return { __proto__: Type } } ] ] return testArgs.reduce( (reduction, [ name, ...args ]) => ( Object.assign( reduction , { [name]: ( { normal: test(name, ...args, { constructPrior: true }) , reconstruct: test(`${name}_reconstruct`, ...args, { constructPrior: false }) } ) } ) ) , {}) } let profiled = profile() const breakdown = Object.keys(profiled).reduce((reduction, name) => [ ...reduction, ...Object.keys(profiled[name]).reduce((r, type) => [ ...r, { profile: `${name}_${type}`, duration: profiled[name][type].duration } ], []) ], []) breakdown.sort((a, b) => a.duration - b.duration) try { const Pre = props => React.createElement('pre', { children: JSON.stringify(props.children, null, 2) }) ReactDOM.render(React.createElement(Pre, { children: { breakdown, profiled } }), document.getElementById('profile')) } catch(err) { console.error(err) } 
 <script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js"></script> <div id="profile"></div> 

हमें वस्तु निर्माण और उपयोग को अलग करना होगा।

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

 function ThisFunc() { this.value = 0; this.increment = function(){ this.value++; } } function ProtFunc() { this.value = 0; } ProtFunc.prototype.increment = function (){ this.value++; } function ClosFunc() { var value = 0; return { increment:function(){ value++; } }; } var thisInstance = new ThisFunc; var iterations = 1000000; var intNow = (new Date()).getTime(); for (i = 0; i < iterations; i++) { thisInstance.increment(); } console.log(`ThisFunc: ${(new Date()).getTime() - intNow}`); // 27ms node v4.6.0 var protInstance = new ProtFunc; intNow = (new Date()).getTime(); for (i = 0; i < iterations; i++) { protInstance.increment(); } console.log(`ProtFunc: ${(new Date()).getTime() - intNow}`); // 4ms node v4.6.0 var closInstance = ClosFunc(); intNow = (new Date()).getTime(); for (i = 0; i < iterations; i++) { closInstance.increment(); } console.log(`ClosFunc: ${(new Date()).getTime() - intNow}`); // 7ms node v4.6.0 

इन परिणामों से हम देख सकते हैं कि प्रोटोटाइप संस्करण सबसे तेज़ (4ms) है, लेकिन समापन संस्करण बहुत करीब है (7ms)। आपको अपने विशेष मामले के लिए अभी भी बेंचमार्क की आवश्यकता हो सकती है।

इसलिए:

  • हम प्रोटोटाइप संस्करण का उपयोग कर सकते हैं जब हमें प्रदर्शन के हर बिट की आवश्यकता होती है या उदाहरणों के बीच कार्य साझा करता है।
  • हम अन्य संस्करणों का उपयोग कर सकते हैं, जब हम जो चाहते हैं वह वे विशेषताएं जो प्रदान करते हैं। (निजी राज्य के सांकेतिकरण, पठनीयता आदि)

पुनश्च: मैंने एक संदर्भ के रूप में एंड्रयू का जवाब इस्तेमाल किया। उसी लूप और नोटेशन का इस्तेमाल किया

मुझे यकीन है कि जहां तक ​​ऑब्जेक्ट को चालू करना होता है, यह तेजी से होता है और कम मेमोरी भी खपत करता है, इसके बारे में कोई संदेह नहीं है, लेकिन मुझे लगता होगा कि जावास्क्रिप्ट इंजन ऑब्जेक्ट के सभी गुणों के माध्यम से लूप की ज़रूरत है, यह निर्धारित करने के लिए कि संपत्ति / लागू की गई विधि उस ऑब्जेक्ट का हिस्सा है और यदि नहीं, तो प्रोटोटाइप के लिए जांच करें। मैं इस बारे में 100% निश्चित नहीं हूं, लेकिन मैं यह मान रहा हूं कि यह कैसे काम करता है और यदि ऐसा है, तो ऐसे कुछ मामलों में जहां आपके ऑब्जेक्ट में बहुत अधिक विधियों को जोड़ा गया है, केवल एक बार instantiated और भारी उपयोग किया है, तो यह संभवतः एक हो सकता है थोड़ा धीमा, लेकिन यह सिर्फ एक अनुमान है मैंने कुछ भी परीक्षण नहीं किया है।

लेकिन अंत में, मैं अभी भी सहमत हूं कि एक सामान्य नियम के रूप में, प्रोटोटाइप का उपयोग तेजी से होगा

इसलिए, इस उदाहरण पर संपत्ति का निर्माण थोड़ा तेज पहुंच समय का परिणाम होगा – लेकिन यह केवल एक बहुत ही गहरी प्रोटोटाइप पदानुक्रम के लिए एक समस्या हो सकता है।

वास्तव में परिणाम अलग है तो हम उम्मीद कर सकते हैं – प्रोटोटाइप किए गए तरीकों के लिए समय का उपयोग तेजी से तब होता है जब ऑब्जेक्ट (एफएफ परीक्षण) के साथ जुड़ी विधियों तक पहुंच होती है।