Per creare una classe JavaScript con un metodo pubblico farei qualcosa del tipo:

function Restaurant() {}

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

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

In questo modo gli utenti della mia classe possono:

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

Come faccio a creare un metodo privato che può essere chiamato dai metodi buy_foode use_restroomma non esternamente dagli utenti della classe?

In altre parole, voglio che la mia implementazione del metodo sia in grado di fare:

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

Ma questo non dovrebbe funzionare:

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

Come definisco private_stuffun metodo privato in modo che entrambi siano veri?

Ho letto lo scritto di Doug Crockford alcune volte, ma non sembra che i metodi "privati" possano essere chiamati con metodi pubblici e che i metodi "privilegiati" possano essere chiamati esternamente.

Puoi farlo, ma il rovescio della medaglia è che non può far parte del prototipo:

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

Utilizzo della funzione e della chiamata auto invocanti

JavaScript utilizza prototipi e non ha classi (o metodi a tale proposito) come i linguaggi orientati agli oggetti. Uno sviluppatore JavaScript deve pensare in JavaScript.

Citazione di Wikipedia:

A differenza di molti linguaggi orientati agli oggetti, non esiste alcuna distinzione tra una definizione di funzione e una definizione di metodo. Piuttosto, la distinzione si verifica durante la chiamata di funzione; quando una funzione viene chiamata come metodo di un oggetto, la funzione locale questa parola chiave viene associata a quell'oggetto per quell'invocazione.

Soluzione che utilizza una funzione auto-invocante e la funzione call per chiamare il "metodo" privato:

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

La funzione di chiamata ci consente di chiamare la funzione privata con il contesto appropriato ( this).

Più semplice con Node.js

Se stai usando node.js , non hai bisogno di IIFE perché puoi sfruttare il sistema di caricamento del modulo :

function MyObject (foo) {
    this._foo = foo;
}

function privateFun (prefix) {
    return prefix + this._foo;
}

MyObject.prototype.publicFun = function () {
    return privateFun.call(this, '>>');
}

exports.MyObject = MyObject;

Carica il file:

var MyObject = require('./MyObject').MyObject;

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

(sperimentale) ES7 con Bind Operator

L'operatore di bind ::è una proposta ECMAScript ed è implementato in Babel ( fase 0 ).

export default class MyObject {
  constructor (foo) {
    this._foo = foo;
  }

  publicFun () {
    return this::privateFun('>>');
  }
}

function privateFun (prefix) {
  return prefix + this._foo;
}

Carica il file:

import MyObject from './MyObject';

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

Puoi simulare metodi privati ​​come questo:

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

Maggiori informazioni su questa tecnica qui: http://webreflection.blogspot.com/2008/04/natural-javascript-private-methods.html

In queste situazioni, quando si dispone di un'API pubblica e si desidera metodi / proprietà privati ​​e pubblici, utilizzo sempre il modello del modulo. Questo modello è stato reso popolare all'interno della libreria YUI e i dettagli sono disponibili qui:

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

È davvero semplice e facile da comprendere per gli altri sviluppatori. Per un semplice esempio:

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

Ecco la classe che ho creato per capire cosa ha suggerito Douglas Crockford nel suo sito Private Members in JavaScript

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

}

Ho evocato questo: EDIT: In realtà, qualcuno ha collegato a una soluzione identica. Duh!

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!'

Penso che tali domande sorgano ancora e ancora a causa della mancanza di comprensione delle chiusure. Le chiusure sono la cosa più importante in JS. Ogni programmatore JS deve sentirne l'essenza.

1. Prima di tutto dobbiamo creare un ambito separato (chiusura).

function () {

}

2. In quest'area, possiamo fare quello che vogliamo. E nessuno lo saprà.

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. Perché il mondo sia a conoscenza della nostra lezione di ristorazione, dobbiamo restituirla dalla chiusura.

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

4. Alla fine, abbiamo:

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. Inoltre, questo approccio ha il potenziale per l'ereditarietà e il templating

// 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')

Spero che questo aiuti qualcuno a capire meglio questo argomento

Personalmente, preferisco il seguente modello per la creazione di classi in JavaScript:

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

Come puoi vedere, ti permette di definire sia le proprietà di classe sia le proprietà di istanza, ognuna delle quali può essere pubblica e privata.

dimostrazione

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

Vedi anche questo violino .

Tutta questa chiusura ti costerà. Assicurati di testare le implicazioni sulla velocità soprattutto in IE. Scoprirai che stai meglio con una convenzione di denominazione. Ci sono ancora molti utenti Web aziendali che sono costretti a utilizzare IE6 ...

Non essere così prolisso. È Javascript. Usa una convenzione di denominazione .

Dopo anni di lavoro in classi es6, di recente ho iniziato a lavorare su un progetto es5 (usando RequireS che è già molto dettagliato). Sono stato ripetutamente tutte le strategie menzionate qui e praticamente tutto si riduce a usare una convenzione di denominazione :

