दिलचस्प पोस्ट
टाइमर और गेम लूप का उपयोग करना इकाई फ़्रेमवर्क / SQL2008 – संस्थाओं के लिए स्वचालित रूप से अद्यतन LastModified फ़ील्ड कैसे करें? I आईओएस में SHA-2 (आदर्श एसएचए 256 या एसएचए 512) हैश की गणना कैसे कर सकता हूं? आंशिक रूप से सीआरएल के साथ एक दूरस्थ फ़ाइल डाउनलोड करने के लिए कैसे? फ़ाइल या असेंबली को 'एंट्ल्र 3.रेंटाइम (1)' या इसके निर्भरता में से एक लोड नहीं किया जा सका पूंछ कॉल opcode उत्पन्न टेक्सटेरा में चयनित पाठ कैसे प्राप्त करें? जब मैं jQuery के स्थगित "तब" विधि का उपयोग करना चाहिए और मुझे "पाइप" विधि का उपयोग कब करना चाहिए? एएसपी.नेट एमवीसी के अंतर्गत एसएसएल पेज एक अस्पष्ट संदर्भ का समाधान करना फेसबुक कनेक्ट- $ user_id = $ facebook-> getUser (); हमेशा वापस 0 एनवीएम नए टर्मिनल सत्र में "भूल" नोड रखता है क्रॉस-ऑरिजन अनुरोध पर अवरुद्ध नेटिक कोड पर एक .NET एप्लिकेशन को कैसे संकलित करें? जावा डेस्कटॉप अनुप्रयोग: SWT बनाम स्विंग

जावास्क्रिप्ट निजी विधियों

एक सार्वजनिक विधि के साथ एक जावास्क्रिप्ट वर्ग बनाने के लिए मैं ऐसा कुछ करता हूं:

