Funzioni statiche private in javascript

Question

Come posso creare una funzione che non può essere chiamata dall'esterno?

var obj = { 
    function1: function(){ 
     alert("function1"); 
    }, 
    function2: function(){ 
     alert("function2..."); 
     obj.function1(); 
    } 
}; 
// so how to make this function unaccessible 
obj.function1(); 
// and you could only call this function 
obj.function2(); 

Answer 1

Si consiglia di prendere in considerazione l'utilizzo di Yahoo Module Pattern. Si tratta di un pattern Singleton, ei metodi non sono realmente statica, ma può essere quello che stai cercando:

var obj = (function() { 

    //"private" variables: 
    var myPrivateVar = "I can be accessed only from within obj."; 

    //"private" method: 
    var myPrivateMethod = function() { 
     console.log("I can be accessed only from within obj"); 
    }; 

    return { 
     myPublicVar: "I'm accessible as obj.myPublicVar", 

     myPublicMethod: function() { 
     console.log("I'm accessible as obj.myPublicMethod"); 

     //Within obj, I can access "private" vars and methods: 
     console.log(myPrivateVar); 
     console.log(myPrivateMethod()); 
     } 
    }; 
})(); 

di definire le componenti private in cui sono definite myPrivateVar e myPrivateMethod, e le vostre membra pubblici dove myPublicVar e myPublicMethod sono definiti.

Si può semplicemente accedere ai metodi e le proprietà pubbliche come segue:

obj.myPublicMethod(); // Works 
obj.myPublicVar;   // Works 
obj.myPrivateMethod(); // Doesn't work - private 
obj.myPrivateVar;  // Doesn't work - private 

Answer 2

È possibile utilizzare una chiusura, qualcosa sulla falsariga di ....

var construct = function() { 

    var obj = {}; 

    var method1 = function() { 
     alert("method1"); 
    } 

    obj.method2 = function() { 
     alert("method2..."); 
     method1(); 
    } 

    return obj; 
} 

obj = construct(); 

Poi:

obj.method2 è accessibile, ma obj.method1 non esiste per l'utilizzo pubblico. È possibile accedervi solo utilizzando le funzioni membro della classe.

Answer 3

La semplice risposta è che non è possibile eseguire entrambi. È possibile creare metodi "private" o metodi "static", ma non è possibile creare Funzioni statiche private come in altre lingue.

Il modo in cui è possibile emulare la privacy è chiusura:

function f() { 

    function inner(){} 

    return { 
    publicFn: function() {}, 
    publicFn2: function() {} 
    } 
} 

qui a causa della chiusura, la funzione inner verrà creato ogni volta che si chiama f, e le funzioni pubbliche può acces questa funzione inner , ma per il mondo esterno inner sarà nascosto.

Il modo in cui si creano metodi statici di un oggetto è semplice:

function f() {} 

f.staticVar = 5; 
f.staticFn = function() {}; 
// or 
f.prototype.staticFn = function() {}; 

Qui l'oggetto funzione f avrà un solo staticFn che ha accesso al statici variabili, ma nulla dalle istanze.

Si noti che la versione prototype verrà ereditata mentre la prima non lo sarà.

Quindi, si crea un metodo privato che non accede a nessun elemento dalle istanze o si crea un metodo statico a cui non si tenta di accedere dall'esterno.

Answer 4

oggetti possono essere prodotte da costruttori , che sono funzioni che inizializzano oggetti. I costruttori forniscono le funzionalità fornite dalle classi in altri linguaggi, tra cui variabili e metodi statici.

Leggi tutto su di esso a http://www.crockford.com/javascript/private.html

Answer 5

Si può fare in questo modo:

var obj = new function() { 
    var method1 = function() { // private } 
    this.method2 = function() { // public } 
} 

obj.method1(); // not possible 
obj.method2(); // possible 

Nota che anche io uso un costruttore anonimo. Questo è analogo al modello di Singleton.

Answer 6

Forse si desidera un oggetto proxy contenente solo i metodi pubblici, ad es.

var obj = (function() { 
    var obj = { 
    method1: function(){ 
     alert("method1"); 
    }, 
    method2: function(){ 
     alert("method2..."); 
     obj.method1(); 
    } 
    } 
    return { 
    method2: function() { return obj.method2.apply(obj, arguments) } 
    } 
})() 

// you could only call this function 
obj.method2(); 
// this function inaccessible 
obj.method1(); 

Non vedo il punto dei metodi privati ​​in javascript. Se non vuoi che le persone chiamino un metodo, allora non pubblicizzarlo. Anche i metodi privati ​​rendono il debugging un po 'più difficile.