1. Javascript non ha parole chiave dell'ambito come private. Altri sviluppatori che accedono a Javascript lo sapranno in anticipo. Pertanto, una semplice convenzione di denominazione è più che sufficiente. Una semplice convenzione di denominazione del prefisso con un trattino basso risolve il problema sia delle proprietà private che dei metodi privati.
2. Approfittiamo del prototipo per motivi di velocità, ma non lasciamoci più prolisso. Proviamo a mantenere la "classe" es5 molto simile a ciò che potremmo aspettarci in altre lingue di backend (e trattiamo ogni file come una classe, anche se non è necessario restituire un'istanza).
3. Dimostriamo con una situazione di modulo più realistica (useremo i vecchi es5 e i vecchi requestJs).

my-tooltip.js

    define([
        'tooltip'
    ],
    function(
        tooltip
    ){

        function MyTooltip() {
            // Later, if needed, we can remove the underscore on some
            // of these (make public) and allow clients of our class
            // to set them.
            this._selector = "#my-tooltip"
            this._template = 'Hello from inside my tooltip!';
            this._initTooltip();
        }

        MyTooltip.prototype = {
            constructor: MyTooltip,

            _initTooltip: function () {
                new tooltip.tooltip(this._selector, {
                    content: this._template,
                    closeOnClick: true,
                    closeButton: true
                });
            }
        }

        return {
            init: function init() {
               new MyTooltip();  // <-- Our constructor adds our tooltip to the DOM so not much we need to do after instantiation.
            }

            // You could instead return a new instantiation, 
            // if later you do more with this class.
            /* 
            create: function create() {
               return new MyTooltip();
            }
            */
        }
    });

Puoi farlo ora con i metodi privati ​​es10 . Devi solo aggiungere un #prima del nome del metodo.

class ClassWithPrivateMethod {
  #privateMethod() {
    return 'hello world';
  }

  getPrivateMessage() {
    return #privateMethod();
  }
}

Prendi una delle soluzioni che seguono il modello privato o privilegiato di Crockford . Per esempio:

function Foo(x) {
    var y = 5;
    var bar = function() {
        return y * x;
    };

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

In ogni caso in cui l'attaccante non ha diritto di "esecuzione" sul contesto JS, non ha modo di accedere a campi o metodi "pubblici" o "privati". Nel caso in cui l'attaccante abbia tale accesso, può eseguire questo one-liner:

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

Si noti che il codice sopra è generico per tutta la privacy di tipo costruttore. Fallirà con alcune delle soluzioni qui, ma dovrebbe essere chiaro che praticamente tutte le soluzioni basate sulla chiusura possono essere rotte in questo modo con replace()parametri diversi .

Dopo che questo è stato eseguito, qualsiasi oggetto creato con new Foo()avrà un evalmetodo che può essere chiamato per restituire o modificare valori o metodi definiti nella chiusura del costruttore, ad esempio:

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

L'unico problema che posso vedere con questo è che non funzionerà nei casi in cui esiste solo un'istanza ed è stata creata al caricamento. Ma poi non c'è motivo di definire effettivamente un prototipo e in tal caso l'attaccante può semplicemente ricreare l'oggetto invece del costruttore purché abbia un modo di passare gli stessi parametri (ad esempio, sono costanti o calcolati dai valori disponibili).

Secondo me, questo rende praticamente inutile la soluzione di Crockford. Dal momento che la "privacy" si rompe facilmente, gli aspetti negativi della sua soluzione (leggibilità e manutenibilità ridotte, prestazioni ridotte, memoria aumentata) rendono il metodo basato sul prototipo "nessuna privacy" la scelta migliore.

Io di solito uso di sottolineatura per contrassegnare leader __privatee _protectedmetodi e campi (stile Perl), ma l'idea di avere privacy in JavaScript solo mostra come si tratta di un linguaggio incompreso.

Pertanto non sono d'accordo con Crockford, fatta eccezione per la sua prima frase.

Quindi, come si ottiene la vera privacy in JS? Metti tutto ciò che è necessario per essere privato sul lato server e usa JS per fare chiamate AJAX.

L'apoteosi del modello di modulo: il modello di modulo rivelatore

Una piccola estensione ordinata a un modello molto robusto.

Se si desidera l'intera gamma di funzioni pubbliche e private con la possibilità per le funzioni pubbliche di accedere a funzioni private, codice layout per un oggetto come questo:

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

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

Simile a georgebrock ma un po 'meno prolisso (IMHO) Qualche problema nel farlo in questo modo? (Non l'ho visto da nessuna parte)

modifica: mi sono reso conto che questo è un po 'inutile poiché ogni istanza indipendente ha la sua copia dei metodi pubblici, minando così l'uso del prototipo.