function Restaurant() {} Restaurant.prototype.buy_food = function(){ // something here } Restaurant.prototype.use_restroom = function(){ // something here } 

इस तरह से मेरी कक्षा के उपयोगकर्ता निम्न कर सकते हैं:

 var restaurant = new Restaurant(); restaurant.buy_food(); restaurant.use_restroom(); 

मैं एक निजी विधि कैसे बनाऊं, जिसे buy_food और use_restroom तरीकों से बुलाया जा सकता है, लेकिन क्लास के उपयोगकर्ताओं द्वारा बाह्य रूप से नहीं?

दूसरे शब्दों में, मैं अपनी विधि कार्यान्वयन करना चाहता हूं:

 Restaurant.prototype.use_restroom = function() { this.private_stuff(); } 

लेकिन यह काम नहीं करना चाहिए:

 var r = new Restaurant(); r.private_stuff(); 

मैं private_stuff को एक निजी विधि के रूप में कैसे परिभाषित private_stuff इसलिए ये दोनों सत्य private_stuff ?

मैंने डग क्रॉकफोर्ड के कुछ समय के लिए पढ़ा है, लेकिन ऐसा लगता नहीं है कि "निजी" तरीके सार्वजनिक विधियों से कहा जा सकता है और "विशेषाधिकारित" तरीकों को बाह्य रूप से कहा जा सकता है

Solutions Collecting From Web of "जावास्क्रिप्ट निजी विधियों"

आप ऐसा कर सकते हैं, लेकिन नकारात्मक पक्ष यह है कि यह प्रोटोटाइप का हिस्सा नहीं हो सकता है:

 function Restaurant() { var myPrivateVar; var private_stuff = function() // Only visible inside Restaurant() { myPrivateVar = "I can set this here!"; } this.use_restroom = function() // use_restroom is visible to all { private_stuff(); } this.buy_food = function() // buy_food is visible to all { private_stuff(); } } 

आप इस तरह से निजी तरीके अनुकरण कर सकते हैं:

 function Restaurant() { } Restaurant.prototype = (function() { var private_stuff = function() { // Private code here }; return { constructor:Restaurant, use_restroom:function() { private_stuff(); } }; })(); var r = new Restaurant(); // This will work: r.use_restroom(); // This will cause an error: r.private_stuff(); 

यहां इस तकनीक पर अधिक जानकारी: http://webreflection.blogspot.com/2008/04/natural-javascript-private-methods.html

स्वयं को लागू करने का फ़ंक्शन और कॉल का उपयोग करना

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

विकिपीडिया उद्धरण:

कई वस्तु-उन्मुख भाषाओं के विपरीत, फ़ंक्शन परिभाषा और एक विधि परिभाषा के बीच कोई अंतर नहीं है। इसके बजाय, फ़ंक्शन कॉलिंग के दौरान अंतर होता है; जब किसी फ़ंक्शन को ऑब्जेक्ट की एक विधि के रूप में कहा जाता है, फ़ंक्शन के स्थानीय इस कीवर्ड को उस ऑब्जेक्शन के लिए उस ऑब्जेक्ट के लिए बाध्य है।

निजी "पद्धति" को कॉल करने के लिए स्वयं आत्मनिर्भर समारोह और कॉल फ़ंक्शन का उपयोग करके समाधान करें :

 var MyObject = (function () { // Constructor function MyObject (foo) { this._foo = foo; } function privateFun (prefix) { return prefix + this._foo; } MyObject.prototype.publicFun = function () { return privateFun.call(this, '>>'); } return MyObject; })(); var myObject = new MyObject('bar'); myObject.publicFun(); // Returns '>>bar' myObject.privateFun('>>'); // ReferenceError: private is not defined 

कॉल फ़ंक्शन हमें उचित संदर्भ ( this ) के साथ निजी फ़ंक्शन को कॉल करने की अनुमति देता है।

नोड। जेएस के साथ सरलता

यदि आप node.js का उपयोग कर रहे हैं, तो आपको IIFE की आवश्यकता नहीं है क्योंकि आप मॉड्यूल लोडिंग सिस्टम का लाभ ले सकते हैं:

 function MyObject (foo) { this._foo = foo; } function privateFun (prefix) { return prefix + this._foo; } MyObject.prototype.publicFun = function () { return privateFun.call(this, '>>'); } exports.MyObject = MyObject; 

फ़ाइल लोड करें:

 var MyObject = require('./MyObject').MyObject; var myObject = new MyObject('bar'); myObject.publicFun(); // Returns '>>bar' myObject.privateFun('>>'); // ReferenceError: private is not defined 

(प्रयोगात्मक) बाइंड ऑपरेटर के साथ ईएस 7

बाइंड ऑपरेटर :: एक ECMAScript प्रस्ताव है और इसे Babel ( चरण 0 ) में लागू किया गया है ।

 export default class MyObject { constructor (foo) { this._foo = foo; } publicFun () { return this::privateFun('>>'); } } function privateFun (prefix) { return prefix + this._foo; } 

फ़ाइल लोड करें:

 import MyObject from './MyObject'; let myObject = new MyObject('bar'); myObject.publicFun(); // Returns '>>bar' myObject.privateFun('>>'); // TypeError: myObject.privateFun is not a function 

इन स्थितियों में जब आपके पास सार्वजनिक एपीआई है, और आप निजी और सार्वजनिक विधियों / गुणों को पसंद करेंगे, तो मैं हमेशा मॉड्यूल पैटर्न का उपयोग करता हूँ यह पैटर्न YUI लाइब्रेरी के भीतर लोकप्रिय बना है, और विवरण यहां पा सकते हैं:

http://yuiblog.com/blog/2007/06/12/module-pattern/

यह वास्तव में सरल और अन्य डेवलपर्स के लिए आसान है। एक सरल उदाहरण के लिए:

 var MYLIB = function() { var aPrivateProperty = true; var aPrivateMethod = function() { // some code here... }; return { aPublicMethod : function() { aPrivateMethod(); // okay // some code here... }, aPublicProperty : true }; }(); MYLIB.aPrivateMethod() // not okay MYLIB.aPublicMethod() // okay 

यहां क्लास है जिसे मैंने समझने के लिए बनाया है कि डगलस क्रॉकफोर्ड ने अपनी साइट में जेनेटिक में निजी सदस्यों का क्या सुझाव दिया है

 function Employee(id, name) { //Constructor //Public member variables this.id = id; this.name = name; //Private member variables var fName; var lName; var that = this; //By convention, we create a private variable 'that'. This is used to //make the object available to the private methods. //Private function function setFName(pfname) { fName = pfname; alert('setFName called'); } //Privileged function this.setLName = function (plName, pfname) { lName = plName; //Has access to private variables setFName(pfname); //Has access to private function alert('setLName called ' + this.id); //Has access to member variables } //Another privileged member has access to both member variables and private variables //Note access of this.dataOfBirth created by public member setDateOfBirth this.toString = function () { return 'toString called ' + this.id + ' ' + this.name + ' ' + fName + ' ' + lName + ' ' + this.dataOfBirth; } } //Public function has access to member variable and can create on too but does not have access to private variable Employee.prototype.setDateOfBirth = function (dob) { alert('setDateOfBirth called ' + this.id); this.dataOfBirth = dob; //Creates new public member note this is accessed by toString //alert(fName); //Does not have access to private member } $(document).ready() { var employee = new Employee(5, 'Shyam'); //Create a new object and initialize it with constructor employee.setLName('Bhaskar', 'Ram'); //Call privileged function employee.setDateOfBirth('1/1/2000'); //Call public function employee.id = 9; //Set up member value //employee.setFName('Ram'); //can not call Private Privileged method alert(employee.toString()); //See the changed object } 

मैंने यह सोचा: संपादित करें: वास्तव में, किसी ने एक समान समाधान से जोड़ा है। ओह!

 var Car = function() { } Car.prototype = (function() { var hotWire = function() { // Private code *with* access to public properties through 'this' alert( this.drive() ); // Alerts 'Vroom!' } return { steal: function() { hotWire.call( this ); // Call a private method }, drive: function() { return 'Vroom!'; } }; })(); var getAwayVechile = new Car(); hotWire(); // Not allowed getAwayVechile.hotWire(); // Not allowed getAwayVechile.steal(); // Alerts 'Vroom!' 

मुझे लगता है कि ऐसे प्रश्न फिर से आते हैं क्योंकि बंद होने की समझ के अभाव में एसएलओएसएस जेएस में सबसे महत्वपूर्ण बात है। प्रत्येक जेएस प्रोग्रामर को इसका सार महसूस करना पड़ता है।

1. सबसे पहले हमें पृथक गुंजाइश (समापन) बनाने की जरूरत है।

 function () { } 

2. इस क्षेत्र में, हम जो भी चाहते हैं वह कर सकते हैं। और इसके बारे में कोई भी नहीं जानता।

 function () { var name, secretSkills = { pizza: function () { return new Pizza() }, sushi: function () { return new Sushi() } } function Restaurant(_name) { name = _name } Restaurant.prototype.getFood = function (name) { return name in secretSkills ? secretSkills[name]() : null } } 

3. हमारे रेस्तरां वर्ग के बारे में दुनिया को जानने के लिए, हमें इसे समापन से वापस करना होगा।

 var Restaurant = (function () { // Restaurant definition return Restaurant })() 

4. अंत में, हमारे पास:

 var Restaurant = (function () { var name, secretSkills = { pizza: function () { return new Pizza() }, sushi: function () { return new Sushi() } } function Restaurant(_name) { name = _name } Restaurant.prototype.getFood = function (name) { return name in secretSkills ? secretSkills[name]() : null } return Restaurant })() 

5. इसके अलावा, इस दृष्टिकोण में विरासत और टेम्पलेटिंग की क्षमता है

 // Abstract class function AbstractRestaurant(skills) { var name function Restaurant(_name) { name = _name } Restaurant.prototype.getFood = function (name) { return skills && name in skills ? skills[name]() : null } return Restaurant } // Concrete classes SushiRestaurant = AbstractRestaurant({ sushi: function() { return new Sushi() } }) PizzaRestaurant = AbstractRestaurant({ pizza: function() { return new Pizza() } }) var r1 = new SushiRestaurant('Yo! Sushi'), r2 = new PizzaRestaurant('Dominos Pizza') r1.getFood('sushi') r2.getFood('pizza') 

मुझे आशा है कि इससे इस विषय को बेहतर ढंग से समझने में मदद मिलेगी

इस सब बंद करने के लिए आपको लागत आएगी सुनिश्चित करें कि आप विशेष रूप से IE में गति के प्रभाव का परीक्षण करते हैं आप पाएंगे कि नामकरण सम्मेलन के साथ आप बेहतर हैं। अभी भी ऐसे कई कॉर्पोरेट वेब उपयोगकर्ता हैं जो कि आईई 6 का उपयोग करने के लिए मजबूर हैं …

क्रॉकफोर्ड के निजी या निजीकृत पैटर्न का पालन करने वाले किसी भी समाधान को लें उदाहरण के लिए:

 function Foo(x) { var y = 5; var bar = function() { return y * x; }; this.public = function(z) { return bar() + x * z; }; } 

किसी भी मामले में जहां हमलावर को जेएस संदर्भ पर "निष्पादन" अधिकार नहीं है, उसे "सार्वजनिक" या "निजी" क्षेत्रों या विधियों तक पहुंचने का कोई तरीका नहीं है। अगर हमलावर का यह उपयोग होता है तो वह इस एक लाइनर को निष्पादित कर सकता है:

 eval("Foo = " + Foo.toString().replace( /{/, "{ this.eval = function(code) { return eval(code); }; " )); 

ध्यान दें कि उपरोक्त कोड सभी निर्माता-प्रकार-गोपनीयता के लिए सामान्य है यह यहां कुछ समाधानों से असफल हो जायेगा लेकिन यह स्पष्ट होना चाहिए कि बहुत सारे क्लोजर आधारित समाधान इस प्रकार अलग-अलग replace() मापदंडों के साथ टूटा जा सकते हैं

इसके बाद किसी भी ऑब्जेक्ट को निष्पादित किया जाता है, new Foo() के साथ बनाया जा रहा है एक eval विधि है जो वापस लौटाने के लिए कहा जा सकता है या कंसल्टेंट्स के समापन में परिभाषित मूल्यों या विधियों को बदलना, जैसे:

 f = new Foo(99); f.eval("x"); f.eval("y"); f.eval("x = 8"); 

एकमात्र समस्या यह है कि मैं यह देख सकता हूं कि यह उन मामलों के लिए काम नहीं करेगा, जहां केवल एक उदाहरण है और यह लोड पर बनाया गया है लेकिन फिर वास्तव में एक प्रोटोटाइप को परिभाषित करने का कोई कारण नहीं है और उस मामले में हमलावर तब तक कन्स्ट्रक्टर के बजाय ऑब्जेक्ट को फिर से बना सकते हैं, क्योंकि उसके पास एक ही पैरामीटर (जैसे वे निरंतर हैं या उपलब्ध मानों से गणना की जाती है) पास करने का एक तरीका है।

मेरी राय में, यह बहुत ज्यादा क्रॉकफोर्ड का समाधान बेकार है। चूंकि "गोपनीयता" आसानी से अपने समाधान के डाउनसाइड्स (कम पठनीयता और रखरखाव, कम प्रदर्शन, बढ़ी हुई स्मृति) को तोड़ा जाता है क्योंकि "कोई गोपनीयता" प्रोटोटाइप आधारित विधि बेहतर विकल्प नहीं बनाता है

मैं आमतौर पर __private और _protected विधियों और खेतों (पर्ल शैली) को चिह्नित करने के लिए अग्रणी अंडरस्कोर का उपयोग करता हूं, लेकिन जावास्क्रिप्ट में गोपनीयता रखने का विचार सिर्फ यह दिखाता है कि यह गलत अर्थ वाली भाषा है।

इसलिए मैं अपनी पहली वाक्य को छोड़कर क्रॉफोर्ड से असहमत हूं

तो आप जेएस में वास्तविक गोपनीयता कैसे प्राप्त करते हैं? सर्वर पक्ष पर निजी होने के लिए आवश्यक सभी चीज़ों को रखें और AJAX कॉल करने के लिए JS का उपयोग करें।

मॉड्यूल पैटर्न के अपोक्तिस : रिवीलिंग मॉड्यूल पैटर्न

एक बहुत ही मजबूत पैटर्न के लिए एक साफ थोड़ा विस्तार

यदि आप सार्वजनिक कार्यों के लिए निजी कार्यों का उपयोग करने की क्षमता के साथ सार्वजनिक और निजी कार्यों की पूरी रेंज चाहते हैं, तो इस तरह एक वस्तु के लिए लेआउट कोड:

 function MyObject(arg1, arg2, ...) { //constructor code using constructor arguments... //create/access public variables as // this.var1 = foo; //private variables var v1; var v2; //private functions function privateOne() { } function privateTwon() { } //public functions MyObject.prototype.publicOne = function () { }; MyObject.prototype.publicTwo = function () { }; } 

मुझे लगता है कि @ domgblackwell और @ james के दृष्टिकोण के साथ समस्या यह है कि प्रोटोटाइप के तरीकों को हर उदाहरण के निर्माण के साथ परिभाषित किया जाएगा हालांकि यह ओवरराइड होने के कारण यह स्मृति पहलू से एक गैर-मुद्दा हो सकता है यह भव्यता पर अंक खो देता है, हालांकि, उन तरीकों को हर बार परिभाषित करने के लिए यह काफी बदसूरत है

इस बारे में क्या?

 var Restaurant = (function() { var _id = 0; var privateVars = []; function Restaurant(name) { this.id = ++_id; this.name = name; privateVars[this.id] = { cooked: [] }; } Restaurant.prototype.cook = function (food) { privateVars[this.id].cooked.push(food); } return Restaurant; })(); 

निजी चर लुकअप तत्काल कार्य के दायरे से बाहर असंभव है। कार्यों का कोई दोहराव नहीं है, मेमोरी बचत।

नकारात्मक पक्ष यह है कि निजी चर का लुकअप privateVars[this.id].cooked है। टाइप करने के लिए हास्यास्पद है। एक अतिरिक्त "id" चर भी है

व्यक्तिगत रूप से, मैं जावास्क्रिप्ट में कक्षाएं बनाने के लिए निम्नलिखित पैटर्न को पसंद करता हूं:

 var myClass = (function() { // Private class properties go here var blueprint = function() { // Private instance properties go here ... }; blueprint.prototype = { // Public class properties go here ... }; return { // Public class properties go here create : function() { return new blueprint(); } ... }; })(); 

जैसा कि आप देख सकते हैं, यह आपको दोनों वर्ग गुणों और उदाहरण गुणों को परिभाषित करने की अनुमति देता है, जिनमें से प्रत्येक सार्वजनिक और निजी हो सकता है


डेमो

 var Restaurant = function() { var totalfoodcount = 0; // Private class property var totalrestroomcount = 0; // Private class property var Restaurant = function(name){ var foodcount = 0; // Private instance property var restroomcount = 0; // Private instance property this.name = name this.incrementFoodCount = function() { foodcount++; totalfoodcount++; this.printStatus(); }; this.incrementRestroomCount = function() { restroomcount++; totalrestroomcount++; this.printStatus(); }; this.getRestroomCount = function() { return restroomcount; }, this.getFoodCount = function() { return foodcount; } }; Restaurant.prototype = { name : '', buy_food : function(){ this.incrementFoodCount(); }, use_restroom : function(){ this.incrementRestroomCount(); }, getTotalRestroomCount : function() { return totalrestroomcount; }, getTotalFoodCount : function() { return totalfoodcount; }, printStatus : function() { document.body.innerHTML += '<h3>Buying food at '+this.name+'</h3>' + '<ul>' + '<li>Restroom count at ' + this.name + ' : '+ this.getRestroomCount() + '</li>' + '<li>Food count at ' + this.name + ' : ' + this.getFoodCount() + '</li>' + '<li>Total restroom count : '+ this.getTotalRestroomCount() + '</li>' + '<li>Total food count : '+ this.getTotalFoodCount() + '</li>' + '</ul>'; } }; return { // Singleton public properties create : function(name) { return new Restaurant(name); }, printStatus : function() { document.body.innerHTML += '<hr />' + '<h3>Overview</h3>' + '<ul>' + '<li>Total restroom count : '+ Restaurant.prototype.getTotalRestroomCount() + '</li>' + '<li>Total food count : '+ Restaurant.prototype.getTotalFoodCount() + '</li>' + '</ul>' + '<hr />'; } }; }(); var Wendys = Restaurant.create("Wendy's"); var McDonalds = Restaurant.create("McDonald's"); var KFC = Restaurant.create("KFC"); var BurgerKing = Restaurant.create("Burger King"); Restaurant.printStatus(); Wendys.buy_food(); Wendys.use_restroom(); KFC.use_restroom(); KFC.use_restroom(); Wendys.use_restroom(); McDonalds.buy_food(); BurgerKing.buy_food(); Restaurant.printStatus(); BurgerKing.buy_food(); Wendys.use_restroom(); McDonalds.buy_food(); KFC.buy_food(); Wendys.buy_food(); BurgerKing.buy_food(); McDonalds.buy_food(); Restaurant.printStatus(); 
 var TestClass = function( ) { var privateProperty = 42; function privateMethod( ) { alert( "privateMethod, " + privateProperty ); } this.public = { constructor: TestClass, publicProperty: 88, publicMethod: function( ) { alert( "publicMethod" ); privateMethod( ); } }; }; TestClass.prototype = new TestClass( ).public; var myTestClass = new TestClass( ); alert( myTestClass.publicProperty ); myTestClass.publicMethod( ); alert( myTestClass.privateMethod || "no privateMethod" ); 

Georgebrock के समान है लेकिन थोड़ा कम वर्बोस (आईएमएचओ) यह इस तरह से करने में कोई समस्या है? (मैंने इसे कहीं नहीं देखा है)

संपादित करें: मुझे एहसास हुआ कि यह हर तरह की बेकार है क्योंकि हर स्वतंत्र पलटाव की सार्वजनिक पद्धतियों की अपनी प्रति है, इस प्रकार प्रोटोटाइप का उपयोग कम हो रहा है।

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

मैंने ये ढूंढ निकाला:

 var MyClass = (function () { var secret = {}; // You can only getPriv() if you know this function MyClass() { var that = this, priv = { foo: 0 // ... and other private values }; that.getPriv = function (proof) { return (proof === secret) && priv; }; } MyClass.prototype.inc = function () { var priv = this.getPriv(secret); priv.foo += 1; return priv.foo; }; return MyClass; }()); var x = new MyClass(); x.inc(); // 1 x.inc(); // 2 

वस्तु निजी में निजी संपत्तियां हैं यह सार्वजनिक समारोह getPriv() माध्यम से पहुँचा जा सकता है, लेकिन यह फ़ंक्शन false जब तक कि आप इसे secret पास नहीं करते हैं, और यह केवल मुख्य बंद के अंदर ही जाना जाता है।

अनाम कोड में सभी कोड लपेटें: फिर, सभी फ़ंक्शंस निजी होंगे, केवल window ऑब्जेक्ट से जुड़ी फ़ंक्शंस:

 (function(w,nameSpacePrivate){ w.Person=function(name){ this.name=name; return this; }; w.Person.prototype.profilePublic=function(){ return nameSpacePrivate.profile.call(this); }; nameSpacePrivate.profile=function(){ return 'My name is '+this.name; }; })(window,{}); 

इसे इस्तेमाल करो :

  var abdennour=new Person('Abdennour'); abdennour.profilePublic(); 

बेला

निजी फ़ंक्शन मॉड्यूल पैटर्न के उपयोग से सार्वजनिक चर का उपयोग नहीं कर सकते

चूंकि सब लोग यहां अपना कोड पोस्ट कर रहे थे, मैं भी ऐसा करूँगा …

मुझे कॉकफोर्ड पसंद है क्योंकि उन्होंने जावास्क्रिप्ट में असली ऑब्जेक्ट ओरिएंटेड पैटर्न पेश किए लेकिन वह भी एक नया गलतफहमी के साथ आया था, "वह" एक

तो वह क्यों "वह = यह" प्रयोग कर रहा है? इसमें निजी कार्यों के साथ कुछ भी नहीं करना है इसे आंतरिक कार्यों के साथ करना है!

क्योंकि क्रॉकफोर्ड के अनुसार यह गड़बड़ कोड है:

 Function Foo( ) { this.bar = 0; var foobar=function( ) { alert(this.bar); } } 

इसलिए उन्होंने ऐसा करने का सुझाव दिया:

 Function Foo( ) { this.bar = 0; that = this; var foobar=function( ) { alert(that.bar); } } 

जैसा कि मैंने कहा, मुझे पूरा यकीन है कि क्रॉकफोर्ड ने उसके बारे में और उसके बारे में स्पष्टीकरण दिया था (लेकिन उसका कोड निश्चित रूप से सही है)। या क्या वह जावास्क्रिप्ट की दुनिया को बेवकूफ़ बना रहा था, यह जानने के लिए कि उसका कोड कॉपी कौन कर रहा है? मुझे नहीं पता … मैं कोई ब्राउज़र जीईक नहीं हूं; डी

संपादित करें

आह, यह सब क्या है: 'var' = क्या; ' जावास्क्रिप्ट में क्या मतलब है?

तो क्रोकी वास्तव में उनके स्पष्टीकरण के साथ गलत था …. लेकिन अपने कोड के साथ, तो वह अभी भी एक महान व्यक्ति है :))

सामान्य तौर पर मैंने ऑब्जेक्ट के लिए अस्थायी तौर पर निजी ऑब्जेक्ट _ को जोड़ा। आपको विधि के लिए "पावर-कन्स्ट्रक्टर" में गोपनीयता को खोलना होगा। यदि आप प्रोटोटाइप से विधि कहते हैं, तो आप प्रोटोटाइप-विधि को अधिलेखित करने में सक्षम होंगे

  • "पावर-कन्स्ट्रक्टर" में एक सार्वजनिक विधि सुलभ बनाएं: (सीटीएक्स ऑब्जेक्ट प्रसंग है)

     ctx.test = GD.Fabric.open('test', GD.Test.prototype, ctx, _); // is a private object 
  • अब मेरे पास यह खुला गोपनीयता है:

     GD.Fabric.openPrivacy = function(func, clss, ctx, _) { return function() { ctx._ = _; var res = clss[func].apply(ctx, arguments); ctx._ = null; return res; }; }; 

यह मैंने जो काम किया है:

एक वर्ग की चीनी कोड की आवश्यकता है जिसे आप यहां पा सकते हैं । इसके अलावा संरक्षित, विरासत, आभासी, स्थिर सामान का समर्थन करता है …

 ;( function class_Restaurant( namespace ) { 'use strict'; if( namespace[ "Restaurant" ] ) return // protect against double inclusions namespace.Restaurant = Restaurant var Static = TidBits.OoJs.setupClass( namespace, "Restaurant" ) // constructor // function Restaurant() { this.toilets = 3 this.Private( private_stuff ) return this.Public( buy_food, use_restroom ) } function private_stuff(){ console.log( "There are", this.toilets, "toilets available") } function buy_food (){ return "food" } function use_restroom (){ this.private_stuff() } })( window ) var chinese = new Restaurant console.log( chinese.buy_food() ); // output: food console.log( chinese.use_restroom() ); // output: There are 3 toilets available console.log( chinese.toilets ); // output: undefined console.log( chinese.private_stuff() ); // output: undefined // and throws: TypeError: Object #<Restaurant> has no method 'private_stuff' 
 Class({ Namespace:ABC, Name:"ClassL2", Bases:[ABC.ClassTop], Private:{ m_var:2 }, Protected:{ proval:2, fight:Property(function(){ this.m_var--; console.log("ClassL2::fight (m_var)" +this.m_var); },[Property.Type.Virtual]) }, Public:{ Fight:function(){ console.log("ClassL2::Fight (m_var)"+this.m_var); this.fight(); } } }); 

https://github.com/nooning/JSClass

I have created a new tool to allow you to have true private methods on the prototype https://github.com/TremayneChrist/ProtectJS

उदाहरण:

 var MyObject = (function () { // Create the object function MyObject() {} // Add methods to the prototype MyObject.prototype = { // This is our public method public: function () { console.log('PUBLIC method has been called'); }, // This is our private method, using (_) _private: function () { console.log('PRIVATE method has been called'); } } return protect(MyObject); })(); // Create an instance of the object var mo = new MyObject(); // Call its methods mo.public(); // Pass mo._private(); // Fail 

You have to put a closure around your actual constructor-function, where you can define your private methods. To change data of the instances through these private methods, you have to give them "this" with them, either as an function argument or by calling this function with .apply(this) :

 var Restaurant = (function(){ var private_buy_food = function(that){ that.data.soldFood = true; } var private_take_a_shit = function(){ this.data.isdirty = true; } // New Closure function restaurant() { this.data = { isdirty : false, soldFood: false, }; } restaurant.prototype.buy_food = function() { private_buy_food(this); } restaurant.prototype.use_restroom = function() { private_take_a_shit.call(this); } return restaurant; })() // TEST: var McDonalds = new Restaurant(); McDonalds.buy_food(); McDonalds.use_restroom(); console.log(McDonalds); console.log(McDonalds.__proto__); 

Here's what i enjoyed the most so far regarding private/public methods/members and instantiation in javascript:

here is the article: http://www.sefol.com/?p=1090

and here is the example:

 var Person = (function () { //Immediately returns an anonymous function which builds our modules return function (name, location) { alert("createPerson called with " + name); var localPrivateVar = name; var localPublicVar = "A public variable"; var localPublicFunction = function () { alert("PUBLIC Func called, private var is :" + localPrivateVar) }; var localPrivateFunction = function () { alert("PRIVATE Func called ") }; var setName = function (name) { localPrivateVar = name; } return { publicVar: localPublicVar, location: location, publicFunction: localPublicFunction, setName: setName } } })(); //Request a Person instance - should print "createPerson called with ben" var x = Person("ben", "germany"); //Request a Person instance - should print "createPerson called with candide" var y = Person("candide", "belgium"); //Prints "ben" x.publicFunction(); //Prints "candide" y.publicFunction(); //Now call a public function which sets the value of a private variable in the x instance x.setName("Ben 2"); //Shouldn't have changed this : prints "candide" y.publicFunction(); //Should have changed this : prints "Ben 2" x.publicFunction(); 

JSFiddle: http://jsfiddle.net/northkildonan/kopj3dt3/1/

I know it's a bit too late but how about this?

 var obj = function(){ var pr = "private"; var prt = Object.getPrototypeOf(this); if(!prt.hasOwnProperty("showPrivate")){ prt.showPrivate = function(){ console.log(pr); } } } var i = new obj(); i.showPrivate(); console.log(i.hasOwnProperty("pr")); 

There are many answers on this question already, but nothing fitted my needs. So i came up with my own solution, I hope it is usefull for someone:

 function calledPrivate(){ var stack = new Error().stack.toString().split("\n"); function getClass(line){ var i = line.indexOf(" "); var i2 = line.indexOf("."); return line.substring(i,i2); } return getClass(stack[2])==getClass(stack[3]); } class Obj{ privateMethode(){ if(calledPrivate()){ console.log("your code goes here"); } } publicMethode(){ this.privateMethode(); } } var obj = new Obj(); obj.publicMethode(); //logs "your code goes here" obj.privateMethode(); //does nothing 

As you can see this system works when using this type of classes in javascript. As far as I figured out none of the methods commented above did.

See this answer for aa clean & simple 'class' solution with a private and public interface and support for composition