Ecco cosa mi è piaciuto di più finora riguardo ai metodi / membri privati ​​/ pubblici e all'istanza in javascript:

ecco l'articolo: http://www.sefol.com/?p=1090

ed ecco l'esempio:

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/

Il modello del modulo è corretto nella maggior parte dei casi. Ma se hai migliaia di istanze, le classi risparmiano memoria. Se il risparmio di memoria è un problema e i tuoi oggetti contengono una piccola quantità di dati privati, ma hanno molte funzioni pubbliche, allora vorrai che tutte le funzioni pubbliche vivano nel prototipo per risparmiare memoria.

Questo è quello che mi è venuto in mente:

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

L'oggetto privcontiene proprietà private. È accessibile tramite la funzione pubblica getPriv(), ma questa funzione ritorna a falsemeno che non la passi secret, e questo è noto solo all'interno della chiusura principale.

Che dire di questo?

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;

})();

La ricerca di variabili private è impossibile al di fuori dell'ambito della funzione immediata. Non c'è duplicazione di funzioni, risparmiando memoria.

Il rovescio della medaglia è che la ricerca di variabili private è goffa privateVars[this.id].cookedè ridicola da digitare. C'è anche una variabile "id" aggiuntiva.

Avvolgi tutto il codice in Funzione anonima: Quindi, tutte le funzioni saranno private, SOLO funzioni associate windowall'oggetto:

(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,{});

Usa questo :

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

VIOLINO

Preferisco archiviare dati privati ​​in un associato WeakMap. Ciò consente di mantenere i metodi pubblici sul prototipo a cui appartengono. Questo sembra essere il modo più efficiente per gestire questo problema per un gran numero di oggetti.

const data = new WeakMap();

function Foo(value) {
    data.set(this, {value});
}

// public method accessing private value
Foo.prototype.accessValue = function() {
    return data.get(this).value;
}

// private 'method' accessing private value
function accessValue(foo) {
    return data.get(foo).value;
}

export {Foo};

Le funzioni private non possono accedere alle variabili pubbliche utilizzando il modello di modulo

Dato che tutti pubblicavano qui il proprio codice, lo farò anch'io ...

Mi piace Crockford perché ha introdotto modelli reali orientati agli oggetti in Javascript. Ma ha anche escogitato un nuovo fraintendimento, quello "quello".

Quindi perché usa "that = this"? Non ha nulla a che fare con le funzioni private. Ha a che fare con le funzioni interne!

Perché secondo Crockford questo è un codice errato:

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

Quindi ha suggerito di fare questo:

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

Quindi, come ho detto, sono abbastanza sicuro che Crockford avesse sbagliato la sua spiegazione su questo e questo (ma il suo codice è certamente corretto). O stava solo ingannando il mondo Javascript, per sapere chi stava copiando il suo codice? Non so ... Non sono un fanatico del browser; D

MODIFICARE

Ah, questo è tutto: cosa significa 'var that = this;' intendi in JavaScript?

Quindi Crockie aveva davvero torto con la sua spiegazione ... ma proprio con il suo codice, quindi è ancora un ragazzo eccezionale. :))

In generale ho aggiunto temporaneamente l'oggetto privato _ all'oggetto. Devi aprire la privacy in modo esplicito nel "Costruttore di potenza" per il metodo. Se chiami il metodo dal prototipo, sarai in grado di sovrascrivere il metodo prototipo

• Rendi accessibile un metodo pubblico nel "Costruttore di potenza": (ctx è il contesto dell'oggetto)

  ctx.test = GD.Fabric.open('test', GD.Test.prototype, ctx, _); // is a private object

• Ora ho questo openPrivacy:

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

Questo è quello che ho elaborato:

Ha bisogno di una classe di codice zucchero che puoi trovare qui . Supporta anche roba protetta, ereditaria, virtuale, statica ...

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

Ho creato un nuovo strumento per consentirti di avere veri metodi privati ​​sul prototipo https://github.com/TremayneChrist/ProtectJS

Esempio:

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

Devi mettere una chiusura attorno alla tua vera funzione di costruzione, dove puoi definire i tuoi metodi privati. Per modificare i dati delle istanze attraverso questi metodi privati, devi dare loro "questo" con loro, sia come argomento di funzione o chiamando questa funzione con .apply (questo):

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

So che è un po 'troppo tardi, ma che ne dici?

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

Ci sono già molte risposte a questa domanda, ma nulla soddisfa i miei bisogni. Quindi ho trovato la mia soluzione, spero sia utile per qualcuno:

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

Come puoi vedere, questo sistema funziona quando si utilizza questo tipo di classi in JavaScript. Per quanto ho capito nessuno dei metodi commentati sopra ha fatto.

Vedi questa risposta per una soluzione 'class' pulita e semplice con un'interfaccia pubblica e privata e supporto per la composizione